fixes for test build

Author: guptask

cachelib/allocator/tests/BaseAllocatorTest.h

@@ -6160,7 +6160,7 @@ class BaseAllocatorTest : public AllocatorTest<AllocatorT> {
 
     std::set<std::string> movedKeys;
     auto moveCb = [&](const Item& oldItem, Item& newItem, Item* /* parentPtr */) {
-      std::memcpy(newItem.getWritableMemory(), oldItem.getMemory(), oldItem.getSize());
+      std::memcpy(newItem.getMemory(), oldItem.getMemory(), oldItem.getSize());
       movedKeys.insert(oldItem.getKey().str());
     };
 
@@ -6190,7 +6190,7 @@ class BaseAllocatorTest : public AllocatorTest<AllocatorT> {
       auto h = alloc.allocate(pid, key, 1024);
       EXPECT_TRUE(h);
 
-      std::memcpy(h->getWritableMemory(), data.data(), data.size());
+      std::memcpy(h->getMemory(), data.data(), data.size());
 
       alloc.insertOrReplace(h);
     }

cachelib/common/BloomFilter.h

@@ -134,34 +134,34 @@ class BloomFilter {
 template <typename SerializationProto>
 void BloomFilter::persist(RecordWriter& rw) {
   serialization::BloomFilterPersistentData bd;
-  *bd.numFilters() = numFilters_;
-  *bd.hashTableBitSize() = hashTableBitSize_;
-  *bd.filterByteSize() = filterByteSize_;
-  *bd.fragmentSize() = kPersistFragmentSize;
+  bd.numFilters_ref() = numFilters_;
+  bd.hashTableBitSize_ref() = hashTableBitSize_;
+  bd.filterByteSize_ref() = filterByteSize_;
+  bd.fragmentSize_ref() = kPersistFragmentSize;
   bd.seeds()->resize(seeds_.size());
   for (uint32_t i = 0; i < seeds_.size(); i++) {
-    bd.seeds()[i] = seeds_[i];
+    bd.seeds()->at(i) = seeds_[i];
   }
   facebook::cachelib::serializeProto<serialization::BloomFilterPersistentData,
                                      SerializationProto>(bd, rw);
-  serializeBits(rw, *bd.fragmentSize());
+  serializeBits(rw, bd.get_fragmentSize());
 }
 
 template <typename SerializationProto>
 void BloomFilter::recover(RecordReader& rr) {
   const auto bd = facebook::cachelib::deserializeProto<
       serialization::BloomFilterPersistentData,
       SerializationProto>(rr);
-  if (numFilters_ != static_cast<uint32_t>(*bd.numFilters()) ||
-      hashTableBitSize_ != static_cast<uint64_t>(*bd.hashTableBitSize()) ||
-      filterByteSize_ != static_cast<uint64_t>(*bd.filterByteSize()) ||
-      static_cast<uint32_t>(*bd.fragmentSize()) != kPersistFragmentSize) {
+  if (numFilters_ != static_cast<uint32_t>(bd.get_numFilters()) ||
+      hashTableBitSize_ != static_cast<uint64_t>(bd.get_hashTableBitSize()) ||
+      filterByteSize_ != static_cast<uint64_t>(bd.get_filterByteSize()) ||
+      static_cast<uint32_t>(bd.get_fragmentSize()) != kPersistFragmentSize) {
     throw std::invalid_argument(
         "Could not recover BloomFilter. Invalid BloomFilter.");
   }
 
   for (uint32_t i = 0; i < bd.seeds()->size(); i++) {
-    seeds_[i] = bd.seeds()[i];
+    seeds_[i] = bd.seeds()->at(i);
   }
   deserializeBits(rr);
 }

cachelib/navy/bighash/BigHash.cpp

@@ -173,13 +173,13 @@ void BigHash::getCounters(const CounterVisitor& visitor) const {
 void BigHash::persist(RecordWriter& rw) {
   XLOG(INFO, "Starting bighash persist");
   serialization::BigHashPersistentData pd;
-  *pd.version() = kFormatVersion;
-  *pd.generationTime() = generationTime_.count();
-  *pd.itemCount() = itemCount_.get();
-  *pd.bucketSize() = bucketSize_;
-  *pd.cacheBaseOffset() = cacheBaseOffset_;
-  *pd.numBuckets() = numBuckets_;
-  *pd.sizeDist() = sizeDist_.getSnapshot();
+  pd.version_ref() = kFormatVersion;
+  pd.generationTime_ref() = generationTime_.count();
+  pd.itemCount_ref() = itemCount_.get();
+  pd.bucketSize_ref() = bucketSize_;
+  pd.cacheBaseOffset_ref() = cacheBaseOffset_;
+  pd.numBuckets_ref() = numBuckets_;
+  pd.sizeDist_ref() = sizeDist_.getSnapshot();
   serializeProto(pd, rw);
 
   if (bloomFilter_) {
@@ -194,26 +194,26 @@ bool BigHash::recover(RecordReader& rr) {
   XLOG(INFO, "Starting bighash recovery");
   try {
     auto pd = deserializeProto<serialization::BigHashPersistentData>(rr);
-    if (*pd.version() != kFormatVersion) {
+    if (pd.get_version() != kFormatVersion) {
       throw std::logic_error{
           folly::sformat("invalid format version {}, expected {}",
-                         *pd.version(),
+                         pd.get_version(),
                          kFormatVersion)};
     }
 
     auto configEquals =
-        static_cast<uint64_t>(*pd.bucketSize()) == bucketSize_ &&
-        static_cast<uint64_t>(*pd.cacheBaseOffset()) == cacheBaseOffset_ &&
-        static_cast<uint64_t>(*pd.numBuckets()) == numBuckets_;
+        static_cast<uint64_t>(pd.get_bucketSize()) == bucketSize_ &&
+        static_cast<uint64_t>(pd.get_cacheBaseOffset()) == cacheBaseOffset_ &&
+        static_cast<uint64_t>(pd.get_numBuckets()) == numBuckets_;
     if (!configEquals) {
       auto configStr = serializeToJson(pd);
       XLOGF(ERR, "Recovery config: {}", configStr.c_str());
       throw std::logic_error{"config mismatch"};
     }
 
-    generationTime_ = std::chrono::nanoseconds{*pd.generationTime()};
-    itemCount_.set(*pd.itemCount());
-    sizeDist_ = SizeDistribution{*pd.sizeDist()};
+    generationTime_ = std::chrono::nanoseconds{pd.get_generationTime()};
+    itemCount_.set(pd.get_itemCount());
+    sizeDist_ = SizeDistribution{pd.get_sizeDist()};
     if (bloomFilter_) {
       bloomFilter_->recover<ProtoSerializer>(rr);
       XLOG(INFO, "Recovered bloom filter");

cachelib/shm/ShmManager.cpp

@@ -177,12 +177,12 @@ typename ShmManager::ShutDownRes ShmManager::writeActiveSegmentsToFile() {
     const auto& name = kv.first;
     serialization::ShmTypeObject key;
     if (const auto* opts = std::get_if<FileShmSegmentOpts>(&kv.second)) {
-      key.set_path(opts->path);
+      key.path_ref() = opts->path;
     } else {
       try {
         const auto& v = std::get<PosixSysVSegmentOpts>(kv.second);
-        key.set_usePosix(v.usePosix);
-        key.set_path("");
+        key.usePosix_ref() = v.usePosix;
+        key.path_ref() = "";
       } catch(std::bad_variant_access&) {
         throw std::invalid_argument(folly::sformat("Not a valid segment"));
       }

examples/multitier_cache/main.cpp

@@ -57,7 +57,7 @@ bool put(CacheKey key, const std::string& value) {
   if (!handle) {
     return false; // cache may fail to evict due to too many pending writes
   }
-  std::memcpy(handle->getWritableMemory(), value.data(), value.size());
+  std::memcpy(handle->getMemory(), value.data(), value.size());
   gCache_->insertOrReplace(handle);
   return true;
 }