Add itemValue to cachebench

Summary: This adds `itemValue`, a `uint64_t`, to the cache trace. This is used to store the user/intern flag. We gave it an intentionally vague name, because we were concerned with putting stuff about user/intern split into the open source code. Other users of this code can use itemValue for whatever they want.

Differential Revision: D41134915

fbshipit-source-id: aa26ce715b70a4c95bb0678443832273522b4fa4

Author: Jim Cipar

cachelib/cachebench/runner/CacheStressor.h

@@ -239,14 +239,20 @@ class CacheStressor : public Stressor {
   }
 
   // populate the input item handle according to the stress setup.
-  void populateItem(WriteHandle& handle) {
+  void populateItem(WriteHandle& handle, const std::string& itemValue = "") {
     if (!config_.populateItem) {
       return;
     }
     XDCHECK(handle);
     XDCHECK_LE(cache_->getSize(handle), 4ULL * 1024 * 1024);
     if (cache_->consistencyCheckEnabled()) {
       cache_->setUint64ToItem(handle, folly::Random::rand64(rng));
+    }
+
+    if (!itemValue.empty()) {
+      // Add the null character to ensure this is a proper c string.
+      // TODO(T141356292): Clean this up to avoid allocating a new string
+      cache_->setStringItem(handle, itemValue + "\0");
     } else {
       cache_->setStringItem(handle, hardcodedString_);
     }
@@ -323,7 +329,7 @@ class CacheStressor : public Stressor {
           }
           auto lock = chainedItemAcquireUniqueLock(*key);
           result = setKey(pid, stats, key, *(req.sizeBegin), req.ttlSecs,
-                          req.admFeatureMap);
+                          req.admFeatureMap, req.itemValue);
 
           break;
         }
@@ -353,7 +359,7 @@ class CacheStressor : public Stressor {
               slock = {};
               xlock = chainedItemAcquireUniqueLock(*key);
               setKey(pid, stats, key, *(req.sizeBegin), req.ttlSecs,
-                     req.admFeatureMap);
+                     req.admFeatureMap, req.itemValue);
             }
           } else {
             result = OpResultType::kGetHit;
@@ -462,7 +468,8 @@ class CacheStressor : public Stressor {
       const std::string* key,
       size_t size,
       uint32_t ttlSecs,
-      const std::unordered_map<std::string, std::string>& featureMap) {
+      const std::unordered_map<std::string, std::string>& featureMap,
+      const std::string& itemValue) {
     // check the admission policy first, and skip the set operation
     // if the policy returns false
     if (config_.admPolicy && !config_.admPolicy->accept(featureMap)) {
@@ -475,7 +482,7 @@ class CacheStressor : public Stressor {
       ++stats.setFailure;
       return OpResultType::kSetFailure;
     } else {
-      populateItem(it);
+      populateItem(it, itemValue);
       cache_->insertOrReplace(it);
       return OpResultType::kSetSuccess;
     }
@@ -501,7 +508,8 @@ class CacheStressor : public Stressor {
       if (config_.checkConsistency && cache_->isInvalidKey(req.key)) {
         continue;
       }
-      // TODO: allow callback on nvm eviction instead of checking it repeatedly.
+      // TODO: allow callback on nvm eviction instead of checking it
+      // repeatedly.
       if (config_.checkNvmCacheWarmUp &&
           folly::Random::oneIn(kNvmCacheWarmUpCheckRate)) {
         checkNvmCacheWarmedUp(req.timestamp);

cachelib/cachebench/util/Request.h

@@ -78,13 +78,15 @@ struct Request {
           OpType o,
           uint32_t ttl,
           uint64_t reqId,
-          const std::unordered_map<std::string, std::string>& admFeatureM)
+          const std::unordered_map<std::string, std::string>& admFeatureM,
+          const std::string& value)
       : key(k),
         sizeBegin(b),
         sizeEnd(e),
         ttlSecs(ttl),
         requestId(reqId),
         admFeatureMap(admFeatureM),
+        itemValue(value),
         op(o) {}
 
   static std::string getUniqueKey() {
@@ -123,6 +125,10 @@ struct Request {
   // May not have to be the same as wall clock
   uint64_t timestamp{0};
 
+  // Use case specific data that will be included in the request. This can be
+  // used to track metadata that is specific to a particular application.
+  std::string itemValue;
+
  private:
   std::atomic<OpType> op{OpType::kGet};
 };

cachelib/cachebench/workload/PieceWiseCache.cpp

@@ -340,7 +340,8 @@ PieceWiseReqWrapper::PieceWiseReqWrapper(
     uint32_t ttl,
     std::vector<std::string>&& statsAggFieldV,
     std::unordered_map<std::string, std::string>&& admFeatureM,
-    folly::Optional<bool> isHit)
+    folly::Optional<bool> isHit,
+    const std::string& itemValue = "")
     : baseKey(GenericPieces::escapeCacheKey(key.str())),
       pieceKey(baseKey),
       sizes(1),
@@ -350,7 +351,8 @@ PieceWiseReqWrapper::PieceWiseReqWrapper(
           opType,
           ttl,
           reqId,
-          admFeatureM),
+          admFeatureM,
+          itemValue),
       requestRange(rangeStart, rangeEnd),
       headerSize(responseHeaderSize),
       fullObjectSize(fullContentSize),
@@ -389,7 +391,8 @@ PieceWiseReqWrapper::PieceWiseReqWrapper(const PieceWiseReqWrapper& other)
           other.req.getOp(),
           other.req.ttlSecs,
           other.req.requestId.value(),
-          other.req.admFeatureMap),
+          other.req.admFeatureMap,
+          other.req.itemValue),
       requestRange(other.requestRange),
       isHeaderPiece(other.isHeaderPiece),
       headerSize(other.headerSize),

cachelib/cachebench/workload/PieceWiseCache.h

@@ -282,6 +282,7 @@ struct PieceWiseReqWrapper {
   // @param ttl: ttl of the content for caching
   // @param statsAggFieldV: extra fields used for stats aggregation
   // @param admFeatureM: features map for admission policy
+  // @param itemValue: client-specific data for the item
 
   explicit PieceWiseReqWrapper(
       uint64_t cachePieceSize,
@@ -296,7 +297,8 @@ struct PieceWiseReqWrapper {
       uint32_t ttl,
       std::vector<std::string>&& statsAggFieldV,
       std::unordered_map<std::string, std::string>&& admFeatureM,
-      folly::Optional<bool> isHit);
+      folly::Optional<bool> isHit,
+      const std::string& itemValue);
 
   PieceWiseReqWrapper(const PieceWiseReqWrapper& other);
 };

cachelib/cachebench/workload/PieceWiseReplayGenerator.cpp

@@ -91,9 +91,10 @@ void PieceWiseReplayGenerator::getReqFromTrace() {
     try {
       std::vector<folly::StringPiece> fields;
       folly::split(",", line, fields);
-      if (fields.size() != totalFieldCount &&
-          // TODO: remove this after legacy data phased out.
-          fields.size() + 1 != totalFieldCount) {
+
+      // TODO: remove this after legacy data phased out.
+      if (fields.size() > totalFieldCount ||
+          fields.size() < totalFieldCount - 2) {
         invalidSamples_.inc();
         continue;
       }
@@ -234,6 +235,11 @@ void PieceWiseReplayGenerator::getReqFromTrace() {
         }
       }
 
+      const std::string itemValue =
+          fields.size() == totalFieldCount
+              ? folly::to<std::string>(fields[SampleFields::ITEM_VALUE])
+              : "";
+
       // Spin until the queue has room
       while (!activeReqQ_[shard]->write(config_.cachePieceSize,
                                         timestampSeconds,
@@ -248,7 +254,8 @@ void PieceWiseReplayGenerator::getReqFromTrace() {
                                         ttl,
                                         std::move(statsAggFields),
                                         std::move(admFeatureMap),
-                                        cacheHit)) {
+                                        cacheHit,
+                                        itemValue)) {
         if (shouldShutdown()) {
           XLOG(INFO) << "Forced to stop, terminate reading trace file!";
           return;

cachelib/cachebench/workload/PieceWiseReplayGenerator.h

@@ -135,7 +135,8 @@ class PieceWiseReplayGenerator : public ReplayGeneratorBase {
     TTL,
     SAMPLING_RATE,
     CACHE_HIT,
-    TOTAL_DEFINED_FIELDS = 11
+    ITEM_VALUE,
+    TOTAL_DEFINED_FIELDS = 12
   };
 
   TraceFileStream traceStream_;

cachelib/cachebench/workload/tests/PieceWiseCacheTest.cpp

@@ -33,6 +33,7 @@ class PieceWiseCacheTest : public ::testing::Test {
     std::unordered_map<uint32_t, std::vector<std::string>> statsPerAggField;
     std::unordered_map<std::string, std::string> admFeatureMap1, admFeatureMap2,
         admFeatureMap3;
+    std::string itemValue = "";
 
     piecewiseCache =
         std::make_unique<PieceWiseCacheAdapter>(/*maxCachePiecesv=*/32000,
@@ -54,7 +55,8 @@ class PieceWiseCacheTest : public ::testing::Test {
         /*ttl=*/3600,
         /*extraField=*/std::move(extraFieldV1),
         /*admFeatureMap=*/std::move(admFeatureMap1),
-        /*isHit=*/folly::none);
+        /*isHit=*/folly::none,
+        /*itemValue=*/itemValue);
 
     // pieceReq2 is stored as multiple pieces, and the range contains a single
     // piece
@@ -71,7 +73,8 @@ class PieceWiseCacheTest : public ::testing::Test {
         /*ttl=*/3600,
         /*extraField=*/std::move(extraFieldV2),
         /*admFeatureMap=*/std::move(admFeatureMap2),
-        /*isHit=*/folly::none);
+        /*isHit=*/folly::none,
+        /*itemValue=*/itemValue);
 
     // nonPieceReq is stored as whole object
     nonPieceReq = std::make_unique<PieceWiseReqWrapper>(
@@ -87,7 +90,8 @@ class PieceWiseCacheTest : public ::testing::Test {
         /*ttl=*/3600,
         /*extraField=*/std::move(extraFieldV3),
         /*admFeatureMap=*/std::move(admFeatureMap3),
-        /*isHit=*/folly::none);
+        /*isHit=*/folly::none,
+        /*itemValue=*/itemValue);
   }
 
   std::unique_ptr<PieceWiseCacheAdapter> piecewiseCache;