Add GroupMergeAdaptive2 eviction algorithm and enhance existing algorithms

- Implemented GroupMergeAdaptive2, an activity-driven adaptive group-based eviction algorithm.
- Introduced new parameters for group size, active threshold, and retention policy.
- Enhanced GroupMergeHead and Sieve algorithms to track additional statistics for object retention and eviction.
- Updated cache object structure to include metadata for GroupMergeAdaptive2.
- Modified eviction algorithm headers to include new initialization functions for GroupMergeAdaptive2.
- Added file handling for tracking retention ratios and object examination statistics in Sieve.

Author: 1a1a11a

.gitignore

@@ -23,3 +23,6 @@ sftp-config.json
 # Python wheels
 *.whl
 2024_google/*
+.nfs*
+figure/*
+results/*

libCacheSim/bin/cachesim/cache_init.h

@@ -56,6 +56,12 @@ static inline cache_t *create_cache(const char *trace_path,
       {"groupmergehead", GroupMergeHead_init},
       {"group-merge-head", GroupMergeHead_init},
       {"group_merge_head", GroupMergeHead_init},
+      {"groupmergeadaptive", GroupMergeAdaptive_init},
+      {"group-merge-adaptive", GroupMergeAdaptive_init},
+      {"group_merge_adaptive", GroupMergeAdaptive_init},
+      {"groupmergeadaptive2", GroupMergeAdaptive2_init},
+      {"group-merge-adaptive2", GroupMergeAdaptive2_init},
+      {"group_merge_adaptive2", GroupMergeAdaptive2_init},
       {"gdsf", GDSF_init},
       {"lhd", LHD_init},
       {"lecar", LeCaR_init},

libCacheSim/cache/CMakeLists.txt

@@ -69,6 +69,8 @@ set(eviction_sources_c
         eviction/FIFO_Reinsertion.c
         eviction/GroupMerge.c
         eviction/GroupMergeHead.c
+        eviction/GroupMergeAdaptive.c
+        eviction/GroupMergeAdaptive2.c
         eviction/S3FIFOv0.c
         eviction/S3FIFOd.c
         eviction/other/flashProb.c

libCacheSim/cache/eviction/Clock.c

@@ -17,8 +17,8 @@
 extern "C" {
 #endif
 
-#define USE_BELADY
-// #undef USE_BELADY
+// #define USE_BELADY
+#undef USE_BELADY
 
 static const char *DEFAULT_PARAMS = "init-freq=0,n-bit-counter=1";
 
@@ -90,6 +90,23 @@ cache_t *Clock_init(const common_cache_params_t ccache_params,
              params->n_bit_counter, params->init_freq);
   }
 
+  // open tracking file
+  {
+    char fname[256];
+    const char *trace_name = getenv("TRACKING_TRACE_NAME");
+    if (trace_name)
+      snprintf(fname, sizeof(fname), "tracking_%s_%s_%lld.csv", trace_name,
+               cache->cache_name, (long long)cache->cache_size);
+    else
+      snprintf(fname, sizeof(fname), "tracking_%s_%lld.csv", cache->cache_name,
+               (long long)cache->cache_size);
+    params->tracking_file = fopen(fname, "w");
+    if (params->tracking_file) {
+      fprintf(params->tracking_file,
+              "vtime,n_obj,avg_scan_depth,retention_ratio\n");
+    }
+  }
+
   return cache;
 }
 
@@ -99,6 +116,8 @@ cache_t *Clock_init(const common_cache_params_t ccache_params,
  * @param cache
  */
 static void Clock_free(cache_t *cache) {
+  Clock_params_t *params = (Clock_params_t *)cache->eviction_params;
+  if (params->tracking_file) fclose(params->tracking_file);
   free(cache->eviction_params);
   cache_struct_free(cache);
 }
@@ -263,10 +282,33 @@ static void Clock_evict(cache_t *cache, const request_t *req) {
     params->n_byte_rewritten += obj_to_evict->obj_size;
     move_obj_to_head(&params->q_head, &params->q_tail, obj_to_evict);
     obj_to_evict = params->q_tail;
+    params->n_obj_examined_interval++;
+    params->n_obj_retained_interval++;
   }
 
+  params->n_obj_examined_interval++;
+  params->n_evictions_interval++;
+
   remove_obj_from_list(&params->q_head, &params->q_tail, obj_to_evict);
   cache_evict_base(cache, obj_to_evict, true);
+
+  if (params->tracking_file &&
+      cache->n_req - params->last_report_vtime >= 100000) {
+    double avg_scan = params->n_evictions_interval > 0
+                          ? (double)params->n_obj_examined_interval /
+                                params->n_evictions_interval
+                          : 0.0;
+    double retention = params->n_obj_examined_interval > 0
+                           ? (double)params->n_obj_retained_interval /
+                                 params->n_obj_examined_interval
+                           : 0.0;
+    fprintf(params->tracking_file, "%ld,%ld,%.4f,%.4f\n", (long)cache->n_req,
+            (long)cache->get_n_obj(cache), avg_scan, retention);
+    params->n_obj_examined_interval = 0;
+    params->n_obj_retained_interval = 0;
+    params->n_evictions_interval = 0;
+    params->last_report_vtime = cache->n_req;
+  }
 }
 
 /**

libCacheSim/cache/eviction/GroupMerge.c

@@ -52,6 +52,11 @@ typedef struct GroupMerge_params {
   int n_objs_to_evict;
   int pos_in_metric_list;
 
+  int64_t n_obj_inserted;
+  int64_t n_byte_inserted;
+  int64_t n_obj_retained;
+  int64_t n_byte_retained;
+
   int64_t n_obj_rewritten;
   int64_t n_byte_rewritten;
 } GroupMerge_params_t;
@@ -107,7 +112,9 @@ cache_t *GroupMerge_init(const common_cache_params_t ccache_params,
   memset(params, 0, sizeof(GroupMerge_params_t));
   cache->eviction_params = params;
 
-  params->group_size = 20 * 1024 * 1024;  // 20 MiB
+  // default group_size = cache_size / 1000
+  params->group_size = (int64_t)ccache_params.cache_size / 1000;
+  if (params->group_size < 1) params->group_size = 1;
   params->n_exam_groups = 4;
   params->retain_policy = RETAIN_POLICY_RECENCY;
   params->next_to_exam = NULL;
@@ -125,6 +132,20 @@ cache_t *GroupMerge_init(const common_cache_params_t ccache_params,
 
   assert(params->group_size > 0 && params->n_exam_groups >= 2);
 
+  // clamp group_size so it cannot exceed a fraction of the cache; otherwise
+  // each scan covers ~the whole cache while retaining everything, forcing
+  // batched evictions of 1, which is O(N^2) per pass.
+  int64_t max_group_size = (int64_t)ccache_params.cache_size /
+                           (int64_t)(params->n_exam_groups * 2);
+  if (max_group_size < 1) max_group_size = 1;
+  if (params->group_size > max_group_size) {
+    WARN("GroupMerge: group-size %ld too large for cache size %lu; "
+         "clamping to %ld (cache_size / (2*E))\n",
+         (long)params->group_size, (unsigned long)ccache_params.cache_size,
+         (long)max_group_size);
+    params->group_size = max_group_size;
+  }
+
   snprintf(cache->cache_name, CACHE_NAME_ARRAY_LEN,
            "GroupMerge_gs%ld_E%d_%s", (long)params->group_size,
            params->n_exam_groups,
@@ -135,6 +156,15 @@ cache_t *GroupMerge_init(const common_cache_params_t ccache_params,
 
 static void GroupMerge_free(cache_t *cache) {
   GroupMerge_params_t *params = (GroupMerge_params_t *)cache->eviction_params;
+  double retain_ratio = params->n_byte_inserted > 0
+      ? (double)params->n_byte_retained / (double)params->n_byte_inserted
+      : 0.0;
+  INFO(
+      "%s: inserted %ld obj / %ld bytes, retained %ld obj / %ld bytes "
+      "(retained/inserted byte ratio = %.4f)\n",
+      cache->cache_name, (long)params->n_obj_inserted,
+      (long)params->n_byte_inserted, (long)params->n_obj_retained,
+      (long)params->n_byte_retained, retain_ratio);
   free(params->metric_list);
   my_free(sizeof(GroupMerge_params_t), params);
   cache_struct_free(cache);
@@ -170,6 +200,9 @@ static cache_obj_t *GroupMerge_insert(cache_t *cache, const request_t *req) {
   cache_obj->GroupMerge.freq = 0;
   cache_obj->GroupMerge.last_access_vtime = (int32_t)cache->n_req;
 
+  params->n_obj_inserted += 1;
+  params->n_byte_inserted += cache_obj->obj_size;
+
   return cache_obj;
 }
 
@@ -195,6 +228,8 @@ static void GroupMerge_evict(cache_t *cache, const request_t *req) {
       for (int i = params->n_objs_to_evict; i < params->n_objs_in_batch; i++) {
         cache_obj_t *retained = params->metric_list[i].cache_obj;
         retained->GroupMerge.freq = (retained->GroupMerge.freq + 1) / 2;
+        params->n_obj_retained += 1;
+        params->n_byte_retained += retained->obj_size;
       }
       params->pos_in_metric_list = INT32_MAX;
     }
@@ -291,6 +326,8 @@ static void GroupMerge_evict(cache_t *cache, const request_t *req) {
     for (int i = params->n_objs_to_evict; i < params->n_objs_in_batch; i++) {
       cache_obj_t *retained = params->metric_list[i].cache_obj;
       retained->GroupMerge.freq = (retained->GroupMerge.freq + 1) / 2;
+      params->n_obj_retained += 1;
+      params->n_byte_retained += retained->obj_size;
     }
     params->pos_in_metric_list = INT32_MAX;
   }