Fix mem leak excepting Quark

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: Release
+  BUILD_TYPE: Debug
 
 jobs:
   # macos:
@@ -45,7 +45,7 @@ jobs:
         run: |
           # Set ASan/LSan options for runtime detection
           export ASAN_OPTIONS="detect_leaks=1:halt_on_error=1:verbosity=1"
-          ctest -C ${{env.BUILD_TYPE}}
+          ctest -C ${{env.BUILD_TYPE}} --output-on-failure
 
   selfhosted:
     runs-on: self-hosted

libCacheSim/cache/eviction/LFUDA.c

@@ -102,6 +102,7 @@ cache_t *LFUDA_init(const common_cache_params_t ccache_params,
 static void LFUDA_free(cache_t *cache) {
   LFUDA_params_t *params = (LFUDA_params_t *)(cache->eviction_params);
   g_hash_table_destroy(params->freq_map);
+  free(params);
   cache_struct_free(cache);
 }
 

libCacheSim/cache/eviction/LIRS.c

@@ -27,6 +27,13 @@ typedef struct LIRS_params {
   uint64_t nonresident;
 } LIRS_params_t;
 
+/**
+ * @brief local request for thread local storage
+ */
+static __thread request_t *req_local_hit_RD_HIRinQ = NULL;
+static __thread request_t *req_local_evictLIR = NULL;
+static __thread request_t *req_local_evictHIR = NULL;
+
 // ***********************************************************************
 // ****                                                               ****
 // ****                   function declarations                       ****
@@ -125,6 +132,20 @@ static void LIRS_free(cache_t *cache) {
   params->LRU_s->cache_free(params->LRU_s);
   params->LRU_q->cache_free(params->LRU_q);
   params->LRU_nh->cache_free(params->LRU_nh);
+
+  if (req_local_hit_RD_HIRinQ != NULL) {
+    free_request(req_local_hit_RD_HIRinQ);
+    req_local_hit_RD_HIRinQ = NULL;
+  }
+  if (req_local_evictLIR != NULL) {
+    free_request(req_local_evictLIR);
+    req_local_evictLIR = NULL;
+  }
+  if (req_local_evictHIR != NULL) {
+    free_request(req_local_evictHIR);
+    req_local_evictHIR = NULL;
+  }
+
   my_free(sizeof(LIRS_params_t), params);
   cache_struct_free(cache);
 }
@@ -553,9 +574,10 @@ 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) {
-    params->hirs_count -= 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 -= cache_obj_q->obj_size;
+    cache->occupied_byte -= obj_size;
     cache->n_obj--;
   }
 
@@ -583,19 +605,17 @@ static cache_obj_t *hit_NR_HIRinS(cache_t *cache, cache_obj_t *cache_obj_s) {
 
 static cache_obj_t *hit_RD_HIRinQ(cache_t *cache, cache_obj_t *cache_obj_q) {
   LIRS_params_t *params = (LIRS_params_t *)(cache->eviction_params);
-
-  static __thread request_t *req_local = NULL;
-  if (req_local == NULL) {
-    req_local = new_request();
+  if (req_local_hit_RD_HIRinQ == NULL) {
+    req_local_hit_RD_HIRinQ = new_request();
   }
-  copy_cache_obj_to_request(req_local, cache_obj_q);
+  copy_cache_obj_to_request(req_local_hit_RD_HIRinQ, cache_obj_q);
 
   while (params->lirs_count + cache_obj_q->obj_size > params->lirs_limit) {
     evictLIR(cache);
   }
-  params->LRU_s->insert(params->LRU_s, req_local);
+  params->LRU_s->insert(params->LRU_s, req_local_hit_RD_HIRinQ);
   cache_obj_t *obj_to_update =
-      params->LRU_s->find(params->LRU_s, req_local, false);
+      params->LRU_s->find(params->LRU_s, req_local_hit_RD_HIRinQ, false);
   obj_to_update->LIRS.is_LIR = false;
   obj_to_update->LIRS.in_cache = true;
 
@@ -606,30 +626,29 @@ static void evictLIR(cache_t *cache) {
   LIRS_params_t *params = (LIRS_params_t *)(cache->eviction_params);
   cache_obj_t *obj_to_evict = params->LRU_s->to_evict(params->LRU_s, NULL);
 
-  static __thread request_t *req_local = NULL;
-  if (req_local == NULL) {
-    req_local = new_request();
+  if (req_local_evictLIR == NULL) {
+    req_local_evictLIR = new_request();
   }
-  copy_cache_obj_to_request(req_local, obj_to_evict);
+  copy_cache_obj_to_request(req_local_evictLIR, obj_to_evict);
   params->lirs_count -= obj_to_evict->obj_size;
   params->LRU_s->evict(params->LRU_s, NULL);
 
-  cache->occupied_byte -= (req_local->obj_size + cache->obj_md_size);
+  cache->occupied_byte -= (req_local_evictLIR->obj_size + cache->obj_md_size);
   cache->n_obj -= 1;
 
-  if ((uint64_t)req_local->obj_size <= params->hirs_limit) {
-    while ((uint64_t)params->hirs_count + req_local->obj_size > params->hirs_limit) {
+  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) {
       evictHIR(cache);
     }
-    params->LRU_q->insert(params->LRU_q, req_local);
+    params->LRU_q->insert(params->LRU_q, req_local_evictLIR);
 
     cache_obj_t *obj_to_update =
-        params->LRU_q->find(params->LRU_q, req_local, false);
+        params->LRU_q->find(params->LRU_q, req_local_evictLIR, false);
     obj_to_update->LIRS.is_LIR = false;
     obj_to_update->LIRS.in_cache = true;
 
-    params->hirs_count += req_local->obj_size;
-    cache->occupied_byte += (req_local->obj_size + cache->obj_md_size);
+    params->hirs_count += req_local_evictLIR->obj_size;
+    cache->occupied_byte += (req_local_evictLIR->obj_size + cache->obj_md_size);
     cache->n_obj += 1;
   }
 
@@ -642,24 +661,23 @@ static bool evictHIR(cache_t *cache) {
   cache_obj_t *obj_to_evict = params->LRU_q->to_evict(params->LRU_q, NULL);
 
   // update the corresponding block in S to be non-resident
-  static __thread request_t *req_local = NULL;
-  if (req_local == NULL) {
-    req_local = new_request();
+  if (req_local_evictHIR == NULL) {
+    req_local_evictHIR = new_request();
   }
-  copy_cache_obj_to_request(req_local, obj_to_evict);
+  copy_cache_obj_to_request(req_local_evictHIR, obj_to_evict);
 
   params->hirs_count -= obj_to_evict->obj_size;
   params->LRU_q->evict(params->LRU_q, NULL);
 
   cache_obj_t *obj_to_update =
-      params->LRU_s->find(params->LRU_s, req_local, false);
+      params->LRU_s->find(params->LRU_s, req_local_evictHIR, false);
   if (obj_to_update != NULL) {
     obj_to_update->LIRS.in_cache = false;
-    params->LRU_nh->insert(params->LRU_nh, req_local);
+    params->LRU_nh->insert(params->LRU_nh, req_local_evictHIR);
     params->nonresident += obj_to_update->obj_size;
   }
 
-  cache->occupied_byte -= (req_local->obj_size + cache->obj_md_size);
+  cache->occupied_byte -= (req_local_evictHIR->obj_size + cache->obj_md_size);
   cache->n_obj -= 1;
 
   return true;

libCacheSim/cache/eviction/LRU.c

@@ -86,7 +86,11 @@ cache_t *LRU_init(const common_cache_params_t ccache_params,
  *
  * @param cache
  */
-static void LRU_free(cache_t *cache) { cache_struct_free(cache); }
+static void LRU_free(cache_t *cache) {
+  LRU_params_t *params = (LRU_params_t *)cache->eviction_params;
+  free(params);
+  cache_struct_free(cache);
+}
 
 /**
  * @brief this function is the user facing API

libCacheSim/cache/eviction/SLRU.c

@@ -202,6 +202,7 @@ static void SLRU_free(cache_t *cache) {
   free(params->lru_tails);
   free(params->lru_n_objs);
   free(params->lru_n_bytes);
+  free(params);
   cache_struct_free(cache);
 }
 

libCacheSim/mrcProfiler/mrcProfiler.cpp

@@ -324,4 +324,7 @@ void mrcProfiler::MRCProfilerMINISIM::run() {
       hit_size_vec[i] = sum_obj_size_req - result[i].n_miss_byte;
     }
   }
+  // clean up
+  my_free(sizeof(cache_stat_t) * mrc_size_vec.size(), result);
+  free_request(req);
 }

libCacheSim/traceReader/reader.c

@@ -512,6 +512,8 @@ int64_t get_num_of_req(reader_t *const reader) {
     while (read_one_req(reader_copy, req) == 0) {
       n_req++;
     }
+    free_request(req);
+    close_reader(reader_copy);
   } else {
     ERROR("should not reach here\n");
     abort();

test/test_admissionAlgo.c

@@ -120,7 +120,7 @@ int main(int argc, char *argv[]) {
   g_test_add_data_func("/libCacheSim/admissionAlgo_AdaptSize", reader, test_AdaptSize);
   g_test_add_data_func("/libCacheSim/admissionAlgo_Size", reader, test_Size);
   g_test_add_data_func("/libCacheSim/admissionAlgo_SizeProb", reader, test_SizeProb);
-  g_test_add_data_func("/libCacheSim/admissionAlgo_BloomFilter", reader, test_BloomFilter);
+  g_test_add_data_func_full("/libCacheSim/admissionAlgo_BloomFilter", reader, test_BloomFilter, test_teardown);
 
   return g_test_run();
 }

test/test_dataStructure.c

@@ -27,13 +27,15 @@ void test_chained_hashtable_v2(gconstpointer user_data) {
   print_chained_hashtable_v2(hashtable);
   // cache_obj_t *obj = chained_hashtable_rand_obj_v2(hashtable);
   // printf("random object %lu\n", obj->obj_id);
+
+  // clean up
+  free_request(req);
+  free_chained_hashtable_v2(hashtable);
 }
 
 int main(int argc, char *argv[]) {
   g_test_init(&argc, &argv, NULL);
-  reader_t *reader;
 
-  reader = setup_plaintxt_reader_num();
   g_test_add_data_func("/libCacheSim/test_chained_hashtable_v2", NULL, test_chained_hashtable_v2);
 
   return g_test_run();

test/test_dist.c

@@ -22,23 +22,26 @@ void test_distUtils_basic(gconstpointer user_data) {
   for (i = (long)get_num_of_req(reader) - 1, j = 0; j < N_TEST; i--, j++) {
     g_assert_cmpint(dist[i], ==, rd_true[j]);
   }
+  free(dist);
 
   dist = get_stack_dist(reader, FUTURE_STACK_DIST, &array_size);
   g_assert_cmpint(array_size, ==, get_num_of_req(reader));
   for (i = 6, j = 0; j < N_TEST; i++, j++) {
     g_assert_cmpint(dist[i], ==, frd_true[j]);
   }
+  free(dist);
 
   dist = get_access_dist(reader, DIST_SINCE_LAST_ACCESS, &array_size);
   g_assert_cmpint(array_size, ==, get_num_of_req(reader));
   for (i = (long)get_num_of_req(reader) - 1, j = 0; j < N_TEST; i--, j++) {
     g_assert_cmpint(dist[i], ==, last_dist_true[j]);
   }
-
+  free(dist);
   // dist = get_next_access_dist(reader);
   // for (i = 6, j = 0; j < N_TEST; i++, j++) {
   //   g_assert_cmpint(dist[i], ==, next_dist_true[j]);
   // }
+  // free(dist);
 }
 
 void test_distUtils_more1(gconstpointer user_data) {