Add per-request cost support (obj_cost) and cost-miss reporting (#309)

* support object cost

* Update libCacheSim/bin/cachesim/main.c

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: 1a1a11a

libCacheSim/bin/cachesim/main.c

@@ -5,6 +5,7 @@
 #endif
 #include <assert.h>
 #include <libgen.h>
+#include <math.h>
 
 #include "internal.h"
 #include "libCacheSim/cache.h"
@@ -66,14 +67,31 @@ int main(int argc, char **argv) {
 
   printf("\n");
   for (int i = 0; i < args.n_cache_size * args.n_eviction_algo; i++) {
-    snprintf(output_str, 1024,
-             "%s %s cache size %8ld%s, %lld req, miss ratio %.4lf, byte miss "
-             "ratio %.4lf\n",
-             args.reader->trace_path, result[i].cache_name,
-             (long)(result[i].cache_size / size_unit), size_unit_str,
-             (long long)result[i].n_req,
-             (double)result[i].n_miss / (double)result[i].n_req,
-             (double)result[i].n_miss_byte / (double)result[i].n_req_byte);
+    double miss_ratio = result[i].n_req > 0
+                            ? (double)result[i].n_miss / (double)result[i].n_req
+                            : 0.0;
+    double cost_saving_ratio =
+        result[i].n_req_cost > 0
+            ? 1.0 - result[i].n_miss_cost / result[i].n_req_cost
+            : 0.0;
+    bool show_cost = fabs(1 - cost_saving_ratio - miss_ratio) > 1e-9;
+
+    int n = snprintf(output_str, sizeof(output_str),
+                     "%s %s cache size %8ld%s, %lld req, miss ratio %.4lf",
+                     args.reader->trace_path, result[i].cache_name,
+                     (long)(result[i].cache_size / size_unit), size_unit_str,
+                     (long long)result[i].n_req, miss_ratio);
+    if (!args.ignore_obj_size)
+      n += snprintf(
+          output_str + n, sizeof(output_str) - n, ", byte miss ratio %.4lf",
+          result[i].n_req_byte > 0
+              ? (double)result[i].n_miss_byte / (double)result[i].n_req_byte
+              : 0.0);
+    if (show_cost)
+      n += snprintf(output_str + n, sizeof(output_str) - n,
+                    ", cost saving ratio %.4lf", cost_saving_ratio);
+    snprintf(output_str + n, sizeof(output_str) - n, "\n");
+
     printf("%s", output_str);
     fprintf(output_file, "%s", output_str);
   }

libCacheSim/bin/cachesim/sim.c

@@ -25,6 +25,7 @@ void simulate(reader_t *reader, cache_t *cache, int report_interval,
   uint64_t req_cnt = 0, miss_cnt = 0;
   uint64_t last_req_cnt = 0, last_miss_cnt = 0;
   uint64_t req_byte = 0, miss_byte = 0;
+  double req_cost = 0, miss_cost = 0;
 
   read_one_req(reader, req);
   uint64_t start_ts = (uint64_t)req->clock_time;
@@ -52,9 +53,11 @@ void simulate(reader_t *reader, cache_t *cache, int report_interval,
 
     req_cnt++;
     req_byte += req->obj_size;
+    req_cost += req->obj_cost;
     if (cache->get(cache, req) == false) {
       miss_cnt++;
       miss_byte += req->obj_size;
+      miss_cost += req->obj_cost;
     }
     if (req->clock_time - last_report_ts >= (uint64_t)report_interval &&
         req->clock_time != 0) {
@@ -78,28 +81,30 @@ void simulate(reader_t *reader, cache_t *cache, int report_interval,
 
   char output_str[1024];
   char size_str[64];
-
-  if (!ignore_obj_size) convert_size_to_str(cache->cache_size, size_str, 64);
-#pragma GCC diagnostic push
-  // Removed unknown pragma warning
-  if (!ignore_obj_size) {
-    snprintf(output_str, 1024,
-             "%s %s cache size %8s, %16lu req, miss ratio %.4lf, throughput "
-             "%.2lf MQPS\n",
-             reader->trace_path, detailed_cache_name, size_str,
-             (unsigned long)req_cnt, (double)miss_cnt / (double)req_cnt,
-             (double)req_cnt / 1000000.0 / runtime);
-  } else {
-    snprintf(output_str, 1024,
-             "%s %s cache size %8lld, %16lu req, miss ratio %.4lf, throughput "
-             "%.2lf MQPS\n",
-             reader->trace_path, detailed_cache_name,
-             (long long)cache->cache_size, (unsigned long)req_cnt,
-             (double)miss_cnt / (double)req_cnt,
-             (double)req_cnt / 1000000.0 / runtime);
-  }
-
-#pragma GCC diagnostic pop
+  double miss_ratio = req_cnt > 0 ? (double)miss_cnt / (double)req_cnt : 0.0;
+  double byte_miss_ratio =
+      req_byte > 0 ? (double)miss_byte / (double)req_byte : 0.0;
+  double cost_saving_ratio = 1.0 - (req_cost > 0 ? miss_cost / req_cost : 0.0);
+
+  if (!ignore_obj_size)
+    convert_size_to_str(cache->cache_size, size_str, 64);
+  else
+    snprintf(size_str, sizeof(size_str), "%lld", (long long)cache->cache_size);
+
+  bool show_cost = fabs(1 - cost_saving_ratio - miss_ratio) > 1e-9;
+
+  int n = snprintf(output_str, sizeof(output_str),
+                   "%s %s cache size %8s, %16lu req, miss ratio %.4lf",
+                   reader->trace_path, detailed_cache_name, size_str,
+                   (unsigned long)req_cnt, miss_ratio);
+  if (!ignore_obj_size)
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", byte miss ratio %.4lf", byte_miss_ratio);
+  if (show_cost)
+    n += snprintf(output_str + n, sizeof(output_str) - n,
+                  ", cost saving ratio %.4lf", cost_saving_ratio);
+  snprintf(output_str + n, sizeof(output_str) - n, ", throughput %.2lf MQPS\n",
+           (double)req_cnt / 1000000.0 / runtime);
   printf("%s", output_str);
   char *output_dir = rindex(ofilepath, '/');
   if (output_dir != NULL) {

libCacheSim/bin/cli_reader_utils.c

@@ -119,6 +119,10 @@ void parse_reader_params(const char *reader_params_str,
                strcasecmp(key, "size-col") == 0) {
       params->obj_size_field = (int)strtol(value, &end, 0);
       _check_parsed_result(end, params->obj_size_field);
+    } else if (strcasecmp(key, "obj-cost-col") == 0 ||
+               strcasecmp(key, "cost-col") == 0) {
+      params->obj_cost_field = (int)strtol(value, &end, 0);
+      _check_parsed_result(end, params->obj_cost_field);
     } else if (strcasecmp(key, "cnt-col") == 0) {
       params->cnt_field = (int)strtol(value, &end, 0);
     } else if (strcasecmp(key, "op-col") == 0) {

libCacheSim/include/libCacheSim/cache.h

@@ -73,8 +73,10 @@ typedef struct {
   int64_t n_warmup_req;
   int64_t n_req;
   int64_t n_req_byte;
+  double n_req_cost;
   int64_t n_miss;
   int64_t n_miss_byte;
+  double n_miss_cost;
 
   int64_t n_obj;
   int64_t occupied_byte;

libCacheSim/include/libCacheSim/reader.h

@@ -45,6 +45,7 @@ typedef struct {
   int32_t time_field;
   int32_t obj_id_field;
   int32_t obj_size_field;
+  int32_t obj_cost_field;
   int32_t op_field;
   int32_t ttl_field;
   int32_t cnt_field;

libCacheSim/include/libCacheSim/request.h

@@ -32,6 +32,8 @@ typedef struct request {
 
   int64_t obj_size;
 
+  int64_t obj_cost;
+
   int32_t ttl;
 
   req_op_e op;
@@ -79,6 +81,7 @@ static inline request_t *new_request(void) {
   request_t *req = my_malloc(request_t);
   memset(req, 0, sizeof(request_t));
   req->obj_size = 1;
+  req->obj_cost = 1;
   req->op = OP_NOP;
   req->valid = true;
   req->obj_id = 0;
@@ -118,14 +121,17 @@ static inline void free_request(request_t *req) { my_free(request_t, req); }
 static inline void print_request(const request_t *req) {
 #ifdef SUPPORT_TTL
   LOGGING(DEBUG_LEVEL,
-          "req clock_time %lu, id %llu, size %ld, ttl %ld, op %s, valid %d\n",
+          "req clock_time %lu, id %llu, size %ld, cost %ld, ttl %ld, op %s, "
+          "valid %d\n",
           (unsigned long)req->clock_time, (unsigned long long)req->obj_id,
-          (long)req->obj_size, (long)req->ttl, req_op_str[req->op], req->valid);
+          (long)req->obj_size, (long)req->obj_cost, (long)req->ttl,
+          req_op_str[req->op], req->valid);
 #else
   LOGGING(DEBUG_LEVEL,
-          "req clock_time %lu, id %llu, size %ld, op %s, valid %d\n",
+          "req clock_time %lu, id %llu, size %ld, cost %ld, op %s, valid %d\n",
           (unsigned long)req->clock_time, (unsigned long long)req->obj_id,
-          (long)req->obj_size, req_op_str[req->op], req->valid);
+          (long)req->obj_size, (long)req->obj_cost, req_op_str[req->op],
+          req->valid);
 #endif
 }
 

libCacheSim/profiler/simulator.c

@@ -97,11 +97,13 @@ static void _simulate(gpointer data, gpointer user_data) {
   while (req->valid) {
     result[idx].n_req++;
     result[idx].n_req_byte += req->obj_size;
+    result[idx].n_req_cost += req->obj_cost;
 
     req->clock_time -= start_ts;
     if (local_cache->get(local_cache, req) == false) {
       result[idx].n_miss++;
       result[idx].n_miss_byte += req->obj_size;
+      result[idx].n_miss_cost += req->obj_cost;
     }
     read_one_req(cloned_reader, req);
   }

libCacheSim/traceReader/generalReader/binary.c

@@ -80,6 +80,15 @@ int binaryReader_setup(reader_t *const reader) {
     params->obj_size_offset = -1;
   }
 
+  params->obj_cost_field_idx = reader->init_params.obj_cost_field;
+  if (params->obj_cost_field_idx > 0) {
+    params->obj_cost_format = fmt_str[params->obj_cost_field_idx - 1];
+    params->obj_cost_offset = cal_offset(fmt_str, params->obj_cost_field_idx);
+  } else {
+    params->obj_cost_format = '\0';
+    params->obj_cost_offset = -1;
+  }
+
   params->op_field_idx = reader->init_params.op_field;
   if (params->op_field_idx > 0) {
     params->op_format = fmt_str[params->op_field_idx - 1];
@@ -148,6 +157,12 @@ int binaryReader_setup(reader_t *const reader) {
                   format_to_size(params->obj_size_format),
                   params->obj_size_offset);
   }
+  if (params->obj_cost_field_idx > 0) {
+    n += snprintf(output + n, 1024 - n, ", obj_cost_field %d,%d,%d",
+                  params->obj_cost_field_idx,
+                  format_to_size(params->obj_cost_format),
+                  params->obj_cost_offset);
+  }
   if (params->op_field_idx > 0) {
     n += snprintf(output + n, 1024 - n, ", op_field %d,%d,%d",
                   params->op_field_idx, format_to_size(params->op_format),
@@ -226,6 +241,12 @@ int binary_read_one_req(reader_t *reader, request_t *req) {
         read_data(start + params->obj_size_offset, params->obj_size_format);
   }
 
+  /* read object cost */
+  if (params->obj_cost_field_idx > 0) {
+    req->obj_cost =
+        read_data(start + params->obj_cost_offset, params->obj_cost_format);
+  }
+
   /* read operation */
   if (params->op_field_idx > 0) {
     req->op = read_data(start + params->op_offset, params->op_format);

libCacheSim/traceReader/generalReader/csv.c

@@ -237,6 +237,11 @@ static inline void csv_cb1(void *s, size_t len, void *data) {
     if (req->obj_size == 0 && end == s) {
       WARN("csvReader obj_size is not a number: \"%s\"\n", (char *)s);
     }
+  } else if (csv_params->curr_field_idx == csv_params->obj_cost_field_idx) {
+    req->obj_cost = (int64_t)strtoll((char *)s, &end, 0);
+    if (req->obj_cost == 0 && end == s) {
+      WARN("csvReader obj_cost is not a number: \"%s\"\n", (char *)s);
+    }
   } else if (csv_params->curr_field_idx == csv_params->op_field_idx) {
     if (strncasecmp((char *)s, "read", len) == 0) {
       req->op = OP_READ;
@@ -298,6 +303,7 @@ void csv_setup_reader(reader_t *const reader) {
   csv_params->time_field_idx = init_params->time_field;
   csv_params->obj_id_field_idx = init_params->obj_id_field;
   csv_params->obj_size_field_idx = init_params->obj_size_field;
+  csv_params->obj_cost_field_idx = init_params->obj_cost_field;
   csv_params->op_field_idx = init_params->op_field;
   csv_params->ttl_field_idx = init_params->ttl_field;
   csv_params->cnt_field_idx = init_params->cnt_field;

libCacheSim/traceReader/reader.c

@@ -258,6 +258,8 @@ int read_one_req(reader_t *const reader, request_t *const req) {
     reader->n_read_req += 1;
     req->hv = 0;
     req->ttl = 0;
+    req->obj_size = 1;
+    req->obj_cost = 1;
     req->valid = true;
 
     switch (reader->trace_type) {
@@ -333,8 +335,14 @@ int read_one_req(reader_t *const reader, request_t *const req) {
     req->obj_size = 1;
   }
 
-  VERBOSE("read one req: time %lu, obj_id %lu, size %lu at offset %zu\n",
-          req->clock_time, req->obj_id, req->obj_size, offset_before_read);
+  if (reader->init_params.obj_cost_field <= 0) {
+    req->obj_cost = 1;
+  }
+
+  VERBOSE(
+      "read one req: time %lu, obj_id %lu, size %lu, cost %lu at offset %zu\n",
+      req->clock_time, req->obj_id, req->obj_size, req->obj_cost,
+      offset_before_read);
 
   return status;
 }