folly::format -> fmt::format in cachelib

Summary:
Mechanical migration of `folly::sformat(...)` call sites to `fmt::format(...)`
(adding `#include <fmt/format.h>` where needed) in `cachelib`.

`folly::sformat` and `fmt::format` share identical format-string syntax, so this
is a semantically-equivalent, token-level rewrite produced by the
`folly-to-fmt-format` clang codemod, run via the migration farm in
`fbcode/scripts/rbarnes/folly_to_fmt` (D112466250). Part of the fbcode-wide
`folly::format` -> `fmt::format` migration.

This diff covers 27 file(s).

Reviewed By: rlyerly

Differential Revision: D113286692

fbshipit-source-id: 4e0ab9847908f3d0dbf827308b580b4aaba445ba

Author: r-barnes

cachelib/allocator/nvmcache/NavyConfig.cpp

@@ -16,6 +16,8 @@
 
 #include "cachelib/allocator/nvmcache/NavyConfig.h"
 
+#include <fmt/format.h>
+
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -35,7 +37,7 @@ const std::vector<std::string>& NavyConfig::getRaidPaths() const {
 // admission policy settings
 RandomAPConfig& NavyConfig::enableRandomAdmPolicy() {
   if (!admissionPolicy_.empty()) {
-    throw std::invalid_argument(folly::sformat(
+    throw std::invalid_argument(fmt::format(
         "{} admission policy is already enabled", admissionPolicy_));
   }
   admissionPolicy_ = "random";
@@ -44,7 +46,7 @@ RandomAPConfig& NavyConfig::enableRandomAdmPolicy() {
 
 DynamicRandomAPConfig& NavyConfig::enableDynamicRandomAdmPolicy() {
   if (!admissionPolicy_.empty()) {
-    throw std::invalid_argument(folly::sformat(
+    throw std::invalid_argument(fmt::format(
         "{} admission policy is already enabled", admissionPolicy_));
   }
   admissionPolicy_ = "dynamic_random";
@@ -53,7 +55,7 @@ DynamicRandomAPConfig& NavyConfig::enableDynamicRandomAdmPolicy() {
 
 RandomAPConfig& RandomAPConfig::setAdmProbability(double admProbability) {
   if (admProbability < 0 || admProbability > 1) {
-    throw std::invalid_argument(folly::sformat(
+    throw std::invalid_argument(fmt::format(
         "admission probability should be in the range of [0, 1], but {} is set",
         admProbability));
   }
@@ -89,7 +91,7 @@ void NavyConfig::enableAsyncIo(uint32_t maxNumReads,
   }
 
   if ((maxNumReads % readerThreads_) || (maxNumWrites % writerThreads_)) {
-    throw std::invalid_argument(folly::sformat(
+    throw std::invalid_argument(fmt::format(
         "reader threads ({}) and writer threads ({}) should divide evenly "
         "into maxNumReads ({}) or maxNumWrites ({})",
         readerThreads_, writerThreads_, maxNumReads, maxNumWrites));
@@ -130,7 +132,7 @@ void NavyConfig::setRaidFiles(std::vector<std::string> raidPaths,
     throw std::invalid_argument("already set a simple file");
   }
   if (raidPaths.size() <= 1) {
-    throw std::invalid_argument(folly::sformat(
+    throw std::invalid_argument(fmt::format(
         "RAID needs at least two paths, but {} path is set", raidPaths.size()));
   }
   raidPaths_ = std::move(raidPaths);
@@ -167,7 +169,7 @@ BlockCacheConfig& BlockCacheConfig::enableCustomReinsertion(
 BlockCacheConfig& BlockCacheConfig::setCleanRegions(
     uint32_t cleanRegions, uint32_t cleanRegionThreads) {
   if (!cleanRegionThreads || cleanRegionThreads > cleanRegions + 1) {
-    throw std::invalid_argument(folly::sformat(
+    throw std::invalid_argument(fmt::format(
         "number of clean region threads should be in the range of [1, {}]",
         cleanRegions + 1));
   }
@@ -219,7 +221,7 @@ BlockCacheConfig& BlockCacheConfig::enableFixedSizeIndex(
 BigHashConfig& BigHashConfig::setSizePctAndMaxItemSize(
     unsigned int sizePct, uint64_t smallItemMaxSize) {
   if (sizePct > 100) {
-    throw std::invalid_argument(folly::sformat(
+    throw std::invalid_argument(fmt::format(
         "to enable BigHash, BigHash size pct should be in the range of [0, 100]"
         ", but {} is set",
         sizePct));
@@ -261,7 +263,7 @@ void NavyConfig::setReaderAndWriterThreads(unsigned int readerThreads,
 
   if (maxNumReads > 0 || maxNumWrites > 0) {
     if ((maxNumReads % readerThreads_) || (maxNumWrites % writerThreads_)) {
-      throw std::invalid_argument(folly::sformat(
+      throw std::invalid_argument(fmt::format(
           "reader threads ({}) and writer threads ({}) should divide evenly "
           "into maxNumReads ({}) or maxNumWrites ({})",
           readerThreads_, writerThreads_, maxNumReads, maxNumWrites));

cachelib/allocator/nvmcache/NavySetup.cpp

@@ -16,6 +16,7 @@
 
 #include "cachelib/allocator/nvmcache/NavySetup.h"
 
+#include <fmt/format.h>
 #include <folly/logging/xlog.h>
 #include <gmock/gmock.h>
 
@@ -49,7 +50,7 @@ uint64_t getRegionSize(const navy::NavyConfig& config) {
   uint64_t regionSize = configs[0].blockCache().getRegionSize();
   for (size_t idx = 1; idx < configs.size(); idx++) {
     if (regionSize != configs[idx].blockCache().getRegionSize()) {
-      throw std::invalid_argument(folly::sformat(
+      throw std::invalid_argument(fmt::format(
           "Blockcache {} region size: {}, not equal to block cache 0: {}", idx,
           configs[idx].blockCache().getRegionSize(), regionSize));
     }
@@ -78,8 +79,8 @@ uint64_t setupBigHash(const navy::BigHashConfig& bigHashConfig,
   auto bucketSize = bigHashConfig.getBucketSize();
   if (bucketSize != alignUp(bucketSize, ioAlignSize)) {
     throw std::invalid_argument(
-        folly::sformat("Bucket size: {} is not aligned to ioAlignSize: {}",
-                       bucketSize, ioAlignSize));
+        fmt::format("Bucket size: {} is not aligned to ioAlignSize: {}",
+                    bucketSize, ioAlignSize));
   }
 
   const uint64_t bigHashCacheOffset =
@@ -142,8 +143,8 @@ uint64_t setupBlockCache(const navy::BlockCacheConfig& blockCacheConfig,
   auto regionSize = blockCacheConfig.getRegionSize();
   if (regionSize != alignUp(regionSize, ioAlignSize)) {
     throw std::invalid_argument(
-        folly::sformat("Region size: {} is not aligned to ioAlignSize: {}",
-                       regionSize, ioAlignSize));
+        fmt::format("Region size: {} is not aligned to ioAlignSize: {}",
+                    regionSize, ioAlignSize));
   }
 
   // Adjust starting size of block cache to ensure it is aligned to region
@@ -242,9 +243,9 @@ void setupCacheProtos(const navy::NavyConfig& config,
   metadataSize = alignUp(metadataSize, ioAlignSize);
   if (metadataSize >= totalCacheSize) {
     throw std::invalid_argument{
-        folly::sformat("Invalid metadata size: {}. Cache size: {}",
-                       metadataSize,
-                       totalCacheSize)};
+        fmt::format("Invalid metadata size: {}. Cache size: {}",
+                    metadataSize,
+                    totalCacheSize)};
   }
   proto.setMetadataSize(metadataSize);
 
@@ -293,10 +294,10 @@ void setupCacheProtos(const navy::NavyConfig& config,
           config.getStackSize(), *enginePairProto);
     }
     if (blockCacheEndOffset > bigHashStartOffset) {
-      throw std::invalid_argument(folly::sformat(
-          "Invalid engine size configurations. block cache ends at "
-          "{}, big hash starts at {}.",
-          blockCacheEndOffset, bigHashStartOffset));
+      throw std::invalid_argument(
+          fmt::format("Invalid engine size configurations. block cache ends at "
+                      "{}, big hash starts at {}.",
+                      blockCacheEndOffset, bigHashStartOffset));
     }
     proto.addEnginePair(std::move(enginePairProto));
     bigHashEndOffset = bigHashStartOffset;
@@ -317,7 +318,7 @@ void setAdmissionPolicy(const cachelib::navy::NavyConfig& config,
     proto.setDynamicRandomAdmissionPolicy(config.dynamicRandomAdmPolicy());
   } else {
     throw std::invalid_argument{
-        folly::sformat("invalid policy name {}", policyName)};
+        fmt::format("invalid policy name {}", policyName)};
   }
 }
 

cachelib/allocator/nvmcache/NvmItem.cpp

@@ -18,6 +18,7 @@
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
+#include <fmt/format.h>
 #include <folly/Format.h>
 #pragma GCC diagnostic pop
 
@@ -29,7 +30,7 @@ namespace cachelib {
 Blob NvmItem::getBlob(size_t index) const {
   if (index >= numBlobs_) {
     throw std::invalid_argument(
-        folly::sformat("Index {} out of range {}", index, numBlobs_));
+        fmt::format("Index {} out of range {}", index, numBlobs_));
   }
 
   const auto& blobInfo = getBlobInfo(index);
@@ -55,7 +56,7 @@ NvmItem::NvmItem(PoolId id,
     auto& blobInfo = getBlobInfo(index++);
     if (offset + blob.data.size() >
         std::numeric_limits<decltype(blobInfo.endOffset)>::max()) {
-      throw std::out_of_range(folly::sformat(
+      throw std::out_of_range(fmt::format(
           "new offset {} is out of range. blob size {}, num blobs{}",
           offset,
           blob.data.size(),
@@ -79,7 +80,7 @@ NvmItem::NvmItem(PoolId id,
   if (blob.data.size() >
       std::numeric_limits<decltype(blobInfo.endOffset)>::max()) {
     throw std::out_of_range(
-        folly::sformat("blob is too big. size {}", blob.data.size()));
+        fmt::format("blob is too big. size {}", blob.data.size()));
   }
   std::memcpy(getDataBegin(), blob.data.data(), blob.data.size());
   blobInfo.origAllocSize = blob.origAllocSize;

cachelib/allocator/nvmcache/tests/NvmCacheTests.cpp

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <fmt/format.h>
 #include <folly/Random.h>
 #include <gtest/gtest.h>
 
@@ -195,7 +196,7 @@ TEST_F(NvmCacheTest, EvictToNvmGet) {
   const int nKeys = 1024;
 
   for (unsigned int i = 0; i < nKeys; i++) {
-    auto key = folly::sformat("key{}", i);
+    auto key = fmt::format("key{}", i);
     auto it = nvm.allocate(pid, key, 15 * 1024);
     ASSERT_NE(nullptr, it);
     nvm.insertOrReplace(it);
@@ -221,7 +222,7 @@ TEST_F(NvmCacheTest, EvictToNvmGet) {
   // reading items from navy.
   for (unsigned int i = nKeys + 100; i-- > 0;) {
     unsigned int index = i;
-    auto key = folly::sformat("key{}", index);
+    auto key = fmt::format("key{}", index);
     auto hdl = this->fetch(key, false /* ramOnly */);
     hdl.wait();
     if (index < nKeys) {
@@ -234,14 +235,14 @@ TEST_F(NvmCacheTest, EvictToNvmGet) {
         // associated with it on the local thread. It is adjusted at destruction
         // time to be net-zero for handle count (first an Inc, and then a Dec).
         EXPECT_EQ(0, nvm.getHandleCountForThread())
-            << folly::sformat("key: {} was read from Navy", key);
+            << fmt::format("key: {} was read from Navy", key);
         ASSERT_TRUE(isClean);
         ASSERT_TRUE(hdl.wentToNvm());
       } else {
         // A handle read from ram-cache will have incremented the thread-local
         // handle count when we have acquired the handle.
         EXPECT_EQ(1, nvm.getHandleCountForThread())
-            << folly::sformat("key: {} was read from RAM cache", key);
+            << fmt::format("key: {} was read from RAM cache", key);
         ASSERT_FALSE(isClean);
       }
     } else {
@@ -1922,7 +1923,7 @@ TEST_F(NvmCacheTest, NavyStats) {
 TEST_F(NvmCacheTest, Raid0Basic) {
   auto& config = getConfig();
   auto& navyConfig = config.nvmConfig->navyConfig;
-  auto filePath = folly::sformat("/tmp/nvmcache-navy-raid0/{}", ::getpid());
+  auto filePath = fmt::format("/tmp/nvmcache-navy-raid0/{}", ::getpid());
   util::makeDir(filePath);
   SCOPE_EXIT { util::removePath(filePath); };
 
@@ -1988,7 +1989,7 @@ TEST_F(NvmCacheTest, Raid0Basic) {
 TEST_F(NvmCacheTest, Raid0OrderChange) {
   auto& config = getConfig();
   auto& navyConfig = config.nvmConfig->navyConfig;
-  auto filePath = folly::sformat("/tmp/nvmcache-navy-raid0/{}", ::getpid());
+  auto filePath = fmt::format("/tmp/nvmcache-navy-raid0/{}", ::getpid());
   util::makeDir(filePath);
   SCOPE_EXIT { util::removePath(filePath); };
 
@@ -2001,7 +2002,7 @@ TEST_F(NvmCacheTest, Raid0OrderChange) {
   // that everything is correct.
   std::string val = "foobar";
   int nKeys = 100;
-  auto makeKey = [&](int i) { return folly::sformat("blah-{}", i); };
+  auto makeKey = [&](int i) { return fmt::format("blah-{}", i); };
 
   this->convertToShmCache();
   {
@@ -2062,7 +2063,7 @@ TEST_F(NvmCacheTest, Raid0OrderChange) {
 TEST_F(NvmCacheTest, Raid0NumFilesChange) {
   auto& config = getConfig();
   auto& navyConfig = config.nvmConfig->navyConfig;
-  auto filePath = folly::sformat("/tmp/nvmcache-navy-raid0/{}", ::getpid());
+  auto filePath = fmt::format("/tmp/nvmcache-navy-raid0/{}", ::getpid());
   util::makeDir(filePath);
   SCOPE_EXIT { util::removePath(filePath); };
 
@@ -2075,7 +2076,7 @@ TEST_F(NvmCacheTest, Raid0NumFilesChange) {
   // that everything is correct.
   std::string val = "foobar";
   int nKeys = 100;
-  auto makeKey = [&](int i) { return folly::sformat("blah-{}", i); };
+  auto makeKey = [&](int i) { return fmt::format("blah-{}", i); };
 
   this->convertToShmCache();
   {
@@ -2135,7 +2136,7 @@ TEST_F(NvmCacheTest, Raid0NumFilesChange) {
 TEST_F(NvmCacheTest, Raid0SizeChange) {
   auto& config = getConfig();
   auto& navyConfig = config.nvmConfig->navyConfig;
-  auto filePath = folly::sformat("/tmp/nvmcache-navy-raid0/{}", ::getpid());
+  auto filePath = fmt::format("/tmp/nvmcache-navy-raid0/{}", ::getpid());
   util::makeDir(filePath);
   SCOPE_EXIT { util::removePath(filePath); };
   std::vector<std::string> vec = {filePath + "/CACHE0", filePath + "/CACHE1",
@@ -2147,7 +2148,7 @@ TEST_F(NvmCacheTest, Raid0SizeChange) {
   // that everything is correct.
   std::string val = "foobar";
   int nKeys = 100;
-  auto makeKey = [&](int i) { return folly::sformat("blah-{}", i); };
+  auto makeKey = [&](int i) { return fmt::format("blah-{}", i); };
 
   this->convertToShmCache();
   {
@@ -2473,7 +2474,7 @@ TEST_F(NvmCacheTest, testSampleItem) {
   // Insert items until either RAM or NVM cache is full
   for (; numEvicted == 0 && nKeys < numMax; nKeys++) {
     unsigned ttl = nKeys % 2 == 0 ? kEvenKeyTTL : 0;
-    auto key = folly::sformat("key{}", nKeys);
+    auto key = fmt::format("key{}", nKeys);
     // the pool's allocsize is
     auto it = cache.allocate(pid, key, 16 * 1024, ttl);
     ASSERT_NE(nullptr, it);
@@ -3033,7 +3034,7 @@ TEST_F(NvmCacheTest, AccessTimeMapPopulatedOnDramEviction) {
   auto now = util::getCurrentTimeSec();
   int populated = 0;
   for (int i = 0; i < nKeys; i++) {
-    auto key = folly::sformat("atm_multi_{}", i);
+    auto key = fmt::format("atm_multi_{}", i);
     HashedKey hk{key};
     auto ts = atm->get(hk.keyHash());
     if (ts != std::nullopt) {
@@ -3067,7 +3068,7 @@ TEST_F(NvmCacheTest, AccessTimeMapNotUpdatedForBigHashItems) {
   // bit is not set for BigHash items, preventing updateAccessTime().
   auto* atm = this->getAccessTimeMap();
   for (int i = 0; i < nKeys; i++) {
-    auto key = folly::sformat("bh_{}", i);
+    auto key = fmt::format("bh_{}", i);
     HashedKey hk{key};
     auto ts = atm->get(hk.keyHash());
     EXPECT_EQ(std::nullopt, ts)
@@ -3090,7 +3091,7 @@ TEST_F(NvmCacheTest, AccessTimeMapNotUpdatedOnRegularEviction) {
   // Evictions of these items go through the NVM put path, not
   // the updateAccessTime path.
   for (int i = 0; i < 1024; i++) {
-    auto key = folly::sformat("regular_{}", i);
+    auto key = fmt::format("regular_{}", i);
     auto it = nvm.allocate(pid, key, allocSize);
     ASSERT_NE(nullptr, it);
     cache_->insertOrReplace(it);
@@ -3140,7 +3141,7 @@ TEST_F(NvmCacheTest, AccessTimeMapCleanupTest) {
   constexpr int kNumGroups = 4;
   std::array<std::vector<std::string>, kNumGroups> groups;
   for (int i = 0; i < nKeys; i++) {
-    auto key = folly::sformat("atm_cl_{}", i);
+    auto key = fmt::format("atm_cl_{}", i);
     HashedKey hk{key};
     if (atm->get(hk.keyHash()) != std::nullopt) {
       groups[i % kNumGroups].push_back(key);
@@ -3183,7 +3184,7 @@ TEST_F(NvmCacheTest, AccessTimeMapCleanupTest) {
   const uint32_t numKeysPerRegion =
       config_.blockCache().getRegionSize() / allocSize;
   for (int i = 0; i < 2048; i++) {
-    auto key = folly::sformat("nvm_evictor_{}", i);
+    auto key = fmt::format("nvm_evictor_{}", i);
     auto it = nvm.allocate(pid, key, allocSize);
     ASSERT_NE(nullptr, it);
     cache_->insertOrReplace(it);
@@ -3234,7 +3235,7 @@ TEST_F(NvmCacheTest, AccessTimeMapSurvivesWarmRoll) {
   auto timeBefore = util::getCurrentTimeSec();
   auto evictBefore = this->evictionCount();
   for (int i = 0; i < 1024; i++) {
-    auto key = folly::sformat("atm_warm_roll_filler_{}", i);
+    auto key = fmt::format("atm_warm_roll_filler_{}", i);
     auto it = nvm.allocate(pid, key, allocSize);
     ASSERT_NE(nullptr, it);
     cache_->insertOrReplace(it);