Initial multi-tier support implementation

Part 1.
-----------------------------------------
This includes the following:
 - Multi-tier allocator with TierId
 - allocateInternalTier
 - creating multi-tier allocator on shared memory
 - serialization
 - some basic tests
 - Add option to insert items to first free tier, this enables
   an interleaving approach. Ther is no data movement among
   the tiers. Use `insertToFirstFreeTier` option to control.
   In order to evict data from the second tier, you will need
   to have the background movers enabled.

Author: igchor

cachelib/allocator/BackgroundMover.h

@@ -27,28 +27,34 @@ template <typename C>
 struct BackgroundMoverAPIWrapper {
   // traverse the cache and move items from one tier to another
   // @param cache             the cache interface
+  // @param tid               the tier to traverse
   // @param pid               the pool id to traverse
   // @param cid               the class id to traverse
   // @param evictionBatch     number of items to evict in one go
   // @param promotionBatch    number of items to promote in one go
   // @return pair of number of items evicted and promoted
   static std::pair<size_t, size_t> traverseAndMoveItems(C& cache,
+                                                        TierId tid,
                                                         PoolId pid,
                                                         ClassId cid,
                                                         size_t evictionBatch,
                                                         size_t promotionBatch) {
-    return cache.traverseAndMoveItems(pid, cid, evictionBatch, promotionBatch);
+    return cache.traverseAndMoveItems(tid, pid, cid, evictionBatch, promotionBatch);
   }
   static std::pair<size_t, double> getApproxUsage(C& cache,
+                                                  TierId tid,
                                                   PoolId pid,
                                                   ClassId cid) {
-    const auto& pool = cache.getPool(pid);
+    const auto& pool = cache.getPoolByTid(pid, tid);
     // we wait until all slabs are allocated before we start evicting
     if (!pool.allSlabsAllocated()) {
       return {0, 0.0};
     }
     return pool.getApproxUsage(cid);
   }
+  static unsigned int getNumTiers(C& cache) {
+    return cache.getNumTiers();
+  }
 };
 
 // Periodic worker that evicts items from tiers in batches
@@ -78,7 +84,7 @@ class BackgroundMover : public PeriodicWorker {
 
   // return id of the worker responsible for promoting/evicting from particlar
   // pool and allocation calss (id is in range [0, numWorkers))
-  static size_t workerId(PoolId pid, ClassId cid, size_t numWorkers);
+  static size_t workerId(TierId tid, PoolId pid, ClassId cid, size_t numWorkers);
 
  private:
   struct TraversalStats {
@@ -135,7 +141,9 @@ BackgroundMover<CacheT>::BackgroundMover(Cache& cache,
     : cache_(cache),
       evictionBatch_(evictionBatch),
       promotionBatch_(promotionBatch),
-      targetFree_(targetFree) {}
+      targetFree_(targetFree) {
+        numTiers_ = BackgroundMoverAPIWrapper<CacheT>::getNumTiers(cache_);
+      }
 
 template <typename CacheT>
 void BackgroundMover<CacheT>::TraversalStats::recordTraversalTime(
@@ -170,8 +178,8 @@ template <typename CacheT>
 void BackgroundMover<CacheT>::setAssignedMemory(
     std::vector<MemoryDescriptorType>&& assignedMemory) {
   XLOG(INFO, "Class assigned to background worker:");
-  for (auto [pid, cid] : assignedMemory) {
-    XLOGF(INFO, "Pid: {}, Cid: {}", pid, cid);
+  for (auto [tid, pid, cid] : assignedMemory) {
+    XLOGF(INFO, "Tid: {}, Pid: {}, Cid: {}", tid, pid, cid);
   }
 
   mutex_.lock_combine([this, &assignedMemory] {
@@ -185,10 +193,10 @@ BackgroundMover<CacheT>::getNumItemsToFree(
     const std::vector<MemoryDescriptorType>& assignedMemory) {
   std::map<MemoryDescriptorType, size_t> toFree;
   for (const auto& md : assignedMemory) {
-    const auto [pid, cid] = md;
+    const auto [tid, pid, cid] = md;
     const auto& pool = cache_.getPool(pid);
     const auto [activeItems, usage] =
-        BackgroundMoverAPIWrapper<CacheT>::getApproxUsage(cache_, pid, cid);
+        BackgroundMoverAPIWrapper<CacheT>::getApproxUsage(cache_, tid, pid, cid);
     if (usage < 1 - targetFree_) {
       toFree[md] = 0;
     } else {
@@ -210,7 +218,7 @@ void BackgroundMover<CacheT>::checkAndRun() {
   while (true) {
     bool allDone = true;
     for (auto md : assignedMemory) {
-      const auto [pid, cid] = md;
+      const auto [tid, pid, cid] = md;
       size_t evictionBatch = evictionBatch_;
       size_t promotionBatch = 0; // will enable with multi-tier support
       if (toFree[md] == 0) {
@@ -224,7 +232,7 @@ void BackgroundMover<CacheT>::checkAndRun() {
         const auto begin = util::getCurrentTimeNs();
         // try moving BATCH items from the class in order to reach free target
         auto moved = BackgroundMoverAPIWrapper<CacheT>::traverseAndMoveItems(
-            cache_, pid, cid, evictionBatch, promotionBatch);
+            cache_, tid, pid, cid, evictionBatch, promotionBatch);
         numEvictedItems_ += moved.first;
         toFree[md] > moved.first ? toFree[md] -= moved.first : toFree[md] = 0;
         numPromotedItems_ += moved.second;
@@ -263,12 +271,13 @@ BackgroundMoverStats BackgroundMover<CacheT>::getStats() const noexcept {
 }
 
 template <typename CacheT>
-size_t BackgroundMover<CacheT>::workerId(PoolId pid,
+size_t BackgroundMover<CacheT>::workerId(TierId tid,
+                                         PoolId pid,
                                          ClassId cid,
                                          size_t numWorkers) {
   XDCHECK(numWorkers);
 
   // TODO: came up with some better sharding (use hashing?)
-  return (pid + cid) % numWorkers;
+  return (tid + pid + cid) % numWorkers;
 }
 }; // namespace facebook::cachelib

cachelib/allocator/Cache.h

@@ -75,16 +75,20 @@ enum class DestructorContext {
 
 // a tuple that describes the memory pool and allocation class
 struct MemoryDescriptorType {
-  MemoryDescriptorType(PoolId pid, ClassId cid) : pid_(pid), cid_(cid) {}
+  MemoryDescriptorType(TierId tid, PoolId pid, ClassId cid) : 
+      tid_(tid), pid_(pid), cid_(cid) {}
+  TierId tid_;
   PoolId pid_;
   ClassId cid_;
 
   bool operator<(const MemoryDescriptorType& rhs) const {
-    return std::make_tuple(pid_, cid_) < std::make_tuple(rhs.pid_, rhs.cid_);
+    return std::make_tuple(tid_, pid_, cid_) < 
+        std::make_tuple(rhs.tid_, rhs.pid_, rhs.cid_);
   }
 
   bool operator==(const MemoryDescriptorType& rhs) const {
-    return std::make_tuple(pid_, cid_) == std::make_tuple(rhs.pid_, rhs.cid_);
+    return std::make_tuple(tid_, pid_, cid_) == 
+        std::make_tuple(rhs.tid_, rhs.pid_, rhs.cid_);
   }
 };
 
@@ -111,6 +115,12 @@ class CacheBase {
   // @param poolId    The pool id to query
   virtual const MemoryPool& getPool(PoolId poolId) const = 0;
 
+  // Get the reference to a memory pool using a tier id, for stats purposes
+  //
+  // @param poolId    The pool id to query
+  // @param tierId    The tier of the pool id
+  virtual const MemoryPool& getPoolByTid(PoolId poolId, TierId tid) const = 0;
+
   // Get Pool specific stats (regular pools). This includes stats from the
   // Memory Pool and also the cache.
   //
@@ -121,7 +131,7 @@ class CacheBase {
   //
   // @param poolId   the pool id
   // @param classId   the class id
-  virtual ACStats getACStats(PoolId poolId, ClassId classId) const = 0;
+  virtual ACStats getACStats(TierId tid,PoolId poolId, ClassId classId) const = 0;
 
   // @param poolId   the pool id
   virtual AllSlabReleaseEvents getAllSlabReleaseEvents(PoolId poolId) const = 0;