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

@@ -312,22 +312,13 @@ template <typename Allocator>
 void Cache<Allocator>::enableConsistencyCheck(
     const std::vector<std::string>& keys) {
   XDCHECK(valueTracker_ == nullptr);
-  XDCHECK(!valueValidatingEnabled());
   valueTracker_ =
       std::make_unique<ValueTracker>(ValueTracker::wrapStrings(keys));
   for (const std::string& key : keys) {
     invalidKeys_[key] = false;
   }
 }
 
-template <typename Allocator>
-void Cache<Allocator>::enableValueValidating(
-    const std::string &expectedValue) {
-  XDCHECK(!valueValidatingEnabled());
-  XDCHECK(!consistencyCheckEnabled());
-  this->expectedValue_ = expectedValue;
-}
-
 template <typename Allocator>
 typename Cache<Allocator>::RemoveRes Cache<Allocator>::remove(Key key) {
   if (!consistencyCheckEnabled()) {
@@ -421,17 +412,15 @@ typename Cache<Allocator>::WriteHandle Cache<Allocator>::insertOrReplace(
 }
 
 template <typename Allocator>
-void Cache<Allocator>::validateValue(const ItemHandle &it) const {
-  XDCHECK(valueValidatingEnabled());
-
-  const auto &expected = expectedValue_.value();
+void Cache<Allocator>::touchValue(const ItemHandle& it) const {
+  XDCHECK(touchValueEnabled());
 
   auto ptr = reinterpret_cast<const uint8_t*>(getMemory(it));
-  auto cmp = std::memcmp(ptr, expected.data(), std::min<size_t>(expected.size(),
-    getSize(it)));
-  if (cmp != 0) {
-    throw std::runtime_error("Value does not match!");
-  }
+
+  /* The accumulate call is intended to access all bytes of the value
+   * and nothing more. */
+  auto sum = std::accumulate(ptr, ptr + getSize(it), 0ULL);
+  folly::doNotOptimizeAway(sum);
 }
 
 template <typename Allocator>
@@ -461,8 +450,6 @@ typename Cache<Allocator>::ItemHandle Cache<Allocator>::find(Key key,
     return it;
   }
 
-  XDCHECK(!valueValidatingEnabled());
-
   auto opId = valueTracker_->beginGet(key);
   auto it = findFn();
   if (checkGet(opId, it)) {

cachelib/cachebench/cache/Cache.h

@@ -181,8 +181,8 @@ class Cache {
     return getSize(item.get());
   }
 
-  // checks if values stored in it matches expectedValue_.
-  void validateValue(const ItemHandle &it) const;
+  // read entire value on find.
+  void touchValue(const ItemHandle& it) const;
 
   // returns the size of the item, taking into account ItemRecords could be
   // enabled.
@@ -243,14 +243,11 @@ class Cache {
   // @param keys  list of keys that the stressor uses for the workload.
   void enableConsistencyCheck(const std::vector<std::string>& keys);
 
-  // enables validating all values on find. Each value is compared to
-  // expected Value.
-  void enableValueValidating(const std::string &expectedValue);
-
   // returns true if the consistency checking is enabled.
   bool consistencyCheckEnabled() const { return valueTracker_ != nullptr; }
 
-  bool valueValidatingEnabled() const { return expectedValue_.has_value(); }
+  // 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
@@ -374,8 +371,8 @@ class Cache {
   // tracker for consistency monitoring.
   std::unique_ptr<ValueTracker> valueTracker_;
 
-  // exceptected value of all items in Cache.
-  std::optional<std::string> expectedValue_;
+  // 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

@@ -114,9 +114,6 @@ class CacheStressor : public Stressor {
     if (config_.checkConsistency) {
       cache_->enableConsistencyCheck(wg_->getAllKeys());
     }
-    if (config_.validateValue) {
-      cache_->enableValueValidating(hardcodedString_);
-    }
     if (config_.opRatePerSec > 0) {
       rateLimiter_ = std::make_unique<folly::BasicTokenBucket<>>(
           config_.opRatePerSec, config_.opRatePerSec);

cachelib/cachebench/util/Config.cpp

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

cachelib/cachebench/util/Config.h

@@ -195,6 +195,10 @@ struct StressorConfig : public JSONConfig {
   // Mutually exclusive with checkConsistency
   bool validateValue{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