test: ALRU: clean below (threshold - inertia)

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

@@ -211,3 +211,122 @@ def test_alru_dirty_ratio_inertia_no_cleaning_if_dirty_below_threshold(cache_lin
                 f"No flushing shall occur when dirty < threshold (dirty before={dirty_before}, "
                 f"dirty after={dirty_after}, threshold={dirty_ratio_threshold}%)"
             )
+
+
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+@pytest.mark.parametrize("inertia", [Size.zero(), Size(600, Unit.MiB)])
+def test_alru_dirty_threshold_cleans_until_threshold_minus_inertia(inertia):
+    """
+    title: Test ALRU threshold cleaning – start > 50%, stop at (threshold - inertia)
+    description: |
+      Verify that with ALRU cleaning configured with 50% dirty threshold and specified inertia in MiB,
+      cleaning starts when dirty exceeds the threshold and stops after reaching (threshold - inertia).
+    pass_criteria:
+      - Cleaning starts once dirty exceeds 50%.
+      - Dirty decreases over time after stopping I/O.
+      - Cleaning stops at or below (threshold - inertia).
+      - If dirty does not decrease for 20 consecutive checks, fail the test.
+    """
+
+    target_dirty_ratio_threshold = 50
+    # 3 GiB cache -> 50% = 1536 MiB; inertia is in MiB
+    threshold_size = Size(1536, Unit.MiB)
+    target_cleaning_threshold = threshold_size - inertia
+
+    with TestRun.step("Prepare 3GiB cache and 10GiB core, disable udev, start cache WB, add core"):
+        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)])
+
+    with TestRun.step("Disable udev"):
+        Udev.disable()
+
+    with TestRun.step("Start cache and add core"):
+        cache = casadm.start_cache(cache_dev.partitions[0], force=True, cache_mode=CacheMode.WB)
+        core = cache.add_core(core_dev.partitions[0])
+
+    with TestRun.step("Set ALRU and disable sequential cutoff"):
+        cache.set_seq_cutoff_policy(SeqCutOffPolicy.never)
+        cache.set_cleaning_policy(CleaningPolicy.alru)
+
+    with TestRun.step(
+        "Configure ALRU: dirty threshold=50%, inertia={inertia}, default wakeup, max staleness_time"
+    ):
+        cache.set_params_alru(
+            FlushParametersAlru(
+                staleness_time=Time(seconds=3600),
+                dirty_ratio_threshold=target_dirty_ratio_threshold,
+                dirty_ratio_inertia=inertia,
+            )
+        )
+
+    with TestRun.step("Start background fio (4 GiB randwrite)"):
+        (
+            Fio()
+            .create_command()
+            .io_engine(IoEngine.libaio)
+            .size(Size(4, Unit.GiB))
+            .block_size(Size(4, Unit.KiB))
+            .target(core)
+            .direct()
+            .read_write(ReadWrite.randwrite)
+            .run_in_background()
+        )
+
+    with TestRun.step("Wait until cache dirty >= 90%, then stop workload"):
+        start_ts = time.time()
+        while True:
+            time.sleep(2)
+            dirty_pct = cache.get_statistics(percentage_val=True).usage_stats.dirty
+            if dirty_pct >= 90:
+                break
+            if time.time() - start_ts > 5 * 60:
+                TestRun.LOGGER.exception(
+                    f"Cache dirty level did not reach 90% within 5 minutes "
+                    f"(current dirty={dirty_pct}%). Aborting test."
+                )
+                TestRun.fail(
+                    "TODO: For some reason the TestRun.LOGGER.exception doesn't interrupt the test, "
+                    "but only modifies the test status and continiues the execution. Until fixed, use TestRun.fail"
+                )
+
+    with TestRun.step("Make sure that the all IO has been completed"):
+        kill_all_io()
+        sync()
+
+    with TestRun.step(
+        "Observe cleaning: ensure monotonic decrease and stop at (threshold - inertia)"
+    ):
+        # Initial dirty after IO stop
+        last_dirty = cache.get_statistics().usage_stats.dirty
+
+        not_decreasing = 0
+        while last_dirty > target_cleaning_threshold:
+            time.sleep(5)
+            dirty_now = cache.get_statistics().usage_stats.dirty
+
+            if dirty_now < last_dirty:
+                not_decreasing = 0
+            else:
+                not_decreasing += 1
+                if not_decreasing >= 20:
+                    TestRun.fail(
+                            f"Exception: Dirty amount not decreasing for 20 consecutive checks "
+                            f"(stuck at {dirty_now}, target stop {target_cleaning_threshold})."
+                    )
+
+            last_dirty = dirty_now
+
+    with TestRun.step(
+        "Once the dirty cache lines counter reached (threshold - inertia) level, "
+        "no further cleaning should take place"
+    ):
+        time.sleep(30)
+        if last_dirty > target_cleaning_threshold:
+            TestRun.fail(
+                f"Cleaning did not stop at expected level "
+                f"(dirty={last_dirty}, expected <= {target_cleaning_threshold})."
+            )