Add write amplification statistics and update eviction algorithms for enhanced reporting

Author: 1a1a11a

libCacheSim/bin/cachesim/sim.c

@@ -1,4 +1,5 @@
 #include "libCacheSim/cache.h"
+#include "libCacheSim/evictionAlgo.h"
 #include "libCacheSim/reader.h"
 #include "utils/include/mymath.h"
 #include "utils/include/mystr.h"
@@ -103,6 +104,52 @@ void simulate(reader_t *reader, cache_t *cache, int report_interval,
   if (show_cost)
     n += snprintf(output_str + n, sizeof(output_str) - n,
                   ", cost saving ratio %.4lf", cost_saving_ratio);
+
+  /* print write amplification stats for algorithms that track them */
+  if (cache->cache_init == Clock_init) {
+    Clock_params_t *p = (Clock_params_t *)cache->eviction_params;
+    double write_ratio = req_byte > 0
+        ? (double)(miss_byte + p->n_byte_rewritten) / (double)req_byte : 0.0;
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", write ratio %.4lf", write_ratio);
+  } else if (cache->cache_init == ClockRI_init) {
+    ClockRI_params_t *p = (ClockRI_params_t *)cache->eviction_params;
+    double write_ratio = req_byte > 0
+        ? (double)(miss_byte + p->n_byte_rewritten) / (double)req_byte : 0.0;
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", write ratio %.4lf", write_ratio);
+  } else if (cache->cache_init == ClockOracle_init) {
+    ClockOracle_params_t *p = (ClockOracle_params_t *)cache->eviction_params;
+    double write_ratio = req_byte > 0
+        ? (double)(miss_byte + p->n_byte_rewritten) / (double)req_byte : 0.0;
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", write ratio %.4lf", write_ratio);
+  } else if (cache->cache_init == LRU_init) {
+    LRU_params_t *p = (LRU_params_t *)cache->eviction_params;
+    double write_ratio = req_byte > 0
+        ? (double)(miss_byte + p->n_byte_promoted) / (double)req_byte : 0.0;
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", write ratio %.4lf", write_ratio);
+  } else if (cache->cache_init == FIFO_init) {
+    /* FIFO: flash writes = miss bytes only */
+    double write_ratio = byte_miss_ratio;
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", write ratio %.4lf", write_ratio);
+  } else if (cache->cache_init == S3FIFO_init) {
+    /* S3FIFO: flash writes = miss bytes + promotion bytes + reinsertion bytes */
+    S3FIFO_params_t *p = (S3FIFO_params_t *)cache->eviction_params;
+    double write_ratio = req_byte > 0
+        ? (double)(miss_byte + p->n_byte_promoted + p->n_byte_rewritten)
+          / (double)req_byte : 0.0;
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", write ratio %.4lf", write_ratio);
+  } else if (cache->cache_init == Sieve_init) {
+    /* Sieve: no data movement, flash writes = miss bytes only */
+    double write_ratio = byte_miss_ratio;
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", write ratio %.4lf", write_ratio);
+  }
+
   snprintf(output_str + n, sizeof(output_str) - n, ", throughput %.2lf MQPS\n",
            (double)req_cnt / 1000000.0 / runtime);
   printf("%s", output_str);

libCacheSim/cache/eviction/ClockOracle.c

@@ -1,10 +1,15 @@
 //
 //  ClockOracle
 //
-//  An oracle-assisted CLOCK that uses next_access_vtime to decide reinsertion.
-//  During eviction scan, an object is reinserted only if:
-//      next_access_vtime - current_vtime <= cache_size / miss_ratio
-//  Objects whose next access is beyond this threshold are evicted.
+//  An oracle-assisted CLOCK that combines the visited bit with oracle
+//  reuse distance to decide reinsertion.
+//
+//  An object is reinserted only if BOTH conditions hold:
+//    1. The visited bit is set (object was accessed since last eviction scan)
+//    2. next_access_vtime - current_vtime <= cache_size / miss_ratio
+//
+//  The visited bit is cleared on reinsertion (like standard CLOCK).
+//  Objects failing either condition are evicted.
 //
 //  Requires oracle traces (oracleGeneral / lcs) that provide next_access_vtime.
 //
@@ -19,16 +24,6 @@
 extern "C" {
 #endif
 
-typedef struct {
-  cache_obj_t *q_head;
-  cache_obj_t *q_tail;
-
-  int64_t n_miss;
-
-  int64_t n_obj_rewritten;
-  int64_t n_byte_rewritten;
-} ClockOracle_params_t;
-
 // ***********************************************************************
 // ****                                                               ****
 // ****                   function declarations                       ****
@@ -121,6 +116,8 @@ static cache_obj_t *ClockOracle_find(cache_t *cache, const request_t *req,
                                      bool update_cache) {
   cache_obj_t *obj = cache_find_base(cache, req, update_cache);
   if (obj != NULL && update_cache) {
+    /* set visited bit */
+    obj->clock.freq = 1;
     obj->next_access_vtime = req->next_access_vtime;
   }
   return obj;
@@ -133,6 +130,8 @@ static cache_obj_t *ClockOracle_insert(cache_t *cache, const request_t *req) {
   cache_obj_t *obj = cache_insert_base(cache, req);
   prepend_obj_to_head(&params->q_head, &params->q_tail, obj);
 
+  /* new objects start with visited bit clear */
+  obj->clock.freq = 0;
   obj->next_access_vtime = req->next_access_vtime;
 
   return obj;
@@ -145,23 +144,21 @@ static cache_obj_t *ClockOracle_to_evict(cache_t *cache, const request_t *req) {
 }
 
 /**
- * @brief evict using oracle information
+ * @brief evict using oracle + visited bit
  *
- * Scan from the tail. For each object, compute the reinsertion threshold:
- *   threshold = cache_size / miss_ratio
- * If next_access_vtime - current_vtime > threshold, evict the object.
- * Otherwise, reinsert it to the head.
+ * Scan from the tail. An object is reinserted only if BOTH:
+ *   1. visited bit is set (freq >= 1)
+ *   2. next_access_vtime - current_vtime <= cache_size / miss_ratio
  *
- * Objects with next_access_vtime == INT64_MAX (no future access) are always
- * evicted.
+ * On reinsertion, the visited bit is cleared.
+ * Objects failing either condition are evicted.
  */
 static void ClockOracle_evict(cache_t *cache, const request_t *req) {
   ClockOracle_params_t *params =
       (ClockOracle_params_t *)cache->eviction_params;
 
-  /* compute the reinsertion threshold: cache_size / miss_ratio
-   * miss_ratio = n_miss / n_req, so threshold = cache_size * n_req / n_miss
-   * when n_miss == 0, use cache_size as the threshold (conservative) */
+  /* threshold = cache_size / miss_ratio = cache_size * n_req / n_miss
+   * when n_miss == 0, use cache_size as the threshold */
   int64_t threshold;
   if (params->n_miss > 0) {
     threshold = (int64_t)((double)cache->cache_size * (double)cache->n_req /
@@ -170,23 +167,31 @@ static void ClockOracle_evict(cache_t *cache, const request_t *req) {
     threshold = cache->cache_size;
   }
 
-  /* scan at most n_obj objects to avoid infinite loop */
-  int64_t n_scanned = 0;
+
   cache_obj_t *obj_to_evict = params->q_tail;
+  int64_t n_scanned = 0;
   while (obj_to_evict != NULL && n_scanned < cache->n_obj) {
-    int64_t reuse_dist = obj_to_evict->next_access_vtime - cache->n_req;
     n_scanned++;
 
-    /* evict if no future access or reuse distance exceeds threshold */
-    if (obj_to_evict->next_access_vtime == INT64_MAX || reuse_dist > threshold) {
-      break;
+    bool no_future_access = (obj_to_evict->next_access_vtime == -1 ||
+                             obj_to_evict->next_access_vtime == INT64_MAX);
+    bool visited = (obj_to_evict->clock.freq >= 1);
+    int64_t reuse_dist = obj_to_evict->next_access_vtime - cache->n_req;
+    bool within_threshold = (!no_future_access && reuse_dist <= threshold);
+
+    /* reinsert only if visited AND within threshold */
+    if (visited && within_threshold) {
+      /* clear visited bit, reinsert to head */
+      obj_to_evict->clock.freq = 0;
+      params->n_obj_rewritten += 1;
+      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;
+      continue;
     }
 
-    /* reinsert: move to head */
-    params->n_obj_rewritten += 1;
-    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;
+    /* evict: either not visited, no future access, or too far away */
+    break;
   }
 
   /* safety: if everything was reinserted, evict the tail */

libCacheSim/cache/eviction/S3FIFO.c

@@ -36,20 +36,6 @@
 extern "C" {
 #endif
 
-typedef struct {
-  cache_t *small_fifo;
-  cache_t *ghost_fifo;
-  cache_t *main_fifo;
-  bool hit_on_ghost;
-
-  int move_to_main_threshold;
-  double small_size_ratio;
-  double ghost_size_ratio;
-
-  bool has_evicted;
-  request_t *req_local;
-} S3FIFO_params_t;
-
 static const char *DEFAULT_CACHE_PARAMS =
     "small-size-ratio=0.10,ghost-size-ratio=0.90,move-to-main-threshold=2";
 
@@ -323,6 +309,8 @@ static void S3FIFO_evict_small(cache_t *cache, const request_t *req) {
     copy_cache_obj_to_request(params->req_local, obj_to_evict);
 
     if (obj_to_evict->S3FIFO.freq >= params->move_to_main_threshold) {
+      params->n_obj_promoted += 1;
+      params->n_byte_promoted += obj_to_evict->obj_size;
       main_fifo->insert(main_fifo, params->req_local);
     } else {
       // insert to ghost
@@ -349,6 +337,8 @@ static void S3FIFO_evict_main(cache_t *cache, const request_t *req) {
     int freq = obj_to_evict->S3FIFO.freq;
     copy_cache_obj_to_request(params->req_local, obj_to_evict);
     if (freq >= 1) {
+      params->n_obj_rewritten += 1;
+      params->n_byte_rewritten += obj_to_evict->obj_size;
       // we need to evict first because the object to insert has the same obj_id
       main_fifo->remove(main_fifo, obj_to_evict->obj_id);
       obj_to_evict = NULL;

libCacheSim/include/libCacheSim/evictionAlgo.h

@@ -56,6 +56,16 @@ typedef struct {
   int64_t n_byte_rewritten;
 } ClockRI_params_t;
 
+typedef struct {
+  cache_obj_t *q_head;
+  cache_obj_t *q_tail;
+
+  int64_t n_miss;
+
+  int64_t n_obj_rewritten;
+  int64_t n_byte_rewritten;
+} ClockOracle_params_t;
+
 cache_t *ARC_init(const common_cache_params_t ccache_params,
                   const char *cache_specific_params);
 
@@ -159,6 +169,25 @@ cache_t *RandomTwo_init(const common_cache_params_t ccache_params,
 cache_t *Random_init(const common_cache_params_t ccache_params,
                      const char *cache_specific_params);
 
+typedef struct {
+  cache_t *small_fifo;
+  cache_t *ghost_fifo;
+  cache_t *main_fifo;
+  bool hit_on_ghost;
+
+  int move_to_main_threshold;
+  double small_size_ratio;
+  double ghost_size_ratio;
+
+  bool has_evicted;
+  request_t *req_local;
+
+  int64_t n_obj_promoted;
+  int64_t n_byte_promoted;
+  int64_t n_obj_rewritten;
+  int64_t n_byte_rewritten;
+} S3FIFO_params_t;
+
 cache_t *S3FIFO_init(const common_cache_params_t ccache_params,
                      const char *cache_specific_params);