Extend cachbench with value validation

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

Author: igchor

cachelib/cachebench/cache/Cache-inl.h

@@ -298,13 +298,21 @@ 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()) {
@@ -397,6 +405,20 @@ typename Cache<Allocator>::ItemHandle Cache<Allocator>::insertOrReplace(
   return rv;
 }
 
+template <typename Allocator>
+void Cache<Allocator>::validateValue(const ItemHandle& it) const {
+  XDCHECK(valueValidatingEnabled());
+
+  const auto& expected = expectedValue_.value();
+
+  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!");
+  }
+}
+
 template <typename Allocator>
 typename Cache<Allocator>::ItemHandle Cache<Allocator>::find(Key key,
                                                              AccessMode mode) {
@@ -408,13 +430,21 @@ 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 (valueValidatingEnabled()) {
+      XDCHECK(!consistencyCheckEnabled());
+      validateValue(it);
+    }
+
     return it;
   };
 
   if (!consistencyCheckEnabled()) {
     return findFn();
   }
 
+  XDCHECK(!valueValidatingEnabled());
+
   auto opId = valueTracker_->beginGet(key);
   auto it = findFn();
   if (checkGet(opId, it)) {

cachelib/cachebench/cache/Cache.h

@@ -168,6 +168,9 @@ class Cache {
     return getSize(item.get());
   }
 
+  // checks if values stored in it matches expectedValue_.
+  void validateValue(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;
@@ -227,9 +230,15 @@ 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(); }
+
   // 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 +361,9 @@ class Cache {
   // tracker for consistency monitoring.
   std::unique_ptr<ValueTracker> valueTracker_;
 
+  // expected value of all items in Cache.
+  std::optional<std::string> expectedValue_;
+
   // reading of the nand bytes written for the benchmark if enabled.
   const uint64_t nandBytesBegin_{0};
 

cachelib/cachebench/runner/CacheStressor.h

@@ -112,6 +112,9 @@ 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,6 +34,7 @@ StressorConfig::StressorConfig(const folly::dynamic& configJson) {
   JSONSetVal(configJson, samplingIntervalMs);
 
   JSONSetVal(configJson, checkConsistency);
+  JSONSetVal(configJson, validateValue);
 
   JSONSetVal(configJson, numOps);
   JSONSetVal(configJson, numThreads);

cachelib/cachebench/util/Config.h

@@ -188,12 +188,17 @@ struct StressorConfig : public JSONConfig {
   uint64_t samplingIntervalMs{1000};
 
   // If enabled, stressor will verify operations' results are consistent.
+  // Mutually exclusive with validateValue
   bool checkConsistency{false};
 
   // If enabled, stressor will check whether nvm cache has been warmed up and
   // output stats after warmup.
   bool checkNvmCacheWarmUp{false};
 
+  // If enable, stressor will verify if value read is equal to value written.
+  // Mutually exclusive with checkConsistency
+  bool validateValue{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