os/bluestore: introduce allocator lookup policy

This allows to have different free space lookup approaches for ssd and hdd
drives.

Signed-off-by: Igor Fedotov <[email protected]>

Author: Igor Fedotov

src/common/options/global.yaml.in

@@ -5646,6 +5646,23 @@ options:
   - hdd
   - ssd
   with_legacy: true
+- name: bluestore_allocator_lookup_policy
+  type: str
+  level: advanced
+  desc: Determines how to perform the next free extent lookup.
+  long_desc: When set to 'hdd_optimized' the allocator searches from the last
+     location found. This may facilitate contiguous disk writes. It may similarly
+     be beneficial for large-IU QLC SSDs to enable firmware coalescing of sub-IU
+     writes.
+     When set to 'ssd-optimized' the allocator will search from the beginning of
+     the device. This may facilitate SSD firmware housekeeping.
+     When set to 'auto' the value will be derived from the detected device type
+    (rotational or non-rotational).
+  default: auto
+  enum_values:
+  - hdd_optimized
+  - ssd_optimized
+  - auto
 - name: bluestore_avl_alloc_ff_max_search_count
   type: uint
   level: dev

src/os/bluestore/AvlAllocator.cc

@@ -239,14 +239,14 @@ int64_t AvlAllocator::_allocate(
   uint64_t want,
   uint64_t unit,
   uint64_t max_alloc_size,
-  int64_t  hint, // unused, for now!
+  int64_t  hint,
   PExtentVector* extents)
 {
   uint64_t allocated = 0;
   while (allocated < want) {
     uint64_t offset, length;
     int r = _allocate(std::min(max_alloc_size, want - allocated),
-      unit, &offset, &length);
+      unit, hint, &offset, &length);
     if (r < 0) {
       // Allocation failed.
       break;
@@ -260,6 +260,7 @@ int64_t AvlAllocator::_allocate(
 int AvlAllocator::_allocate(
   uint64_t size,
   uint64_t unit,
+  int64_t  hint,
   uint64_t *offset,
   uint64_t *length)
 {
@@ -296,7 +297,9 @@ int AvlAllocator::_allocate(
      */
     uint64_t align = size & -size;
     ceph_assert(align != 0);
-    uint64_t* cursor = &lbas[cbits(align) - 1];
+    uint64_t dummy_cursor = (uint64_t)hint;
+    uint64_t* cursor =
+      hint == -1 ? &lbas[cbits(align) - 1] : &dummy_cursor;
     start = _pick_block_after(cursor, size, unit);
     dout(20) << __func__
              << std::hex << " first fit params: 0x" << start << "~" << size
@@ -399,7 +402,7 @@ int64_t AvlAllocator::allocate(
   uint64_t want,
   uint64_t unit,
   uint64_t max_alloc_size,
-  int64_t  hint, // unused, for now!
+  int64_t  hint,
   PExtentVector* extents)
 {
   ldout(cct, 10) << __func__ << std::hex

src/os/bluestore/AvlAllocator.h

@@ -109,6 +109,7 @@ class AvlAllocator : public AllocatorBase {
   int _allocate(
     uint64_t size,
     uint64_t unit,
+    int64_t  hint,
     uint64_t *offset,
     uint64_t *length);
 

src/os/bluestore/BlueFS.cc

@@ -4387,7 +4387,7 @@ int BlueFS::_allocate(uint8_t id, uint64_t len,
   ceph_assert(id < alloc.size());
   int64_t alloc_len = 0;
   PExtentVector extents;
-  uint64_t hint = 0;
+  int64_t hint = -1;
   int64_t need = len;
   bool shared = is_shared_alloc(id);
   auto shared_unit = shared_alloc ? shared_alloc->alloc_unit : 0;
@@ -4414,7 +4414,7 @@ int BlueFS::_allocate(uint8_t id, uint64_t len,
     need = round_up_to(len, alloc_unit);
     if (!node->extents.empty() && node->extents.back().bdev == id) {
       hint = node->extents.back().end();
-    }   
+    }
     ++alloc_attempts;
     extents.reserve(4);  // 4 should be (more than) enough for most allocations
     auto t0 = mono_clock::now();

src/os/bluestore/BlueStore.cc

@@ -5742,7 +5742,8 @@ std::vector<std::string> BlueStore::get_tracked_keys() const noexcept
     "bluestore_warn_on_no_per_pool_omap"s,
     "bluestore_warn_on_no_per_pg_omap"s,
     "bluestore_max_defer_interval"s,
-    "bluestore_onode_segment_size"s
+    "bluestore_onode_segment_size"s,
+    "bluestore_allocator_lookup_policy"s
   };
 }
 
@@ -5814,6 +5815,9 @@ void BlueStore::handle_conf_change(const ConfigProxy& conf,
       changed.count("osd_memory_expected_fragmentation")) {
     _update_osd_memory_options();
   }
+  if (changed.count("bluestore_allocator_lookup_policy")) {
+    _update_allocator_lookup_policy();
+  }
 }
 
 void BlueStore::_set_compression()
@@ -5948,6 +5952,24 @@ void BlueStore::_update_osd_memory_options()
            << dendl;
 }
 
+
+void BlueStore::_update_allocator_lookup_policy()
+{
+  auto policy = cct->_conf.get_val<string>("bluestore_allocator_lookup_policy");
+  if (policy == "hdd_optimized") {
+    use_last_allocator_lookup_position = true;
+  } else if (policy == "ssd_optimized") {
+    use_last_allocator_lookup_position = false;
+  } else {
+    // Apply "auto" policy for everything else.
+    // Which means reusing last lookup position for hdds.
+    use_last_allocator_lookup_position = _use_rotational_settings();
+  }
+  dout(5) << __func__
+          << " use_last_lookup_position " << use_last_allocator_lookup_position
+          << dendl;
+}
+
 int BlueStore::_set_cache_sizes()
 {
   ceph_assert(bdev);
@@ -11240,7 +11262,7 @@ int BlueStore::_fsck_on_open(BlueStore::FSCKDepth depth, bool repair)
 	    dout(5) << __func__ << "::NCB::(F)alloc=" << alloc << ", length=" << e->length << dendl;
 	    int64_t alloc_len =
               alloc->allocate(e->length, min_alloc_size,
-				       0, 0, &exts);
+				       0, -1, &exts);
 	    if (alloc_len < 0 || alloc_len < (int64_t)e->length) {
 	      derr << __func__
 	           << " failed to allocate 0x" << std::hex << e->length
@@ -11694,7 +11716,7 @@ void BlueStore::inject_leaked(uint64_t len)
 {
   PExtentVector exts;
   int64_t alloc_len = alloc->allocate(len, min_alloc_size,
-					   min_alloc_size * 256, 0, &exts);
+					   min_alloc_size * 256, -1, &exts);
   ceph_assert(alloc_len >= 0); // generally we do not expect any errors
   if (fm->is_null_manager()) {
     return;
@@ -14087,6 +14109,7 @@ int BlueStore::_open_super_meta()
   _set_csum();
   _set_compression();
   _set_blob_size();
+  _update_allocator_lookup_policy();
 
   _validate_bdev();
   return 0;
@@ -17019,7 +17042,8 @@ int BlueStore::_do_alloc_write(
   auto start = mono_clock::now();
   prealloc_left = alloc->allocate(
     need, min_alloc_size, need,
-    0, &prealloc);
+    use_last_allocator_lookup_position ? -1 : 0,
+    &prealloc);
   log_latency("allocator@_do_alloc_write",
     l_bluestore_allocator_lat,
     mono_clock::now() - start,

src/os/bluestore/BlueStore.h

@@ -2536,6 +2536,8 @@ class BlueStore : public ObjectStore,
   friend class SocketHook;
   AdminSocketHook* asok_hook = nullptr;
 
+  bool use_last_allocator_lookup_position = true;
+
   struct MempoolThread : public Thread {
   public:
     BlueStore *store;
@@ -2793,6 +2795,7 @@ class BlueStore : public ObjectStore,
   void _set_finisher_num();
   void _set_per_pool_omap();
   void _update_osd_memory_options();
+  void _update_allocator_lookup_policy();
 
   int _open_bdev(bool create);
   // Verifies if disk space is enough for reserved + min bluefs

src/os/bluestore/Btree2Allocator.cc

@@ -65,7 +65,7 @@ int64_t Btree2Allocator::allocate(
   uint64_t want,
   uint64_t unit,
   uint64_t max_alloc_size,
-  int64_t  hint, // unused, for now!
+  int64_t  hint, // unused and likely unneeded
   PExtentVector* extents)
 {
   ldout(cct, 10) << __func__ << std::hex
@@ -182,7 +182,7 @@ int64_t Btree2Allocator::_allocate(
   uint64_t want,
   uint64_t unit,
   uint64_t max_alloc_size,
-  int64_t  hint, // unused, for now!
+  int64_t  hint, // unused and likely unneeded
   PExtentVector* extents)
 {
   uint64_t allocated = 0;

src/os/bluestore/BtreeAllocator.cc

@@ -226,14 +226,14 @@ int64_t BtreeAllocator::_allocate(
   uint64_t want,
   uint64_t unit,
   uint64_t max_alloc_size,
-  int64_t  hint, // unused, for now!
+  int64_t  hint,
   PExtentVector* extents)
 {
   uint64_t allocated = 0;
   while (allocated < want) {
     uint64_t offset, length;
     int r = _allocate(std::min(max_alloc_size, want - allocated),
-                      unit, &offset, &length);
+                      unit, hint, &offset, &length);
     if (r < 0) {
       // Allocation failed.
       break;
@@ -248,6 +248,7 @@ int64_t BtreeAllocator::_allocate(
 int BtreeAllocator::_allocate(
   uint64_t size,
   uint64_t unit,
+  int64_t  hint,
   uint64_t *offset,
   uint64_t *length)
 {
@@ -294,7 +295,8 @@ int BtreeAllocator::_allocate(
        * not guarantee that other allocations sizes may exist in the same
        * region.
        */
-      uint64_t* cursor = &lbas[cbits(size) - 1];
+      uint64_t dummy_cursor = (uint64_t)hint;
+      uint64_t* cursor = hint == -1 ? &lbas[cbits(size) - 1] : &dummy_cursor;
       start = _pick_block_after(cursor, size, unit);
       dout(20) << __func__ << " first fit=" << start << " size=" << size << dendl;
       if (start != uint64_t(-1ULL)) {
@@ -376,7 +378,7 @@ int64_t BtreeAllocator::allocate(
   uint64_t want,
   uint64_t unit,
   uint64_t max_alloc_size,
-  int64_t  hint, // unused, for now!
+  int64_t  hint,
   PExtentVector* extents)
 {
   ldout(cct, 10) << __func__ << std::hex

src/os/bluestore/BtreeAllocator.h

@@ -103,6 +103,7 @@ class BtreeAllocator : public AllocatorBase {
   int _allocate(
     uint64_t size,
     uint64_t unit,
+    int64_t  hint,
     uint64_t *offset,
     uint64_t *length);
 

src/os/bluestore/HybridAllocator.cc

@@ -32,7 +32,7 @@ int64_t HybridBtree2Allocator::allocate(
   uint64_t want,
   uint64_t unit,
   uint64_t max_alloc_size,
-  int64_t  hint,
+  int64_t  hint, // unused and likely unneeded for btree2 allocator
   PExtentVector* extents)
 {
   ldout(get_context(), 10) << __func__ << std::hex