[Feature]: Enhance cache eviction policy to support payload-size-aware eviction

[xiexiaoy]

• Summary (Provide a general summary of the issue in the Title above):

  Add a payload-size-aware cache eviction policy that cooperates with the
  existing LRU-based eviction policy, so that entries with large payloads
  are kept in memory longer than small entries.

• Detailed Description (Provide a detailed description of the change or
  addition you are proposing):

  EloqKV stores some very large values. When such a large value is evicted
  from the in-memory cache (cc map) and later requested again, it must be
  reloaded from disk — an expensive operation that hurts latency. The current
  LRU eviction policy treats all cache entries equally regardless of payload
  size, so a large value may be evicted well before its reload cost would
  justify doing so.

  The proposed enhancement introduces two new configuration knobs:

  • large_value_threshold (bytes, default 0 = disabled): entries
    whose PayloadSize() exceeds this threshold are candidates for
    large-value protection.
  • large_value_eviction_age (LRU access-counter units, default
    1000): the minimum LRU age that a page must accumulate before its
    large-value entries become eligible for eviction.

  The protection cooperates with — rather than replaces — the existing LRU
  policy:

  • Small entries continue to be evicted in normal LRU order.
  • Large entries are shielded from eviction while their page is "young"
    (recently accessed). Once the page has aged past
    large_value_eviction_age access-counter ticks without being touched,
    the protection is lifted and the entry can be evicted by the regular
    LRU scan.

  This means hot large values (pages that are accessed frequently) are never
  evicted, while cold large values are eventually evicted once they have been
  idle long enough.

• Software version (the version of the software you're running):

  main branch

• Possible Implementation (suggest an idea for implementing addition or
  change)

  • Add txservice_large_value_threshold (size_t) and
    txservice_large_value_eviction_age (uint64_t) inline variables to
    tx_service_common.h, defaulting to 0 and 1000 respectively.
  • Expose CcShard::AccessCounter() as a public getter so the clean guard
    can read the current LRU access counter.
  • In CcPageCleanGuardWithoutKickoutCc::CanBeCleaned() (in
    cc_page_clean_guard.h), after the existing IsFree()/GetBeingCkpt()
    check, add:

    if (txservice_large_value_threshold > 0 &&
        cce->PayloadSize() > txservice_large_value_threshold)
    {
        uint64_t age =
            cc_shard_->AccessCounter() - page_->last_access_ts_;
        if (age < txservice_large_value_eviction_age)
            return {false, false};
    }

  • Parse the optional large_value_threshold and
    large_value_eviction_age config keys in TxService::Init().

  Implementation is in PR Add payload-size-aware large-value zone eviction for EloqKV (ObjectCcMap) #415.

[xiexiaoy]

AI gives a solution. There are 2 problems:

1. access_counter_ is a CcShard level variable. Which might increment quickly for a hot key.
2. Large pages drop down to the LRU head, but they are now allowed to evict since they are not old enough.

[xiexiaoy]

I asked AI to give a 2-zone solution, which is similar to SLRU. One zone for small objects, and another zone for large objects.

Implement the feature based on the solution.

Traditional SLRU might expose a ratio parameter for Probation zone / Protected zone. Our policy doesn't contain the parameter, because the mimalloc heap provides the memory usage, and there is only one heap per CcShard. As a result, large objects may occupy the entire heap, and small objects experience cache misses even if they are frequently accessed.

[xiexiaoy]

Considering large objects use one page exclusively.

[xiexiaoy]

1. Introduce cache_evict_policy and lolru_large_obj_threshold_kb parameter. Modify UpdateLruList, ReplaceLru, and DetachLru.
2. Currently, LRU adjustment takes place at Find/FindEmplace. For large value LRU, adjustment should take place at ApplyCc(CommitCommandOnPayload, CommitCommandOnDirtyPayload), BackFill, BatchFillSlice.

[xiexiaoy]

Modify ObjectCcMap::BackFill() for large value page.

[xiexiaoy]

RestoreCcMapCc calls BatchFillSlice(). BatchFillSlice is too complex to edit for large value LRU. RestoreCcMapCc is used when enable_cache_replacement is false. The large value LRU won't handle BatchFillSlice().

[xiexiaoy]

Insert ObjectCcMap::EnsureLargeObjOccupyPageAlone() to:

• ApplyCc
• PostWriteCc
• UploadTxCommandsCc
• KeyObjectStandbyForwardCc
• ReplayLogCc
• BackFill.

[xiexiaoy]

ctests inside txservice cannot run.

(gdb) bt
#0  0x000055b9c4dbe784 in std::__atomic_base<int>::load (__m=std::memory_order_acquire, this=0x4608c0b0500) at /usr/include/c++/12/bits/atomic_base.h:484
#1  txservice::LocalCcShards::FastMetaDataMutex::lock_shared (this=0x4608c3e5e80) at /home/xiexy/eloqdata-redis/data_substrate/tx_service/src/cc/local_cc_shards.cpp:7195
#2  0x000055b9c4b2146d in std::shared_lock<txservice::LocalCcShards::FastMetaDataMutex>::shared_lock (this=0x7ffc36cfd5c0, __m=...) at /usr/include/c++/12/shared_mutex:727
#3  0x000055b9c4da4d4b in txservice::LocalCcShards::GetAllBucketInfos (this=0x4608c3e5400, ng_id=0) at /home/xiexy/eloqdata-redis/data_substrate/tx_service/src/cc/local_cc_shards.cpp:1971
#4  0x000055b9c4bcc668 in txservice::CcShard::GetAllBucketInfos (this=0x4608c1a1c00, ng_id=0) at /home/xiexy/eloqdata-redis/data_substrate/tx_service/src/cc/cc_shard.cpp:1789
#5  0x000055b9c4befbd7 in txservice::RangeBucketCcMap::RangeBucketCcMap (this=0x4608cfa8400, shard=0x4608c1a1c00, cc_ng_id=0, table_name=...) at /home/xiexy/eloqdata-redis/data_substrate/tx_service/include/cc/range_bucket_cc_map.h:56
#6  0x000055b9c4c0a4d7 in std::make_unique<txservice::RangeBucketCcMap, txservice::CcShard*, unsigned int const&, txservice::TableName&> () at /usr/include/c++/12/bits/unique_ptr.h:1065
#7  0x000055b9c4bc6c46 in txservice::CcShard::Init (this=0x4608c1a1c00) at /home/xiexy/eloqdata-redis/data_substrate/tx_service/src/cc/cc_shard.cpp:282
#8  0x000055b9c4a42197 in txservice::make_shard () at /home/xiexy/eloqdata-redis/data_substrate/tx_service/tests/LargeObjLRU-Test.cpp:113
#9  0x000055b9c4a4258c in txservice::CATCH2_INTERNAL_TEST_2 () at /home/xiexy/eloqdata-redis/data_substrate/tx_service/tests/LargeObjLRU-Test.cpp:146
#10 0x000055b9c53f89d8 in Catch::TestInvokerAsFunction::invoke() const ()
#11 0x000055b9c53edcfb in Catch::TestCaseHandle::invoke() const ()
#12 0x000055b9c53ecdc0 in Catch::RunContext::invokeActiveTestCase() ()
#13 0x000055b9c53ecad4 in Catch::RunContext::runCurrentTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&) ()
#14 0x000055b9c53eb0f8 in Catch::RunContext::runTest(Catch::TestCaseHandle const&) ()
#15 0x000055b9c539f50d in Catch::(anonymous namespace)::TestGroup::execute() ()
#16 0x000055b9c53a0a12 in Catch::Session::runInternal() ()
#17 0x000055b9c53a0514 in Catch::Session::run() ()
#18 0x000055b9c4a6b69d in Catch::Session::run<char> (this=0x7ffc36cfe580, argc=1, argv=0x7ffc36cfe838) at /usr/local/include/catch2/catch_session.hpp:41
#19 0x000055b9c4a437df in main (argc=1, argv=0x7ffc36cfe838) at /home/xiexy/eloqdata-redis/data_substrate/tx_service/tests/LargeObjLRU-Test.cpp:231

[xiexiaoy]

1. Write test case for large value lru.
2. Debug crash inside RebalancePage() when run test case.

[xiexiaoy]

1. Fix test crash.
2. One REQUIRE check failed, review code modification.

[xiexiaoy]

Write and pass some ctests for the large value lru policy.