Merge pull request ceph#52489 from ifed01/wip-ifed-alloc2

os/bluestore: introduce hybrid_btree2 allocator

Author: aclamk

src/common/options/global.yaml.in

@@ -4213,6 +4213,7 @@ options:
   - avl
   - btree
   - hybrid
+  - hybrid_btree2
   with_legacy: true
 - name: bluefs_log_replay_check_allocations
   type: bool
@@ -5053,6 +5054,7 @@ options:
   - avl
   - btree
   - hybrid
+  - hybrid_btree2
   with_legacy: true
 - name: bluestore_freelist_blocks_per_key
   type: size
@@ -5561,6 +5563,11 @@ options:
   level: dev
   desc: Maximum RAM hybrid allocator should use before enabling bitmap supplement
   default: 64_M
+- name: bluestore_btree2_alloc_weight_factor
+  type: float
+  level: dev
+  desc: Large continuous extents weight factor
+  default: 2
 - name: bluestore_volume_selection_policy
   type: str
   level: dev

src/crimson/os/alienstore/CMakeLists.txt

@@ -50,6 +50,7 @@ set(alien_store_srcs
   ${PROJECT_SOURCE_DIR}/src/os/bluestore/Allocator.cc
   ${PROJECT_SOURCE_DIR}/src/os/bluestore/AvlAllocator.cc
   ${PROJECT_SOURCE_DIR}/src/os/bluestore/BtreeAllocator.cc
+  ${PROJECT_SOURCE_DIR}/src/os/bluestore/Btree2Allocator.cc
   ${PROJECT_SOURCE_DIR}/src/os/bluestore/BitmapFreelistManager.cc
   ${PROJECT_SOURCE_DIR}/src/os/bluestore/BlueFS.cc
   ${PROJECT_SOURCE_DIR}/src/os/bluestore/bluefs_types.cc

src/include/intarith.h

@@ -57,6 +57,18 @@ constexpr inline T p2align(T x, T align) {
   return x & -align;
 }
 
+/*
+ * return whether x is aligned with (align)
+ * eg, p2aligned(1200, 1024) ==> false
+ * eg, p2aligned(1024, 1024) ==> true
+ * eg, p2aligned(0x1234, 0x100) ==> false
+ * eg, p2aligned(0x5600, 0x100) ==> true
+ */
+template<typename T>
+constexpr inline bool p2aligned(T x, T align) {
+  return p2align(x, align) == x;
+}
+
 /*
  * return x % (mod) align
  * eg, p2phase(0x1234, 0x100) == 0x34 (x-0x12*align)

src/os/CMakeLists.txt

@@ -23,6 +23,7 @@ if(WITH_BLUESTORE)
     bluestore/BitmapAllocator.cc
     bluestore/AvlAllocator.cc
     bluestore/BtreeAllocator.cc
+    bluestore/Btree2Allocator.cc
     bluestore/HybridAllocator.cc
   )
 endif(WITH_BLUESTORE)

src/os/bluestore/Allocator.cc

@@ -7,9 +7,11 @@
 #include "BitmapAllocator.h"
 #include "AvlAllocator.h"
 #include "BtreeAllocator.h"
+#include "Btree2Allocator.h"
 #include "HybridAllocator.h"
 #include "common/debug.h"
 #include "common/admin_socket.h"
+
 #define dout_subsys ceph_subsys_bluestore
 using TOPNSPC::common::cmd_getval;
 
@@ -108,7 +110,7 @@ class Allocator::SocketHook : public AdminSocketHook {
     } else if (command == "bluestore allocator fragmentation histogram " + name) {
       int64_t alloc_unit = 4096;
       cmd_getval(cmdmap, "alloc_unit", alloc_unit);
-      if (alloc_unit == 0  ||
+      if (alloc_unit <= 0  ||
           p2align(alloc_unit, alloc->get_block_size()) != alloc_unit) {
         ss << "Invalid allocation unit: '" << alloc_unit
            << ", to be aligned with: '" << alloc->get_block_size()
@@ -123,20 +125,22 @@ class Allocator::SocketHook : public AdminSocketHook {
         return -EINVAL;
       }
 
-      Allocator::FreeStateHistogram hist;
-      hist.resize(num_buckets);
-      alloc->build_free_state_histogram(alloc_unit, hist);
+      Allocator::FreeStateHistogram hist(num_buckets);
+      alloc->foreach(
+        [&](size_t off, size_t len) {
+          hist.record_extent(uint64_t(alloc_unit), off, len);
+        });
       f->open_array_section("extent_counts");
-      for(int i = 0; i < num_buckets; i++) {
-        f->open_object_section("c");
-        f->dump_unsigned("max_len",
-          hist[i].get_max(i, num_buckets)
-        );
-        f->dump_unsigned("total", hist[i].total);
-        f->dump_unsigned("aligned", hist[i].aligned);
-        f->dump_unsigned("units", hist[i].alloc_units);
-        f->close_section();
-      }
+      hist.foreach(
+        [&](uint64_t max_len, uint64_t total, uint64_t aligned, uint64_t units) {
+          f->open_object_section("c");
+          f->dump_unsigned("max_len", max_len);
+          f->dump_unsigned("total", total);
+          f->dump_unsigned("aligned", aligned);
+          f->dump_unsigned("units", units);
+          f->close_section();
+        }
+      );
       f->close_section();
     } else {
       ss << "Invalid command" << std::endl;
@@ -182,8 +186,13 @@ Allocator *Allocator::create(
   } else if (type == "btree") {
     return new BtreeAllocator(cct, size, block_size, name);
   } else if (type == "hybrid") {
-    return new HybridAllocator(cct, size, block_size,
+    return new HybridAvlAllocator(cct, size, block_size,
+      cct->_conf.get_val<uint64_t>("bluestore_hybrid_alloc_mem_cap"),
+      name);
+  }  else if (type == "hybrid_btree2") {
+    return new HybridBtree2Allocator(cct, size, block_size,
       cct->_conf.get_val<uint64_t>("bluestore_hybrid_alloc_mem_cap"),
+      cct->_conf.get_val<double>("bluestore_btree2_alloc_weight_factor"),
       name);
   }
   if (alloc == nullptr) {
@@ -195,7 +204,7 @@ Allocator *Allocator::create(
 
 void Allocator::release(const PExtentVector& release_vec)
 {
-  interval_set<uint64_t> release_set;
+  release_set_t release_set;
   for (auto e : release_vec) {
     release_set.insert(e.offset, e.length);
   }
@@ -266,50 +275,40 @@ double Allocator::get_fragmentation_score()
   return (ideal - score_sum) / (ideal - terrible);
 }
 
-void Allocator::build_free_state_histogram(
-  size_t alloc_unit, Allocator::FreeStateHistogram& hist)
-{
-  auto num_buckets = hist.size();
-  ceph_assert(num_buckets);
-
-  auto base = free_state_hist_bucket::base;
-  auto base_bits = free_state_hist_bucket::base_bits;
-  auto mux = free_state_hist_bucket::mux;
-  // maximum chunk size we track,
-  // provided by the bucket before the last one
-  size_t max =
-    free_state_hist_bucket::get_max(num_buckets - 2, num_buckets);
-
-  auto iterated_allocation = [&](size_t off, size_t len) {
-    size_t idx;
-    if (len <= base) {
-      idx = 0;
-    } else if (len > max) {
-      idx = num_buckets - 1;
-    } else {
-      size_t most_bit = cbits(uint64_t(len-1)) - 1;
-      idx = 1 + ((most_bit - base_bits) / mux);
-    }
-    ceph_assert(idx < num_buckets);
-    ++hist[idx].total;
+/*************
+* Allocator::FreeStateHistogram
+*************/
+using std::function;
 
-    // now calculate the bucket for the chunk after alignment,
-    // resulting chunks shorter than alloc_unit are discarded
-    auto delta = p2roundup(off, alloc_unit) - off;
-    if (len >= delta + alloc_unit) {
-      len -= delta;
-      if (len <= base) {
-        idx = 0;
-      } else if (len > max) {
-        idx = num_buckets - 1;
-      } else {
-        size_t most_bit = cbits(uint64_t(len-1)) - 1;
-        idx = 1 + ((most_bit - base_bits) / mux);
-      }
-      ++hist[idx].aligned;
-      hist[idx].alloc_units += len / alloc_unit;
-    }
-  };
+void Allocator::FreeStateHistogram::record_extent(uint64_t alloc_unit,
+                                                  uint64_t off,
+                                                  uint64_t len)
+{
+  size_t idx = myTraits._get_bucket(len);
+  ceph_assert(idx < buckets.size());
+  ++buckets[idx].total;
 
-  foreach(iterated_allocation);
+  // now calculate the bucket for the chunk after alignment,
+  // resulting chunks shorter than alloc_unit are discarded
+  auto delta = p2roundup(off, alloc_unit) - off;
+  if (len >= delta + alloc_unit) {
+    len -= delta;
+    idx = myTraits._get_bucket(len);
+    ceph_assert(idx < buckets.size());
+    ++buckets[idx].aligned;
+    buckets[idx].alloc_units += len / alloc_unit;
+  }
+}
+void Allocator::FreeStateHistogram::foreach(
+  function<void(uint64_t max_len,
+                uint64_t total,
+                uint64_t aligned,
+                uint64_t unit)> cb)
+{
+  size_t i = 0;
+  for (const auto& b : buckets) {
+    cb(myTraits._get_bucket_max(i),
+      b.total, b.aligned, b.alloc_units);
+    ++i;
+  }
 }