Extend cachbench with touch value

The main purpose of this patch is to better simulate workloads in
cachebench. Setting touchValue to true allows to see performance
impact of using different mediums for memory cache.

Author: igchor

cachelib/cachebench/cache/Cache-inl.h

@@ -50,8 +50,10 @@ uint64_t Cache<Allocator>::fetchNandWrites() const {
 template <typename Allocator>
 Cache<Allocator>::Cache(const CacheConfig& config,
                         ChainedItemMovingSync movingSync,
-                        std::string cacheDir)
+                        std::string cacheDir,
+                        bool touchValue)
     : config_(config),
+      touchValue_(touchValue),
       nandBytesBegin_{fetchNandWrites()},
       itemRecords_(config_.enableItemDestructorCheck) {
   constexpr size_t MB = 1024ULL * 1024ULL;
@@ -397,6 +399,15 @@ typename Cache<Allocator>::ItemHandle Cache<Allocator>::insertOrReplace(
   return rv;
 }
 
+template <typename Allocator>
+void Cache<Allocator>::touchValue(const ItemHandle& it) const {
+  XDCHECK(touchValueEnabled());
+
+  auto ptr = reinterpret_cast<const uint8_t*>(getMemory(it));
+  auto sum = std::accumulate(ptr, ptr + getSize(it), 0ULL);
+  folly::doNotOptimizeAway(sum);
+}
+
 template <typename Allocator>
 typename Cache<Allocator>::ItemHandle Cache<Allocator>::find(Key key,
                                                              AccessMode mode) {
@@ -408,13 +419,20 @@ typename Cache<Allocator>::ItemHandle Cache<Allocator>::find(Key key,
     // find from cache and wait for the result to be ready.
     auto it = cache_->findImpl(key, mode);
     it.wait();
+
+    if (touchValueEnabled()) {
+      touchValue(it);
+    }
+
     return it;
   };
 
   if (!consistencyCheckEnabled()) {
     return findFn();
   }
 
+  XDCHECK(!touchValueEnabled());
+
   auto opId = valueTracker_->beginGet(key);
   auto it = findFn();
   if (checkGet(opId, it)) {

cachelib/cachebench/cache/Cache.h

@@ -64,9 +64,11 @@ class Cache {
   //                      cache.
   // @param cacheDir      optional directory for the cache to enable
   //                      persistence across restarts.
+  // @param touchValue    read entire value on find
   explicit Cache(const CacheConfig& config,
                  ChainedItemMovingSync movingSync = {},
-                 std::string cacheDir = "");
+                 std::string cacheDir = "",
+                 bool touchValue = false);
 
   ~Cache();
 
@@ -168,6 +170,9 @@ class Cache {
     return getSize(item.get());
   }
 
+  // read entire value on find.
+  void touchValue(const ItemHandle& it) const;
+
   // returns the size of the item, taking into account ItemRecords could be
   // enabled.
   uint32_t getSize(const Item* item) const noexcept;
@@ -230,6 +235,9 @@ class Cache {
   // returns true if the consistency checking is enabled.
   bool consistencyCheckEnabled() const { return valueTracker_ != nullptr; }
 
+  // returns true if touching value is enabled.
+  bool touchValueEnabled() const { return touchValue_; }
+
   // return true if the key was previously detected to be inconsistent. This
   // is useful only when consistency checking is enabled by calling
   // enableConsistencyCheck()
@@ -352,6 +360,9 @@ class Cache {
   // tracker for consistency monitoring.
   std::unique_ptr<ValueTracker> valueTracker_;
 
+  // read entire value on find.
+  bool touchValue_{false};
+
   // reading of the nand bytes written for the benchmark if enabled.
   const uint64_t nandBytesBegin_{0};
 

cachelib/cachebench/runner/CacheStressor.h

@@ -95,7 +95,8 @@ class CacheStressor : public Stressor {
       cacheConfig.ticker = ticker_;
     }
 
-    cache_ = std::make_unique<CacheT>(cacheConfig, movingSync);
+    cache_ = std::make_unique<CacheT>(cacheConfig, movingSync, "",
+                                      config_.touchValue);
     if (config_.opPoolDistribution.size() > cache_->numPools()) {
       throw std::invalid_argument(folly::sformat(
           "more pools specified in the test than in the cache. "

cachelib/cachebench/util/Config.cpp

@@ -34,6 +34,7 @@ StressorConfig::StressorConfig(const folly::dynamic& configJson) {
   JSONSetVal(configJson, samplingIntervalMs);
 
   JSONSetVal(configJson, checkConsistency);
+  JSONSetVal(configJson, touchValue);
 
   JSONSetVal(configJson, numOps);
   JSONSetVal(configJson, numThreads);

cachelib/cachebench/util/Config.h

@@ -194,6 +194,10 @@ struct StressorConfig : public JSONConfig {
   // output stats after warmup.
   bool checkNvmCacheWarmUp{false};
 
+  // If enabled, each value will be read on find. This is useful for measuring
+  // performance of value access.
+  bool touchValue{false};
+
   uint64_t numOps{0};     // operation per thread
   uint64_t numThreads{0}; // number of threads that will run
   uint64_t numKeys{0};    // number of keys that will be used