ollama/mlx/memory_test.go
Daniel Hiltgen 73ee71ddcc
mlxrunner: adapt saved history to memory pressure (#19678)
* mlxrunner: adapt saved history to memory pressure

Retain Metal prefix history using observed memory headroom and execution
workspace rather than a fixed 8 GiB allowance. Release unused buffers and
cold history when system compression grows, preserving reusable paths and
active requests.

Cover pressure reclamation, snapshot ownership, memory observation, and
cacheless request isolation.

* address comments

* address comments
2026-11-19 15:41:42 -08:00

93 lines
2.3 KiB
Go

package mlx
import (
"errors"
"fmt"
"math"
"slices"
"testing"
"github.com/ollama/ollama/mlx/mlxthread/mlxthreadtest"
)
func TestSetWiredLimitRejectsOversizeWithoutChangingLimit(t *testing.T) {
withMLXThread(t, func(t *mlxthreadtest.T) {
if !GPUIsAvailable() {
t.Skip("MLX GPU not available")
}
if err := checkWiredLimitRejectsOversize(); err != nil {
t.Fatal(err)
}
})
}
func checkWiredLimitRejectsOversize() (err error) {
maxRecommended, err := MaxRecommendedWorkingSetSize()
if err != nil {
return err
}
if maxRecommended == math.MaxInt {
return errors.New("recommended working set cannot be exceeded by an int")
}
previous, err := SetWiredLimit(maxRecommended)
if err != nil {
return err
}
defer func() {
if _, restoreErr := SetWiredLimit(previous); restoreErr != nil {
err = errors.Join(err, fmt.Errorf("restore wired limit: %w", restoreErr))
}
}()
if _, err := SetWiredLimit(maxRecommended + 1); err == nil {
return errors.New("SetWiredLimit accepted a limit above the recommended working set")
}
current, err := SetWiredLimit(maxRecommended)
if err != nil {
return err
}
if current != maxRecommended {
return fmt.Errorf("wired limit after rejected update = %d, want %d", current, maxRecommended)
}
a := FromValues([]float32{1, 2, 3, 4}, 2, 2)
b := Matmul(a, a)
Eval(b)
if got, want := b.Floats(), []float32{7, 10, 15, 22}; !slices.Equal(got, want) {
return fmt.Errorf("evaluation after rejected update = %v, want %v", got, want)
}
return nil
}
func TestMeasurePeakMemoryPreservesReportingPeak(t *testing.T) {
withMLXThread(t, func(t *mlxthreadtest.T) {
if !GPUIsAvailable() {
t.Skip("GPU allocator counters required")
}
ResetPeakMemory()
before := ActiveMemory()
large := MeasurePeakMemory(func() {
Scoped(func() { Eval(Zeros(DTypeFloat32, 4096)) })
})
DefaultStream().Synchronize()
if large <= before {
t.Fatal("fixture did not allocate")
}
small := MeasurePeakMemory(func() {
Scoped(func() { Eval(Zeros(DTypeFloat32, 4)) })
})
if small >= large {
t.Fatalf("small interval peak %d must be below %d", small, large)
}
if got := PeakMemory(); got != large {
t.Fatalf("cumulative peak = %d, want %d", got, large)
}
DefaultStream().Synchronize()
ResetPeakMemory()
if got := PeakMemory(); got >= large {
t.Fatalf("reset kept prior interval peak: %d", got)
}
})
}