test(*): add unit test related to watermark

Author: JulyWindK

cmd/katalyst-agent/app/options/dynamic/userwatermark/user_watermark_base_test.go

@@ -0,0 +1,67 @@
+/*
+Copyright 2022 The Katalyst Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package userwatermark
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	cliflag "k8s.io/component-base/cli/flag"
+
+	dynamicuserwm "github.com/kubewharf/katalyst-core/pkg/config/agent/dynamic/userwatermark"
+)
+
+func TestNewUserWatermarkOptions(t *testing.T) {
+	t.Parallel()
+
+	opts := NewUserWatermarkOptions()
+	assert.NotNil(t, opts)
+	assert.NotNil(t, opts.DefaultOptions)
+}
+
+func TestUserWatermarkOptions_AddFlags(t *testing.T) {
+	t.Parallel()
+
+	opts := NewUserWatermarkOptions()
+	fss := &cliflag.NamedFlagSets{}
+
+	opts.AddFlags(fss)
+	fs := fss.FlagSet("user-watermark")
+	assert.NotNil(t, fs.Lookup("enable-user-watermark-reclaimer"))
+	assert.NotNil(t, fs.Lookup("user-watermark-reconcile-interval"))
+	assert.NotNil(t, fs.Lookup("user-watermark-pod-service-label"))
+}
+
+func TestUserWatermarkOptions_ApplyTo(t *testing.T) {
+	t.Parallel()
+
+	opts := &UserWatermarkOptions{
+		EnableReclaimer:   true,
+		ReconcileInterval: 10,
+		ServiceLabel:      "service-label",
+		DefaultOptions:    NewUserWatermarkOptions().DefaultOptions,
+	}
+
+	conf := dynamicuserwm.NewUserWatermarkConfiguration()
+	err := opts.ApplyTo(conf)
+
+	assert.NoError(t, err)
+	assert.True(t, conf.EnableReclaimer)
+	assert.Equal(t, int64(10), conf.ReconcileInterval)
+	assert.Equal(t, "service-label", conf.ServiceLabel)
+	assert.NotNil(t, conf.DefaultConfig)
+}

cmd/katalyst-agent/app/options/dynamic/userwatermark/userwatermarkdefault/user_watermark_default_config_test.go

@@ -0,0 +1,96 @@
+/*
+Copyright 2022 The Katalyst Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package userwatermarkdefault
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	cliflag "k8s.io/component-base/cli/flag"
+
+	v1alpha1 "github.com/kubewharf/katalyst-api/pkg/apis/config/v1alpha1"
+	dynamicuserwm "github.com/kubewharf/katalyst-core/pkg/config/agent/dynamic/userwatermark"
+)
+
+func TestNewDefaultOptions(t *testing.T) {
+	t.Parallel()
+
+	opts := NewDefaultOptions()
+	assert.NotNil(t, opts)
+}
+
+func TestDefaultOptions_AddFlags(t *testing.T) {
+	t.Parallel()
+
+	opts := NewDefaultOptions()
+	fss := &cliflag.NamedFlagSets{}
+
+	opts.AddFlags(fss)
+
+	fs := fss.FlagSet("user-watermark")
+
+	assert.NotNil(t, fs.Lookup("enable-user-watermark-memory-reclaim"))
+	assert.NotNil(t, fs.Lookup("user-watermark-reclaim-interval"))
+	assert.NotNil(t, fs.Lookup("user-watermark-scale-factor"))
+	assert.NotNil(t, fs.Lookup("user-watermark-single-reclaim-size"))
+	assert.NotNil(t, fs.Lookup("user-watermark-single-reclaim-factor"))
+	assert.NotNil(t, fs.Lookup("user-watermark-backoff-duration"))
+
+	assert.NotNil(t, fs.Lookup("user-watermark-feedback-policy"))
+	assert.NotNil(t, fs.Lookup("user-watermark-reclaim-failed-threshold"))
+	assert.NotNil(t, fs.Lookup("user-watermark-failure-freeze-period"))
+	assert.NotNil(t, fs.Lookup("user-watermark-psi-avg60-threshold"))
+	assert.NotNil(t, fs.Lookup("user-watermark-reclaim-accuracy-target"))
+	assert.NotNil(t, fs.Lookup("user-watermark-reclaim-scan-efficiency-target"))
+}
+
+func TestDefaultOptions_ApplyTo(t *testing.T) {
+	t.Parallel()
+
+	opts := &DefaultOptions{
+		EnableMemoryReclaim: true,
+		ReclaimInterval:     5,
+		ScaleFactor:         200,
+		SingleReclaimFactor: 0.5,
+		SingleReclaimSize:   1 << 20,
+		BackoffDuration:     10,
+		FeedbackPolicy:      string(v1alpha1.UserWatermarkPolicyNamePSI),
+
+		ReclaimFailedThreshold:      3,
+		FailureFreezePeriod:         20,
+		PsiAvg60Threshold:           1.0,
+		ReclaimAccuracyTarget:       0.8,
+		ReclaimScanEfficiencyTarget: 0.5,
+	}
+
+	conf := &dynamicuserwm.UserWatermarkDefaultConfiguration{}
+	err := opts.ApplyTo(conf)
+
+	assert.NoError(t, err)
+	assert.True(t, conf.EnableMemoryReclaim)
+	assert.Equal(t, int64(5), conf.ReclaimInterval)
+	assert.Equal(t, uint64(200), conf.ScaleFactor)
+	assert.Equal(t, 0.5, conf.SingleReclaimFactor)
+	assert.Equal(t, uint64(1<<20), conf.SingleReclaimSize)
+	assert.Equal(t, opts.BackoffDuration, conf.BackoffDuration)
+	assert.Equal(t, v1alpha1.UserWatermarkPolicyNamePSI, conf.FeedbackPolicy)
+	assert.Equal(t, uint64(3), conf.ReclaimFailedThreshold)
+	assert.Equal(t, opts.FailureFreezePeriod, conf.FailureFreezePeriod)
+	assert.Equal(t, opts.PsiAvg60Threshold, conf.PsiAvg60Threshold)
+	assert.Equal(t, opts.ReclaimAccuracyTarget, conf.ReclaimAccuracyTarget)
+	assert.Equal(t, opts.ReclaimScanEfficiencyTarget, conf.ReclaimScanEfficiencyTarget)
+}

pkg/agent/qrm-plugins/memory/dynamicpolicy/userwatermark/calculator_test.go

@@ -0,0 +1,146 @@
+/*
+Copyright 2022 The Katalyst Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package userwatermark
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/kubewharf/katalyst-core/pkg/util/cgroup/common"
+)
+
+const (
+	TestCGroupPath = "/sys/fs/cgroup/test"
+
+	TestWatermarkScaleFactor = 100
+	TestSingleReclaimFactor  = 0.25
+	TestSingleReclaimSize    = 4096
+)
+
+var calculatorMutex sync.Mutex
+
+func NewDefaultMemoryWatermarkCalculator() *WatermarkCalculator {
+	return NewMemoryWatermarkCalculator(TestCGroupPath, TestWatermarkScaleFactor, TestSingleReclaimFactor, TestSingleReclaimSize)
+}
+
+func TestNewMemoryWatermarkCalculator(t *testing.T) {
+	t.Parallel()
+
+	calc := NewMemoryWatermarkCalculator(TestCGroupPath, TestWatermarkScaleFactor, TestSingleReclaimFactor, TestSingleReclaimSize)
+	assert.Equal(t, TestCGroupPath, calc.CGroupPath)
+	assert.Equal(t, uint64(TestWatermarkScaleFactor), calc.WatermarkScaleFactor)
+	assert.Equal(t, TestSingleReclaimFactor, calc.SingleReclaimFactor)
+	assert.Equal(t, uint64(TestSingleReclaimSize), calc.SingleReclaimSize)
+}
+
+func TestWatermarkCalculator_GetLowAndHighWatermark(t *testing.T) {
+	t.Parallel()
+
+	wmc := NewDefaultMemoryWatermarkCalculator()
+	capacity := uint64(1024 * 1024 * 1024) // 1GiB
+	low := wmc.GetLowWatermark(capacity)
+	high := wmc.GetHighWatermark(capacity)
+
+	expectedLow := uint64(float64(capacity * wmc.WatermarkScaleFactor / 10000))
+	expectedHigh := uint64(float64(capacity * 2 * wmc.WatermarkScaleFactor / 10000))
+
+	assert.Equal(t, expectedLow, low)
+	assert.Equal(t, expectedHigh, high)
+	assert.True(t, high >= low)
+}
+
+func TestWatermarkCalculator_GetReclaimTarget(t *testing.T) {
+	t.Parallel()
+
+	wmc := NewDefaultMemoryWatermarkCalculator()
+	memLimit := uint64(1000)
+
+	// case 1: reclaimTarget > reclaimableMax
+	memUsage := uint64(950)
+	reclaimableMax := uint64(300)
+
+	high := wmc.GetHighWatermark(memLimit)
+	free := memLimit - memUsage
+	expected := high - free
+
+	if expected > reclaimableMax {
+		expected = reclaimableMax
+	}
+	got := wmc.GetReclaimTarget(memLimit, memUsage, reclaimableMax)
+	assert.Equal(t, expected, got)
+
+	// case 2: reclaimTarget < reclaimableMax
+	memUsage = 900
+	reclaimableMax = 999
+
+	high = wmc.GetHighWatermark(memLimit)
+	free = memLimit - memUsage
+	expected = high - free
+
+	if expected > reclaimableMax {
+		expected = reclaimableMax
+	}
+
+	got = wmc.GetReclaimTarget(memLimit, memUsage, reclaimableMax)
+	assert.Equal(t, expected, got)
+
+	// case 3: reclaimTarget == reclaimableMax
+	memUsage = 800
+	reclaimableMax = 900
+
+	high = wmc.GetHighWatermark(memLimit)
+	free = memLimit - memUsage
+	expected = high - free
+
+	if expected > reclaimableMax {
+		expected = reclaimableMax
+	}
+
+	got = wmc.GetReclaimTarget(memLimit, memUsage, reclaimableMax)
+	assert.Equal(t, expected, got)
+}
+
+func TestWatermarkCalculator_GetWatermark(t *testing.T) {
+	t.Parallel()
+
+	wmc := &WatermarkCalculator{WatermarkScaleFactor: 100}
+
+	capacity := uint64(1024)
+
+	low, high := wmc.GetWatermark(capacity)
+	assert.Equal(t, wmc.GetLowWatermark(capacity), low)
+	assert.Equal(t, wmc.GetHighWatermark(capacity), high)
+}
+
+func TestWatermarkCalculator_GetReclaimMax(t *testing.T) {
+	t.Parallel()
+
+	memStats := common.MemoryStats{
+		InactiveFile: 100,
+		ActiveFile:   50,
+		InactiveAnno: 200,
+		ActiveAnno:   70,
+	}
+
+	wmc := &WatermarkCalculator{SwapEnabled: false}
+	assert.Equal(t, uint64(150), wmc.GetReclaimMax(memStats))
+
+	wmc.SwapEnabled = true
+	assert.Equal(t, uint64(420), wmc.GetReclaimMax(memStats))
+}