tests: ALRU inertia: don't clean below threshold

Co-authored-by: aider (gpt-5) <aider@aider.chat>
Signed-off-by: Michal Mielewczyk <michal.mielewczyk@huawei.com>

Author: mmichal10

test/functional/tests/lazy_writes/cleaning_policy/test_alru.py

@@ -1,6 +1,6 @@
 #
 # Copyright(c) 2020-2021 Intel Corporation
-# Copyright(c) 2024 Huawei Technologies Co., Ltd.
+# Copyright(c) 2024-2025 Huawei Technologies Co., Ltd.
 # SPDX-License-Identifier: BSD-3-Clause
 #
 
@@ -10,12 +10,18 @@
 from datetime import timedelta
 
 from api.cas import casadm
-from api.cas.cache_config import CacheMode, CleaningPolicy, FlushParametersAlru, SeqCutOffPolicy
+from api.cas.cache_config import (
+    CacheMode,
+    CleaningPolicy,
+    FlushParametersAlru,
+    SeqCutOffPolicy,
+    CacheLineSize,
+)
 from core.test_run import TestRun
 from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
 from test_tools.fio.fio import Fio
 from test_tools.fio.fio_param import ReadWrite, IoEngine
-from test_tools.os_tools import kill_all_io
+from test_tools.os_tools import kill_all_io, sync
 from test_tools.udev import Udev
 from type_def.size import Size, Unit
 from type_def.time import Time
@@ -118,3 +124,86 @@ def prepare():
     )
 
     return cache, core
+
+
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+@pytest.mark.parametrize("inertia", [Size.zero(), Size(1500, Unit.MiB)])
+@pytest.mark.parametrizex(
+    "cache_line_size",
+    [CacheLineSize.LINE_4KiB, CacheLineSize.LINE_64KiB],
+)
+def test_alru_dirty_ratio_inertia_no_cleaning_below_threshold(cache_line_size, inertia):
+    """
+    title: Test ALRU dirty ratio inertia — no cleaning below threshold
+    description: |
+      Verify that with ALRU cleaning and a dirty ratio threshold of 90%, the cache does not
+      perform cleaning while dirty data stays below the threshold when inertia is specified in MiB.
+      Configure long ALRU wake-up, staleness, and activity thresholds to avoid periodic cleaning.
+      Generate about 2 GiB of dirty data (~66% of a 3 GiB cache), then idle; Dirty cache lines are not flushed.
+      Run with inertia values 0 MiB and 1500 MiB.
+    pass_criteria:
+      - The cleaning is not triggered when dirty data doesn't exceed the specified threshold.
+    """
+    with TestRun.step("Prepare 3GiB cache and 10GiB core, start cache WB, add core, set ALRU"):
+        cache_dev = TestRun.disks["cache"]
+        core_dev = TestRun.disks["core"]
+
+        cache_dev.create_partitions([Size(3, Unit.GiB)])
+        core_dev.create_partitions([Size(10, Unit.GiB)])
+
+        Udev.disable()
+        cache = casadm.start_cache(
+            cache_dev.partitions[0],
+            cache_line_size=cache_line_size,
+            force=True,
+            cache_mode=CacheMode.WB,
+        )
+        core = cache.add_core(core_dev.partitions[0])
+
+        cache.set_seq_cutoff_policy(SeqCutOffPolicy.never)
+        cache.set_cleaning_policy(CleaningPolicy.alru)
+
+    with TestRun.step(
+        f"Set threshold=90%, inertia={inertia}. Staleness=3600s to avoid accidental cleaning, wake_up=1s to ensure the cleaning thread has been woken up"
+    ):
+        dirty_ratio_threshold = 90
+        casadm.set_param_cleaning_alru(
+            cache_id=cache.cache_id,
+            wake_up=1,
+            flush_max_buffers=100,
+            staleness_time=3600,
+            activity_threshold=1000,
+            dirty_ratio_threshold=dirty_ratio_threshold,
+            dirty_ratio_inertia=inertia,
+        )
+
+    with TestRun.step("Run write workload to reach ~2GiB (≈66% of 3GiB) dirty data"):
+        (
+            Fio()
+            .create_command()
+            .io_engine(IoEngine.libaio)
+            .size(Size(2, Unit.GiB))
+            .block_size(Size(4, Unit.KiB))
+            .target(core)
+            .direct()
+            .read_write(ReadWrite.randwrite)
+            .run()
+        )
+        sync()
+
+    with TestRun.step("Capture baseline dirty usage after I/O settles"):
+        time.sleep(2)
+        dirty_before = cache.get_statistics().usage_stats.dirty
+
+    with TestRun.step("Idle and verify dirty cache lines do not change and remain below threshold"):
+        time.sleep(30)
+        dirty_after = cache.get_statistics().usage_stats.dirty
+
+        if dirty_after < dirty_after:
+            TestRun.fail(
+                f"No flushing shall occur when dirty < threshold (dirty before={dirty_before}, dirty after={dirty_after}, threshold={dirty_ratio_threshold}%)"
+            )
+
+    with TestRun.step("Stop cache"):
+        casadm.stop_cache(cache.cache_id)