Issue75 rebased (pmem#88)

* pmem#75: Use actual tier sizes (rounded down to slab size and decreased by header size) when creating new memory pools

* Added getPoolSize method to calculate combined pool size for all tiers; added pool size validation to tests

* Explicitly specified type for totalCacheSize to avoid overflow

* Minor test change

* Reworked tests

* Minor change

* Deleted redundant tests

* Deleted unused constant

* First set of changes to cache configuration API to enable multi-tier caches (facebook#138)

Summary:
These changes introduce per-tier cache configuration required to implement features discussed here: facebook#102. These specific changes enable single DRAM tier configs only which are compatible with the current version of cachelib. Configuration API will be expanded as multi-tier changes in other parts of the library are introduced.

Pull Request resolved: facebook#138

Reviewed By: therealgymmy

Differential Revision: D36189766

Pulled By: jiayuebao

fbshipit-source-id: 947aa0cd800ea6accffc1b7b6b0c9693aa7fc0a5

Co-authored-by: Victoria McGrath <[email protected]>

Author: 2 people

cachelib/allocator/CacheAllocator-inl.h

@@ -249,10 +249,24 @@ ShmSegmentOpts CacheAllocator<CacheTrait>::createShmCacheOpts(TierId tid) {
   ShmSegmentOpts opts;
   opts.alignment = sizeof(Slab);
   opts.typeOpts = memoryTierConfigs[tid].getShmTypeOpts();
+  if (auto *v = std::get_if<PosixSysVSegmentOpts>(&opts.typeOpts)) {
+    v->usePosix = config_.usePosixShm;
+  }
 
   return opts;
 }
 
+template <typename CacheTrait>
+size_t CacheAllocator<CacheTrait>::memoryTierSize(TierId tid) const
+{
+  auto partitions = std::accumulate(memoryTierConfigs.begin(), memoryTierConfigs.end(), 0UL,
+  [](const size_t i, const MemoryTierCacheConfig& config){
+    return i + config.getRatio();
+  });
+
+  return memoryTierConfigs[tid].calculateTierSize(config_.getCacheSize(), partitions);
+}
+
 template <typename CacheTrait>
 std::unique_ptr<MemoryAllocator>
 CacheAllocator<CacheTrait>::createNewMemoryAllocator(TierId tid) {
@@ -263,7 +277,8 @@ CacheAllocator<CacheTrait>::createNewMemoryAllocator(TierId tid) {
                       config_.getCacheSize(), config_.slabMemoryBaseAddr,
                       createShmCacheOpts(tid))
           .addr,
-      memoryTierConfigs[tid].getSize());
+          memoryTierSize(tid)
+      );
 }
 
 template <typename CacheTrait>
@@ -274,7 +289,7 @@ CacheAllocator<CacheTrait>::restoreMemoryAllocator(TierId tid) {
       shmManager_
           ->attachShm(detail::kShmCacheName + std::to_string(tid),
             config_.slabMemoryBaseAddr, createShmCacheOpts(tid)).addr,
-      memoryTierConfigs[tid].getSize(),
+      memoryTierSize(tid),
       config_.disableFullCoredump);
 }
 
@@ -2387,12 +2402,27 @@ PoolId CacheAllocator<CacheTrait>::addPool(
   folly::SharedMutex::WriteHolder w(poolsResizeAndRebalanceLock_);
 
   PoolId pid = 0;
-  auto tierConfigs = config_.getMemoryTierConfigs();
+  std::vector<size_t> tierPoolSizes;
+  const auto &tierConfigs = config_.getMemoryTierConfigs();
+  size_t totalCacheSize = 0;
+
   for (TierId tid = 0; tid < numTiers_; tid++) {
-    auto tierSizeRatio = static_cast<double>(
-        tierConfigs[tid].getSize()) / config_.getCacheSize();
-    auto tierPoolSize = static_cast<size_t>(tierSizeRatio * size);
-    auto res = allocator_[tid]->addPool(name, tierPoolSize, allocSizes, ensureProvisionable);
+    totalCacheSize += allocator_[tid]->getMemorySize();
+  }
+
+  for (TierId tid = 0; tid < numTiers_; tid++) {
+    auto tierSizeRatio =
+        static_cast<double>(allocator_[tid]->getMemorySize()) / totalCacheSize;
+    size_t tierPoolSize = static_cast<size_t>(tierSizeRatio * size);
+
+    tierPoolSizes.push_back(tierPoolSize);
+  }
+
+  for (TierId tid = 0; tid < numTiers_; tid++) {
+    // TODO: what if we manage to add pool only in one tier?
+    // we should probably remove that on failure
+    auto res = allocator_[tid]->addPool(
+        name, tierPoolSizes[tid], allocSizes, ensureProvisionable);
     XDCHECK(tid == 0 || res == pid);
     pid = res;
   }
@@ -2555,6 +2585,16 @@ const std::string CacheAllocator<CacheTrait>::getCacheName() const {
   return config_.cacheName;
 }
 
+template <typename CacheTrait>
+size_t CacheAllocator<CacheTrait>::getPoolSize(PoolId poolId) const {
+  size_t poolSize = 0;
+  for (auto& allocator: allocator_) {
+    const auto& pool = allocator->getPool(poolId);
+    poolSize += pool.getPoolSize();
+  }
+  return poolSize;
+}
+
 template <typename CacheTrait>
 PoolStats CacheAllocator<CacheTrait>::getPoolStats(PoolId poolId) const {
   const auto& pool = allocator_[currentTier()]->getPool(poolId);

cachelib/allocator/CacheAllocator.h

@@ -1106,8 +1106,8 @@ class CacheAllocator : public CacheBase {
   // get cache name
   const std::string getCacheName() const override final;
 
-  // whether it is object-cache
-  bool isObjectCache() const override final { return false; }
+  // combined pool size for all memory tiers
+  size_t getPoolSize(PoolId pid) const;
 
   // pool stats by pool id
   PoolStats getPoolStats(PoolId pid) const override final;
@@ -1673,6 +1673,8 @@ class CacheAllocator : public CacheBase {
   //         handle to the item. On failure an empty handle. 
   WriteHandle tryEvictToNextMemoryTier(Item& item);
 
+  size_t memoryTierSize(TierId tid) const;
+
   // Deserializer CacheAllocatorMetadata and verify the version
   //
   // @param  deserializer   Deserializer object

cachelib/allocator/CacheAllocatorConfig.h

@@ -207,15 +207,15 @@ class CacheAllocatorConfig {
   // cachePersistence().
   CacheAllocatorConfig& usePosixForShm();
 
-  // Configures cache memory tiers. Accepts vector of MemoryTierCacheConfig.
-  // Each vector element describes configuration for a single memory cache tier.
-  // @throw std::invalid_argument if:
-  // - the size of configs is 0
-  // - memory tiers use both size and ratio parameters
+  // Configures cache memory tiers. Each tier represents a cache region inside
+  // byte-addressable memory such as DRAM, Pmem, CXLmem.
+  // Accepts vector of MemoryTierCacheConfig. Each vector element describes
+  // configuration for a single memory cache tier. Tier sizes are specified as
+  // ratios, the number of parts of total cache size each tier would occupy.
   CacheAllocatorConfig& configureMemoryTiers(const MemoryTierConfigs& configs);
 
-  // Return vector of memory tier configs.
-  MemoryTierConfigs getMemoryTierConfigs() const;
+  // Return reference to MemoryTierCacheConfigs.
+  const MemoryTierConfigs& getMemoryTierConfigs() const;
 
   // This turns on a background worker that periodically scans through the
   // access container and look for expired items and remove them.
@@ -369,7 +369,7 @@ class CacheAllocatorConfig {
 
   const std::string& getCacheName() const noexcept { return cacheName; }
 
-  size_t getCacheSize() const noexcept;
+  size_t getCacheSize() const noexcept { return size; }
 
   bool isUsingPosixShm() const noexcept { return usePosixShm; }
 
@@ -391,8 +391,7 @@ class CacheAllocatorConfig {
   std::map<std::string, std::string> serialize() const;
 
   // The max number of memory cache tiers
-  // TODO: increase this number when multi-tier configs are enabled
-  inline static const size_t kMaxCacheMemoryTiers = 1;
+  inline static const size_t kMaxCacheMemoryTiers = 2;
 
   // Cache name for users to indentify their own cache.
   std::string cacheName{""};
@@ -608,8 +607,6 @@ class CacheAllocatorConfig {
   friend CacheT;
 
  private:
-  void validateMemoryTiersWithSize(const MemoryTierConfigs&, size_t) const;
-
   // Configuration for memory tiers.
   MemoryTierConfigs memoryTierConfigs{
     {MemoryTierCacheConfig::fromShm().setRatio(1)}
@@ -642,8 +639,6 @@ CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::setCacheName(
 
 template <typename T>
 CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::setCacheSize(size_t _size) {
-  validateMemoryTiersWithSize(this->memoryTierConfigs, _size);
-
   size = _size;
   constexpr size_t maxCacheSizeWithCoredump = 64'424'509'440; // 60GB
   if (size <= maxCacheSizeWithCoredump) {
@@ -897,57 +892,24 @@ CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::enableItemReaperInBackground(
 
 template <typename T>
 CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::configureMemoryTiers(
-      const MemoryTierConfigs& config) {
-  if (!config.size()) {
-    throw std::invalid_argument("There must be at least one memory tier.");
+    const MemoryTierConfigs& config) {
+  if (config.size() > kMaxCacheMemoryTiers) {
+    throw std::invalid_argument(folly::sformat(
+        "Too many memory tiers. The number of supported tiers is {}.",
+        kMaxCacheMemoryTiers));
   }
-
-  for (auto tier_config: config) {
-    auto tier_size = tier_config.getSize();
-    auto tier_ratio = tier_config.getRatio();
-    if ((!tier_size and !tier_ratio) || (tier_size and tier_ratio)) {
-      throw std::invalid_argument(
-        "For each memory tier either size or ratio must be set.");
-    }
+  if (!config.size()) {
+    throw std::invalid_argument(
+        "There must be at least one memory tier config.");
   }
-
-  validateMemoryTiersWithSize(config, this->size);
-
   memoryTierConfigs = config;
-
   return *this;
 }
 
 template <typename T>
-typename CacheAllocatorConfig<T>::MemoryTierConfigs
+const typename CacheAllocatorConfig<T>::MemoryTierConfigs&
 CacheAllocatorConfig<T>::getMemoryTierConfigs() const {
-  MemoryTierConfigs config = memoryTierConfigs;
-  size_t sum_ratios = 0;
-
-  for (auto &tier_config: config) {
-    if (auto *v = std::get_if<PosixSysVSegmentOpts>(&tier_config.shmOpts)) {
-      v->usePosix = usePosixShm;
-    }
-
-    sum_ratios += tier_config.getRatio();
-  }
-
-  if (sum_ratios == 0)
-    return config;
-
-  // if ratios are used, size must be specified
-  XDCHECK(size);
-
-  // Convert ratios to sizes, size must be non-zero
-  size_t sum_sizes = 0;
-  size_t partition_size = size / sum_ratios;
-  for (auto& tier_config: config) {
-    tier_config.setSize(partition_size * tier_config.getRatio());
-    tier_config.setRatio(0);
-    sum_sizes += tier_config.getSize();
-  }
-
-  return config;
+  return memoryTierConfigs;
 }
 
 template <typename T>
@@ -1079,46 +1041,6 @@ CacheAllocatorConfig<T>::setSkipPromoteChildrenWhenParentFailed() {
   return *this;
 }
 
-template <typename T>
-size_t CacheAllocatorConfig<T>::getCacheSize() const noexcept {
-  if (size)
-    return size;
-
-  size_t sum_sizes = 0;
-  for (const auto &tier_config : getMemoryTierConfigs()) {
-    sum_sizes += tier_config.getSize();
-  }
-
-  return sum_sizes;
-}
-
-template <typename T>
-void CacheAllocatorConfig<T>::validateMemoryTiersWithSize(
-    const MemoryTierConfigs &config, size_t size) const {
-  size_t sum_ratios = 0;
-  size_t sum_sizes = 0;
-
-  for (const auto &tier_config: config) {
-    sum_ratios += tier_config.getRatio();
-    sum_sizes += tier_config.getSize();
-  }
-
-  if (sum_ratios && sum_sizes) {
-    throw  std::invalid_argument("Cannot mix ratios and sizes.");
-  } else if (sum_sizes) {
-    if (size && sum_sizes != size) {
-      throw std::invalid_argument(
-          "Sum of tier sizes doesn't match total cache size. "
-          "Setting of cache total size is not required when per-tier "
-          "sizes are specified - it is calculated as sum of tier sizes.");
-    }
-  } else if (!sum_ratios && !sum_sizes) {
-    throw std::invalid_argument(
-      "Either sum of all memory tiers sizes or sum of all ratios "
-      "must be greater than 0.");
-  }
-}
-
 template <typename T>
 const CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::validate() const {
   // we can track tail hits only if MMType is MM2Q
@@ -1143,23 +1065,7 @@ const CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::validate() const {
         "It's not allowed to enable both RemoveCB and ItemDestructor.");
   }
 
-  size_t sum_ratios = 0;
-  for (auto tier_config: memoryTierConfigs) {
-    sum_ratios += tier_config.getRatio();
-  }
-
-  if (sum_ratios) {
-    if (!size) {
-      throw std::invalid_argument(
-          "Total cache size must be specified when size ratios are "
-          "used to specify memory tier sizes.");
-    } else if (size < sum_ratios) {
-      throw std::invalid_argument(
-        "Sum of all tier size ratios is greater than total cache size.");
-    }
-  }
-
-  return *this;
+  return validateMemoryTiers();
 }
 
 template <typename T>

cachelib/allocator/MemoryTierCacheConfig.h

@@ -40,42 +40,46 @@ class MemoryTierCacheConfig {
     return config;
   }
 
-  // Specifies size of this memory tier. Sizes of tiers  must be specified by
-  // either setting size explicitly or using ratio, mixing of the two is not supported.
-  MemoryTierCacheConfig& setSize(size_t _size) {
-    size = _size;
-    return *this;
-  }
-
   // Specifies ratio of this memory tier to other tiers. Absolute size
   // of each tier can be calculated as:
-  // cacheSize * tierRatio / Sum of ratios for all tiers; the difference
-  // between total cache size and sum of all tier sizes resulted from
-  // round off error is accounted for when calculating the last tier's
-  // size to make the totals equal.
-  MemoryTierCacheConfig& setRatio(double _ratio) {
+  // cacheSize * tierRatio / Sum of ratios for all tiers.
+  MemoryTierCacheConfig& setRatio(size_t _ratio) {
+    if (!_ratio) {
+      throw std::invalid_argument("Tier ratio must be an integer number >=1.");
+    }
     ratio = _ratio;
     return *this;
   }
 
   size_t getRatio() const noexcept { return ratio; }
 
-  size_t getSize() const noexcept { return size; }
-
   const ShmTypeOpts& getShmTypeOpts() const noexcept { return shmOpts; }
 
-  // Size of this memory tiers
-  size_t size{0};
+  size_t calculateTierSize(size_t totalCacheSize, size_t partitionNum) const {
+    if (!partitionNum) {
+      throw std::invalid_argument(
+          "The total number of tier ratios must be an integer number >=1.");
+    }
 
-  // Ratio is a number of parts of the total cache size to be allocated for this tier.
-  // E.g. if X is a total cache size, Yi are ratios specified for memory tiers,
-  // then size of the i-th tier Xi = (X / (Y1 + Y2)) * Yi and X = sum(Xi)
-  size_t ratio{0};
+    if (partitionNum > totalCacheSize) {
+      throw std::invalid_argument(
+          "Ratio must be less or equal to total cache size.");
+    }
+
+    return static_cast<size_t>(getRatio() * (static_cast<double>(totalCacheSize) / partitionNum));
+  }
+
+private:
+  // Ratio is a number of parts of the total cache size to be allocated for this
+  // tier. E.g. if X is a total cache size, Yi are ratios specified for memory
+  // tiers, and Y is the sum of all Yi, then size of the i-th tier
+  // Xi = (X / Y) * Yi. For examle, to configure 2-tier cache where each
+  // tier is a half of the total cache size, set both tiers' ratios to 1.
+  size_t ratio{1};
 
   // Options specific to shm type
   ShmTypeOpts shmOpts;
 
-private:
   MemoryTierCacheConfig() = default;
 };
 } // namespace cachelib

cachelib/allocator/memory/SlabAllocator.cpp

@@ -40,7 +40,7 @@
 using namespace facebook::cachelib;
 
 namespace {
-size_t roundDownToSlabSize(size_t size) { return size - (size % sizeof(Slab)); }
+static inline size_t roundDownToSlabSize(size_t size) { return size - (size % sizeof(Slab)); }
 } // namespace
 
 // definitions to avoid ODR violation.