Formatting test code

Author: haochengxia

.github/workflows/build.yml

@@ -4,7 +4,7 @@ on: [push, pull_request]
 
 env:
   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  BUILD_TYPE: Debug
+  BUILD_TYPE: Release
 
 jobs:
   # macos:

libCacheSim/cache/eviction/LFUDA.c

@@ -58,7 +58,8 @@ static void free_list_node(void *list_node);
  */
 cache_t *LFUDA_init(const common_cache_params_t ccache_params,
                     const char *cache_specific_params) {
-  cache_t *cache = cache_struct_init("LFUDA", ccache_params, cache_specific_params);
+  cache_t *cache =
+      cache_struct_init("LFUDA", ccache_params, cache_specific_params);
   cache->cache_init = LFUDA_init;
   cache->cache_free = LFUDA_free;
   cache->get = LFUDA_get;
@@ -217,7 +218,9 @@ static cache_obj_t *LFUDA_insert(cache_t *cache, const request_t *req) {
     memset(new_node, 0, sizeof(freq_node_t));
     new_node->freq = cache_obj->lfu.freq;
     g_hash_table_insert(params->freq_map, key, new_node);
-    params->max_freq = params->max_freq < cache_obj->lfu.freq ? cache_obj->lfu.freq : params->max_freq;
+    params->max_freq = params->max_freq < cache_obj->lfu.freq
+                           ? cache_obj->lfu.freq
+                           : params->max_freq;
   } else {
     DEBUG_ASSERT(new_node->freq == cache_obj->lfu.freq);
   }
@@ -355,7 +358,7 @@ static void update_min_freq(LFUDA_params_t *params) {
       break;
     }
   }
-  // If cache is empty, min_freq will be unchanged. 
+  // If cache is empty, min_freq will be unchanged.
   DEBUG_ASSERT(params->min_freq >= old_min_freq);
 }
 

libCacheSim/cache/eviction/LIRS.c

@@ -574,7 +574,7 @@ static cache_obj_t *hit_RD_HIRinS(cache_t *cache, cache_obj_t *cache_obj_s,
   LIRS_params_t *params = (LIRS_params_t *)(cache->eviction_params);
 
   if (cache_obj_q != NULL) {
-    int64_t obj_size = cache_obj_q->obj_size; 
+    int64_t obj_size = cache_obj_q->obj_size;
     params->hirs_count -= obj_size;
     params->LRU_q->remove(params->LRU_q, cache_obj_q->obj_id);
     cache->occupied_byte -= obj_size;
@@ -637,7 +637,8 @@ static void evictLIR(cache_t *cache) {
   cache->n_obj -= 1;
 
   if ((uint64_t)req_local_evictLIR->obj_size <= params->hirs_limit) {
-    while ((uint64_t)params->hirs_count + req_local_evictLIR->obj_size > params->hirs_limit) {
+    while ((uint64_t)params->hirs_count + req_local_evictLIR->obj_size >
+           params->hirs_limit) {
       evictHIR(cache);
     }
     params->LRU_q->insert(params->LRU_q, req_local_evictLIR);

libCacheSim/cache/eviction/SLRU.c

@@ -451,8 +451,9 @@ static void SLRU_parse_params(cache_t *cache,
       params->n_seg = n_seg;
       params->lru_max_n_bytes = calloc(params->n_seg, sizeof(int64_t));
       for (int i = 0; i < n_seg; i++) {
-        params->lru_max_n_bytes[i] = (int64_t)(
-            (double)seg_size_array[i] / seg_size_sum * cache->cache_size);
+        params->lru_max_n_bytes[i] =
+            (int64_t)((double)seg_size_array[i] / seg_size_sum *
+                      cache->cache_size);
       }
     } else if (strcasecmp(key, "print") == 0) {
       printf("current parameters: %s\n", SLRU_current_params(cache, params));

libCacheSim/traceReader/reader.c

@@ -39,7 +39,8 @@ extern "C" {
 // ssize_t getline(char **lineptr, size_t *n, FILE *stream);
 // #endif
 
-reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_type,
+reader_t *setup_reader(const char *const trace_path,
+                       const trace_type_e trace_type,
                        const reader_init_param_t *const init_params) {
   static bool _info_printed = false;
 
@@ -84,7 +85,8 @@ reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_ty
 
   if (init_params != NULL) {
     memcpy(&reader->init_params, init_params, sizeof(reader_init_param_t));
-    if (init_params->binary_fmt_str != NULL) reader->init_params.binary_fmt_str = strdup(init_params->binary_fmt_str);
+    if (init_params->binary_fmt_str != NULL)
+      reader->init_params.binary_fmt_str = strdup(init_params->binary_fmt_str);
 
     reader->ignore_obj_size = init_params->ignore_obj_size;
     reader->ignore_size_zero_req = init_params->ignore_size_zero_req;
@@ -94,7 +96,8 @@ reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_ty
     reader->mmap_offset = init_params->trace_start_offset;
     reader->cap_at_n_req = init_params->cap_at_n_req;
     reader->block_size = init_params->block_size;
-    if (init_params->sampler != NULL) reader->sampler = init_params->sampler->clone(init_params->sampler);
+    if (init_params->sampler != NULL)
+      reader->sampler = init_params->sampler->clone(init_params->sampler);
   } else {
     memset(&reader->init_params, 0, sizeof(reader_init_param_t));
   }
@@ -114,7 +117,8 @@ reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_ty
   }
   reader->file_size = st.st_size;
 
-  if (reader->trace_type == CSV_TRACE || reader->trace_type == PLAIN_TXT_TRACE) {
+  if (reader->trace_type == CSV_TRACE ||
+      reader->trace_type == PLAIN_TXT_TRACE) {
     reader->file = fopen(reader->trace_path, "rb");
     if (reader->file == 0) {
       ERROR("Failed to open %s: %s\n", reader->trace_path, strerror(errno));
@@ -137,7 +141,8 @@ reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_ty
     if ((reader->mapped_file) == MAP_FAILED) {
       close(fd);
       reader->mapped_file = NULL;
-      ERROR("Unable to allocate %llu bytes of memory, %s\n", (unsigned long long)st.st_size, strerror(errno));
+      ERROR("Unable to allocate %llu bytes of memory, %s\n",
+            (unsigned long long)st.st_size, strerror(errno));
       abort();
     }
   }
@@ -147,7 +152,8 @@ reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_ty
       reader->trace_format = TXT_TRACE_FORMAT;
       csv_setup_reader(reader);
       if (!check_delimiter(reader, init_params->delimiter)) {
-        ERROR("The trace does not use delimiter '%c', please check\n", init_params->delimiter);
+        ERROR("The trace does not use delimiter '%c', please check\n",
+              init_params->delimiter);
       }
       break;
     case PLAIN_TXT_TRACE:
@@ -194,7 +200,9 @@ reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_ty
       WARN(
           "trace file size %lu - %lu is not multiple of item size %lu, mod "
           "%lu\n",
-          (unsigned long)reader->file_size, (unsigned long)reader->trace_start_offset, (unsigned long)reader->item_size,
+          (unsigned long)reader->file_size,
+          (unsigned long)reader->trace_start_offset,
+          (unsigned long)reader->item_size,
           (unsigned long)reader->file_size % reader->item_size);
     }
 
@@ -227,14 +235,15 @@ reader_t *setup_reader(const char *const trace_path, const trace_type_e trace_ty
  */
 int read_one_req(reader_t *const reader, request_t *const req) {
   if (reader->mmap_offset >= reader->file_size) {
-    DEBUG("read_one_req: end of file, current mmap_offset %zu, file size %zu\n", reader->mmap_offset,
-          reader->file_size);
+    DEBUG("read_one_req: end of file, current mmap_offset %zu, file size %zu\n",
+          reader->mmap_offset, reader->file_size);
     req->valid = false;
     return 1;
   }
 
   if (reader->cap_at_n_req > 1 && reader->n_read_req >= reader->cap_at_n_req) {
-    DEBUG("read_one_req: processed %ld requests capped by the user\n", (long)reader->n_read_req);
+    DEBUG("read_one_req: processed %ld requests capped by the user\n",
+          (long)reader->n_read_req);
     req->valid = false;
     return 1;
   }
@@ -305,8 +314,8 @@ int read_one_req(reader_t *const reader, request_t *const req) {
     sampler_t *sampler = reader->sampler;
     reader->sampler = NULL;
     while (!sampler->sample(sampler, req)) {
-      VVERBOSE("skip 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);
+      VVERBOSE("skip 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->read_direction == READ_FORWARD) {
         status = read_one_req(reader, req);
       } else {
@@ -324,8 +333,8 @@ int read_one_req(reader_t *const reader, request_t *const req) {
     req->obj_size = 1;
   }
 
-  VVERBOSE("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);
+  VVERBOSE("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);
 
   return status;
 }
@@ -354,7 +363,8 @@ int go_back_one_req(reader_t *const reader) {
         seek_size = MIN(PER_SEEK_SIZE, max_seek_size - total_seek_size);
         total_seek_size += seek_size;
         fseek(reader->file, -seek_size, SEEK_CUR);
-        ssize_t read_size = fread(reader->line_buf, 1, seek_size - 1, reader->file);
+        ssize_t read_size =
+            fread(reader->line_buf, 1, seek_size - 1, reader->file);
         reader->line_buf[read_size - 1] = 0;
         char *last_line_end = strrchr(reader->line_buf, '\n');
 
@@ -385,7 +395,8 @@ int go_back_one_req(reader_t *const reader) {
       }
       break;
     case BINARY_TRACE_FORMAT:
-      if (reader->mmap_offset >= reader->trace_start_offset + reader->item_size) {
+      if (reader->mmap_offset >=
+          reader->trace_start_offset + reader->item_size) {
         reader->mmap_offset -= (reader->item_size);
         return 0;
       } else {
@@ -523,7 +534,8 @@ int64_t get_num_of_req(reader_t *const reader) {
 }
 
 reader_t *clone_reader(const reader_t *const reader_in) {
-  reader_t *reader = setup_reader(reader_in->trace_path, reader_in->trace_type, &reader_in->init_params);
+  reader_t *reader = setup_reader(reader_in->trace_path, reader_in->trace_type,
+                                  &reader_in->init_params);
   reader->n_total_req = reader_in->n_total_req;
 
   if (reader->trace_format != TXT_TRACE_FORMAT) {
@@ -638,7 +650,9 @@ void read_last_req(reader_t *reader, request_t *req) {
 
 bool is_str_num(const char *str, size_t len) {
   for (size_t i = 0; i < len; i++) {
-    if (!(isdigit(str[i]) || (str[i] >= 'a' && str[i] <= 'f') || (str[i] >= 'A' && str[i] <= 'F'))) return false;
+    if (!(isdigit(str[i]) || (str[i] >= 'a' && str[i] <= 'f') ||
+          (str[i] >= 'A' && str[i] <= 'F')))
+      return false;
   }
   return true;
 }

test/test_3lcache.c

@@ -7,7 +7,9 @@
 #define ThreeLCache_CACHE_SIZE (4 * GiB)
 #define ThreeLCache_STEP_SIZE GiB
 
-static void _verify_profiler_results(const cache_stat_t *res, uint64_t num_of_sizes, uint64_t req_cnt_true,
+static void _verify_profiler_results(const cache_stat_t *res,
+                                     uint64_t num_of_sizes,
+                                     uint64_t req_cnt_true,
                                      const uint64_t *miss_cnt_true) {
   for (uint64_t i = 0; i < num_of_sizes; i++) {
     g_assert_cmpuint(req_cnt_true, ==, res[i].n_req);
@@ -22,10 +24,12 @@ static void _verify_profiler_results(const cache_stat_t *res, uint64_t num_of_si
 }
 
 static void print_results(const cache_t *cache, const cache_stat_t *res) {
-  for (uint64_t i = 0; i < ThreeLCache_CACHE_SIZE / ThreeLCache_STEP_SIZE; i++) {
-    printf("%s cache size %8.4lf GB, req %" PRIu64 " miss %8" PRIu64 " req_bytes %" PRIu64 " miss_bytes %" PRIu64 "\n",
-           cache->cache_name, (double)res[i].cache_size / (double)GiB, res[i].n_req, res[i].n_miss, res[i].n_req_byte,
-           res[i].n_miss_byte);
+  for (uint64_t i = 0; i < ThreeLCache_CACHE_SIZE / ThreeLCache_STEP_SIZE;
+       i++) {
+    printf("%s cache size %8.4lf GB, req %" PRIu64 " miss %8" PRIu64
+           " req_bytes %" PRIu64 " miss_bytes %" PRIu64 "\n",
+           cache->cache_name, (double)res[i].cache_size / (double)GiB,
+           res[i].n_req, res[i].n_miss, res[i].n_req_byte, res[i].n_miss_byte);
   }
 }
 
@@ -34,13 +38,18 @@ static void test_3LCache_OBJECT_MISS_RATIO(gconstpointer user_data) {
   uint64_t miss_cnt_true[] = {4779140, 4619176, 4099469, 4070435};
 
   reader_t *reader = (reader_t *)user_data;
-  common_cache_params_t cc_params = {.cache_size = ThreeLCache_CACHE_SIZE, .hashpower = 24, .default_ttl = DEFAULT_TTL};
+  common_cache_params_t cc_params = {.cache_size = ThreeLCache_CACHE_SIZE,
+                                     .hashpower = 24,
+                                     .default_ttl = DEFAULT_TTL};
 
-  cache_t *cache = create_test_cache("3LCache-object-miss-ratio", cc_params, reader, NULL);
+  cache_t *cache =
+      create_test_cache("3LCache-object-miss-ratio", cc_params, reader, NULL);
   g_assert_true(cache != NULL);
-  cache_stat_t *res = simulate_at_multi_sizes_with_step_size(reader, cache, ThreeLCache_STEP_SIZE, NULL, 0, 0, _n_cores(), false);
+  cache_stat_t *res = simulate_at_multi_sizes_with_step_size(
+      reader, cache, ThreeLCache_STEP_SIZE, NULL, 0, 0, _n_cores(), false);
   print_results(cache, res);
-  _verify_profiler_results(res, ThreeLCache_CACHE_SIZE / ThreeLCache_STEP_SIZE, req_cnt_true, miss_cnt_true);
+  _verify_profiler_results(res, ThreeLCache_CACHE_SIZE / ThreeLCache_STEP_SIZE,
+                           req_cnt_true, miss_cnt_true);
   cache->cache_free(cache);
   my_free(sizeof(cache_stat_t), res);
 }
@@ -51,14 +60,19 @@ static void test_3LCache_BYTE_MISS_RATIO(gconstpointer user_data) {
   uint64_t miss_cnt_true[] = {4821107, 4476524, 4374172, 4350448};
 
   reader_t *reader = (reader_t *)user_data;
-  common_cache_params_t cc_params = {.cache_size = ThreeLCache_CACHE_SIZE, .hashpower = 24, .default_ttl = DEFAULT_TTL};
+  common_cache_params_t cc_params = {.cache_size = ThreeLCache_CACHE_SIZE,
+                                     .hashpower = 24,
+                                     .default_ttl = DEFAULT_TTL};
 
-  cache_t *cache = create_test_cache("3LCache-byte-miss-ratio", cc_params, reader, NULL);
+  cache_t *cache =
+      create_test_cache("3LCache-byte-miss-ratio", cc_params, reader, NULL);
   g_assert_true(cache != NULL);
-  cache_stat_t *res = simulate_at_multi_sizes_with_step_size(reader, cache, ThreeLCache_STEP_SIZE, NULL, 0, 0, _n_cores(), false);
+  cache_stat_t *res = simulate_at_multi_sizes_with_step_size(
+      reader, cache, ThreeLCache_STEP_SIZE, NULL, 0, 0, _n_cores(), false);
 
   print_results(cache, res);
-  _verify_profiler_results(res, ThreeLCache_CACHE_SIZE / ThreeLCache_STEP_SIZE, req_cnt_true, miss_cnt_true);
+  _verify_profiler_results(res, ThreeLCache_CACHE_SIZE / ThreeLCache_STEP_SIZE,
+                           req_cnt_true, miss_cnt_true);
   cache->cache_free(cache);
   my_free(sizeof(cache_stat_t), res);
 }
@@ -72,10 +86,13 @@ int main(int argc, char *argv[]) {
 
 #if defined(ENABLE_3L_CACHE) && ENABLE_3L_CACHE == 1
   reader = setup_3LCacheTestData_reader();
-  g_test_add_data_func("/libCacheSim/cacheAlgo_3LCache_OBJECT_MISS_RATIO", reader, test_3LCache_OBJECT_MISS_RATIO);
-  g_test_add_data_func("/libCacheSim/cacheAlgo_3LCache_BYTE_MISS_RATIO", reader, test_3LCache_BYTE_MISS_RATIO);
+  g_test_add_data_func("/libCacheSim/cacheAlgo_3LCache_OBJECT_MISS_RATIO",
+                       reader, test_3LCache_OBJECT_MISS_RATIO);
+  g_test_add_data_func("/libCacheSim/cacheAlgo_3LCache_BYTE_MISS_RATIO", reader,
+                       test_3LCache_BYTE_MISS_RATIO);
 
-  g_test_add_data_func_full("/libCacheSim/empty", reader, empty_test, test_teardown);
+  g_test_add_data_func_full("/libCacheSim/empty", reader, empty_test,
+                            test_teardown);
 #endif /* ENABLE_3L_CACHE */
 
   return g_test_run();