LRU_K: harden param parsing and account for K in obj_md_size

- Replace `strstr("k=") + atoi` with `strsep`-based key=value tokenizer
  that matches the SLRU pattern. Avoids fragile substring matches
  (e.g. embedded "k=" in unrelated keys), validates the value with
  `strtol` (no silent truncation), errors on unknown keys, and adds
  a `print` parameter consistent with other algos.
- Reorder LRU_K_init so parse_params runs before obj_md_size, and
  scale per-object metadata as `8 * k + 16` (history vtimes + node
  overhead) instead of a fixed 8 bytes that ignored K.

Author: 1a1a11a

libCacheSim/cache/eviction/cpp/LRU_K.cpp

@@ -13,6 +13,8 @@
  */
 
 #include <cassert>
+#include <cstdlib>
+#include <cstring>
 #include <deque>
 #include <list>
 #include <set>
@@ -81,25 +83,46 @@ static bool LRU_K_remove(cache_t *cache, obj_id_t obj_id);
 /**
  * @brief parse algorithm-specific parameters
  *
- * Supported parameters:
- *   k=<int>   number of accesses to track (default: 2)
+ * Supported parameters (comma-separated key=value pairs):
+ *   k=<int>   number of accesses to track (default: 2, must be >= 1)
  */
 static void LRU_K_parse_params(cache_t *cache,
-                                const char *cache_specific_params) {
-  auto *lruk =
-      reinterpret_cast<eviction::LRU_K *>(cache->eviction_params);
+                               const char *cache_specific_params) {
+  auto *lruk = reinterpret_cast<eviction::LRU_K *>(cache->eviction_params);
   if (cache_specific_params == nullptr || cache_specific_params[0] == '\0')
     return;
 
-  const char *k_str = strstr(cache_specific_params, "k=");
-  if (k_str != nullptr) {
-    int k_val = atoi(k_str + 2);
-    if (k_val >= 1) {
-      lruk->k = k_val;
+  char *params_str = strdup(cache_specific_params);
+  char *to_free = params_str;
+  char *end = nullptr;
+
+  while (params_str != nullptr && params_str[0] != '\0') {
+    char *key = strsep(&params_str, "=");
+    char *value = strsep(&params_str, ",");
+
+    while (params_str != nullptr && *params_str == ' ') params_str++;
+
+    if (strcasecmp(key, "k") == 0) {
+      if (value == nullptr || value[0] == '\0') {
+        ERROR("LRU_K: missing value for k\n");
+      }
+      long k_val = strtol(value, &end, 0);
+      if (end == value || (end != nullptr && *end != '\0')) {
+        ERROR("LRU_K: invalid k value \"%s\"\n", value);
+      }
+      if (k_val < 1) {
+        ERROR("LRU_K: k must be >= 1, got %ld\n", k_val);
+      }
+      lruk->k = static_cast<int>(k_val);
+    } else if (strcasecmp(key, "print") == 0) {
+      printf("LRU_K parameters: k=%d\n", lruk->k);
+      exit(0);
     } else {
-      WARN("LRU_K: invalid k value %d, using default k=2\n", k_val);
+      ERROR("LRU_K does not have parameter %s\n", key);
     }
   }
+
+  free(to_free);
 }
 
 /**
@@ -123,14 +146,16 @@ cache_t *LRU_K_init(const common_cache_params_t ccache_params,
   cache->to_evict = LRU_K_to_evict;
   cache->remove = LRU_K_remove;
 
+  LRU_K_parse_params(cache, cache_specific_params);
+
   if (ccache_params.consider_obj_metadata) {
-    cache->obj_md_size = 8;
+    auto *lruk = reinterpret_cast<eviction::LRU_K *>(cache->eviction_params);
+    /* per-object overhead: K vtimes in history + map entry + queue/set node */
+    cache->obj_md_size = 8 * lruk->k + 16;
   } else {
     cache->obj_md_size = 0;
   }
 
-  LRU_K_parse_params(cache, cache_specific_params);
-
   return cache;
 }