[Fix]: Compiling LRB, GL and 3L Cache on macOS (#280)

* Fix the compilation of LRB on macOS

* Fix the compilation of GLCache on macOS

* Fix the compilation of 3L Cache

* Clean up

* Revert README

Author: haochengxia

libCacheSim/cache/eviction/3LCache/ThreeLCache.cpp

@@ -382,14 +382,13 @@ pair<uint64_t, int32_t> ThreeLCacheCache::evict_predobj() {
 
 void ThreeLCacheCache::prediction(vector<int32_t> sampled_objects) {
   int32_t sample_nums = sampled_objects.size();
-  int32_t indptr[sample_nums + 1];
-  indptr[0] = 0;
-  int32_t indices[sample_nums * n_feature];
-  double data[sample_nums * n_feature];
-  int32_t past_timestamps[sample_nums];
-  int32_t sizes[sample_nums];
-  uint64_t keys[sample_nums];
-  int32_t poses[sample_nums];
+  std::vector<int32_t> indptr(sample_nums + 1, 0);
+  std::vector<int32_t> indices(sample_nums * n_feature);
+  std::vector<double> data(sample_nums * n_feature);
+  std::vector<int32_t> past_timestamps(sample_nums);
+  std::vector<int32_t> sizes(sample_nums);
+  std::vector<uint64_t> keys(sample_nums);
+  std::vector<int32_t> poses(sample_nums);
   unsigned int idx_feature = 0;
   int32_t pos;
   unsigned int idx_row = 0;
@@ -430,18 +429,19 @@ void ThreeLCacheCache::prediction(vector<int32_t> sampled_objects) {
     indptr[idx_row + 1] = idx_feature;
   }
   int64_t len = 0;
-  double scores[sample_nums];
+  std::vector<double> scores(sample_nums);
   std::string inference_params_str;
   for (const auto &param : inference_params) {
     inference_params_str += param.first + "=" + param.second + " ";
   }
   inference_params_str.pop_back();  // Remove trailing space
   const char *inference_params_cstr = inference_params_str.c_str();
   LGBM_BoosterPredictForCSR(
-      booster, static_cast<void *>(indptr), C_API_DTYPE_INT32, indices,
-      static_cast<void *>(data), C_API_DTYPE_FLOAT64, idx_row + 1, idx_feature,
+      booster, static_cast<void *>(indptr.data()), C_API_DTYPE_INT32,
+      indices.data(), static_cast<void *>(data.data()), C_API_DTYPE_FLOAT64,
+      idx_row + 1, idx_feature,
       n_feature,  // remove future t
-      C_API_PREDICT_NORMAL, 0, 0, inference_params_cstr, &len, scores);
+      C_API_PREDICT_NORMAL, 0, 0, inference_params_cstr, &len, scores.data());
   float _distance;
   if (objective == byte_miss_ratio) {
     for (int i = 0; i < sample_nums; ++i) {

libCacheSim/cache/eviction/3LCache/ThreeLCache.hpp

@@ -388,9 +388,11 @@ class ThreeLCacheCache : public webcachesim::Cache {
 
   void update_stat_periodic() override;
 
-  void setSize(const uint64_t &cs) { _cacheSize = cs; }
+  void setSize(const uint64_t &cs) override { _cacheSize = cs; }
 
-  bool exist(const int64_t &key) { return key_map.find(key) != key_map.end(); }
+  bool exist(const int64_t &key) override {
+    return key_map.find(key) != key_map.end();
+  }
 
   pair<uint64_t, int32_t> evict_predobj();
 

libCacheSim/cache/eviction/3LCache/cache.h

@@ -69,7 +69,7 @@ class Cache {
       std::cerr << "unknown cacheType" << std::endl;
       return nullptr;
     }
-    Cache_instance = std::move(get_factory_instance()[name]->create_unique());
+    Cache_instance = get_factory_instance()[name]->create_unique();
     return Cache_instance;
   }
 

libCacheSim/cache/eviction/GLCache/GLCache.c

@@ -446,9 +446,10 @@ static void GLCache_evict(cache_t *cache, const request_t *req) {
     if (params->curr_rtime - last_print_time > 3600 * 6) {
       last_print_time = params->curr_rtime;
       WARN(
-          "%.2lf hour, cache size %lu MB, %d segs, evicting and cannot merge\n",
-          (double)params->curr_rtime / 3600.0, cache->cache_size / 1024 / 1024,
-          params->n_in_use_segs);
+          "%.2lf hour, cache size %lld MB, %d segs, evicting and cannot "
+          "merge\n",
+          (double)params->curr_rtime / 3600.0,
+          (long long)(cache->cache_size / 1024 / 1024), params->n_in_use_segs);
     }
 
     evict_one_seg(cache, params->obj_sel.segs_to_evict[0]);

libCacheSim/cache/eviction/GLCache/README

@@ -58,4 +58,3 @@ to evict/write `cache_size`' bytes.
 
 
 
-

libCacheSim/cache/eviction/GLCache/train.c

@@ -8,11 +8,11 @@
 
 static void debug_print_feature_matrix(const DMatrixHandle handle,
                                        int print_n_row) {
-  unsigned long out_len;
+  bst_ulong out_len;
   const float *out_data;
   XGDMatrixGetFloatInfo(handle, "label", &out_len, &out_data);
 
-  printf("out_len: %lu\n", out_len);
+  printf("out_len: %llu\n", (unsigned long long)out_len);
   for (int i = 0; i < print_n_row; i++) {
     printf("%.4f, ", out_data[i]);
   }

libCacheSim/cache/eviction/LRB/cache.h

@@ -69,7 +69,7 @@ class Cache {
       std::cerr << "unknown cacheType" << std::endl;
       return nullptr;
     }
-    Cache_instance = std::move(get_factory_instance()[name]->create_unique());
+    Cache_instance = get_factory_instance()[name]->create_unique();
     return Cache_instance;
   }
 

libCacheSim/cache/eviction/LRB/lrb.cpp

@@ -284,16 +284,16 @@ pair<uint64_t, uint32_t> LRBCache::rank() {
     }
   }
 
-  int32_t indptr[sample_rate + 1];
+  std::vector<int32_t> indptr(sample_rate + 1);
   indptr[0] = 0;
-  int32_t indices[sample_rate * n_feature];
-  double data[sample_rate * n_feature];
-  int32_t past_timestamps[sample_rate];
-  uint64_t sizes[sample_rate];
+  std::vector<int32_t> indices(sample_rate * n_feature);
+  std::vector<double> data(sample_rate * n_feature);
+  std::vector<int32_t> past_timestamps(sample_rate);
+  std::vector<uint64_t> sizes(sample_rate);
 
   unordered_set<uint64_t> key_set;
-  uint64_t keys[sample_rate];
-  uint32_t poses[sample_rate];
+  std::vector<uint64_t> keys(sample_rate);
+  std::vector<uint32_t> poses(sample_rate);
   // next_past_timestamp, next_size = next_indptr - 1
 
   unsigned int idx_feature = 0;
@@ -365,16 +365,17 @@ pair<uint64_t, uint32_t> LRBCache::rank() {
   }
 
   int64_t len;
-  double scores[sample_rate];
+  std::vector<double> scores(sample_rate);
   system_clock::time_point timeBegin;
   // sample to measure inference time
   if (!(current_seq % 10000)) timeBegin = chrono::system_clock::now();
   LGBM_BoosterPredictForCSR(
-      booster, static_cast<void *>(indptr), C_API_DTYPE_INT32, indices,
-      static_cast<void *>(data), C_API_DTYPE_FLOAT64, idx_row + 1, idx_feature,
+      booster, static_cast<void *>(indptr.data()), C_API_DTYPE_INT32,
+      indices.data(), static_cast<void *>(data.data()), C_API_DTYPE_FLOAT64,
+      idx_row + 1, idx_feature,
       n_feature,  // remove future t
       C_API_PREDICT_NORMAL, 0, atoi(training_params["num_iterations"].c_str()),
-      map_to_string(inference_params).c_str(), &len, scores);
+      map_to_string(inference_params).c_str(), &len, scores.data());
   if (!(current_seq % 10000))
     inference_time = 0.95 * inference_time +
                      0.05 * chrono::duration_cast<chrono::microseconds>(

libCacheSim/cache/eviction/LRB/lrb.h

@@ -433,7 +433,7 @@ class LRBCache : public Cache {
   void remove_from_outcache_metas(Meta &meta, unsigned int &pos,
                                   const uint64_t &key);
 
-  bool has(const uint64_t &id) {
+  bool has(const uint64_t &id) override {
     auto it = key_map.find(id);
     if (it == key_map.end()) return false;
     return !it->second.list_idx;