Fix hit ratio issue by fixing key generation logic

Summary:
Adding useLegacyKeyGen option to fill the gap between the old test config files based on old key generate logic which was changed by D23183497 back in 2020.
Currently we cannot generate expected key pattern and hit ratio with the existing test configs and it's causing problem in our SSD qual process.

Reviewed By: therealgymmy

Differential Revision: D69520704

fbshipit-source-id: 3bedef7c4851cc4d94fb93fe912a6d20efb5ddd0

Author: byahn0996

cachelib/cachebench/test_configs/ssd_perf/graph_cache_leader/config.json

@@ -53,7 +53,8 @@
         "loneGetRatio": 0.2315436539873129,
         "popDistFile": "fbobj_pop.json",
         "setRatio": 0.0,
-        "valSizeDistFile": "fbobj_sizes.json"
+        "valSizeDistFile": "fbobj_sizes.json",
+        "useLegacyKeyGen": true
       },
       {
         "addChainedRatio": 0.0,
@@ -69,7 +70,8 @@
         "loneGetRatio": 0.1158887280020357,
         "popDistFile": "assoc_pop.json",
         "setRatio": 0.0,
-        "valSizeDistFile": "assoc_sizes.json"
+        "valSizeDistFile": "assoc_sizes.json",
+        "useLegacyKeyGen": true
       }
     ]
   }

cachelib/cachebench/test_configs/ssd_perf/kvcache_l2_wc/config.json

@@ -42,7 +42,8 @@
         "setRatio": 0.0,
         "popDistFile": "pop.json",
         "setRatio": 0.0,
-        "valSizeDistFile": "sizes.json"
+        "valSizeDistFile": "sizes.json",
+        "useLegacyKeyGen": true
       }
     ],
 

cachelib/cachebench/util/Config.cpp

@@ -171,6 +171,8 @@ DistributionConfig::DistributionConfig(const folly::dynamic& jsonConfig,
   JSONSetVal(jsonConfig, updateRatio);
   JSONSetVal(jsonConfig, couldExistRatio);
 
+  JSONSetVal(jsonConfig, useLegacyKeyGen);
+
   auto readFile = [&](const std::string& f) {
     std::string str;
     const std::string path = folly::sformat("{}/{}", configPath, f);
@@ -194,7 +196,7 @@ DistributionConfig::DistributionConfig(const folly::dynamic& jsonConfig,
     JSONSetVal(configJsonPop, popularityWeights);
   }
 
-  checkCorrectSize<DistributionConfig, 368>();
+  checkCorrectSize<DistributionConfig, 376>();
 }
 
 ReplayGeneratorConfig::ReplayGeneratorConfig(const folly::dynamic& configJson) {

cachelib/cachebench/util/Config.h

@@ -74,6 +74,21 @@ struct DistributionConfig : public JSONConfig {
   double updateRatio{0.0};
   double couldExistRatio{0.0};
 
+  // Set useLegacyKeyGen true when using the old distribution data based on old
+  // key generation scheme. (ex. test configs like graph_cache_leader or
+  // kvcache_l2_wc).
+  //
+  // Our old key generation scheme didn't populate all the keys within the key
+  // space. It was just using some of the keys which was grabbed for the
+  // popularity data from the production workload. So, even though numKeys in
+  // config can be configured to any number, # of total utilized keys are always
+  // # of collected keys or less than that. This was changed to generate any key
+  // within the key space given by numKeys, but with the new scheme, old test
+  // configs key population data is not working anymore. Since we still need to
+  // test with the old test configs based on old key generation scheme, this
+  // option is added.
+  bool useLegacyKeyGen{false};
+
   bool usesChainedItems() const { return addChainedRatio > 0; }
 
   // for continuous value sizes, the probability is expressed per interval

cachelib/cachebench/workload/FastDiscrete.h

@@ -82,8 +82,11 @@ class FastDiscreteDistribution final : public Distribution {
                            size_t right,
                            std::vector<size_t> sizes,
                            std::vector<double> probs,
+                           bool useLegacyKeyGen,
                            size_t numBuckets = 2048)
-      : leftOffset_(left), rightOffset_(right) {
+      : leftOffset_(left),
+        rightOffset_(right),
+        useLegacyKeyGen_(useLegacyKeyGen) {
     double totalWeight = std::accumulate(probs.begin(), probs.end(), 0.0);
     double totalObjects = std::accumulate(sizes.begin(), sizes.end(), 0.0);
     bucketWeight_ = totalWeight / numBuckets;
@@ -113,15 +116,25 @@ class FastDiscreteDistribution final : public Distribution {
         // Determine bucket size. In doing so, take max against 1
         // before and after scaling to account for scaling factors
         objectsSeen = std::max(1UL, objectsSeen);
-        auto scaledObjects =
-            static_cast<uint64_t>(objectsSeen * scalingFactor_);
-        buckets.push_back(std::max(1UL, scaledObjects));
-        DCHECK_LE(bucketOffsets_.back() + buckets.back(), rightOffset_);
-
-        // determine the offset for next bucket
-        auto nextOffset = static_cast<uint64_t>(sumObjects * scalingFactor_);
-        bucketOffsets_.push_back(nextOffset);
-        DCHECK_LE(nextOffset, rightOffset_);
+
+        if (useLegacyKeyGen_) {
+          buckets.push_back(std::max(1UL, objectsSeen));
+          DCHECK_LE(bucketOffsets_.back() + buckets.back(), rightOffset_);
+
+          bucketOffsets_.push_back(sumObjects);
+          DCHECK_LE(sumObjects, rightOffset_);
+        } else {
+          auto scaledObjects =
+              static_cast<uint64_t>(objectsSeen * scalingFactor_);
+          buckets.push_back(std::max(1UL, scaledObjects));
+          DCHECK_LE(bucketOffsets_.back() + buckets.back(), rightOffset_);
+
+          // determine the offset for next bucket
+          auto nextOffset = static_cast<uint64_t>(sumObjects * scalingFactor_);
+          bucketOffsets_.push_back(nextOffset);
+          DCHECK_LE(nextOffset, rightOffset_);
+        }
+
         weightSeen = 0.0;
         objectsSeen = 0;
       } else {
@@ -147,8 +160,9 @@ class FastDiscreteDistribution final : public Distribution {
     size_t bucket = bucketDistribution_(gen);
     size_t objectInBucket = facebook::cachelib::util::narrow_cast<size_t>(
         insideBucketDistributions_[bucket](gen));
+    auto multiplier = useLegacyKeyGen_ ? scalingFactor_ : 1;
     auto ret = facebook::cachelib::util::narrow_cast<size_t>(
-                   (bucketOffsets_[bucket] + objectInBucket)) +
+                   (multiplier * (bucketOffsets_[bucket] + objectInBucket))) +
                leftOffset_;
     XDCHECK_LE(ret, rightOffset_);
     XDCHECK_GE(ret, leftOffset_);
@@ -169,6 +183,7 @@ class FastDiscreteDistribution final : public Distribution {
   std::vector<uint64_t> bucketOffsets_{};
   const size_t leftOffset_{};
   const size_t rightOffset_{};
+  bool useLegacyKeyGen_{false};
   double scalingFactor_{};
   double bucketWeight_{};
   std::uniform_int_distribution<uint64_t> bucketDistribution_{};

cachelib/cachebench/workload/WorkloadDistribution.h

@@ -92,7 +92,11 @@ class WorkloadDistribution {
   std::unique_ptr<Distribution> getPopDist(size_t left, size_t right) const {
     if (config_.usesDiscretePopularity()) {
       return std::make_unique<FastDiscreteDistribution>(
-          left, right, config_.popularityBuckets, config_.popularityWeights);
+          left,
+          right,
+          config_.popularityBuckets,
+          config_.popularityWeights,
+          config_.useLegacyKeyGen);
     } else {
       // TODO In general, could have different keyFrequency factor besides 2
       double mu = (left + right) * 0.5;