seastore: make rbm_alloc_delta_t to use pair<paddr_t, size>

This commit makes rbm_alloc_delta_t to use std::pair based on
paddr_t in order that other modules such as cache, which does not
know about RBM, can add free information.

Signed-off-by: Myoungwon Oh <myoungwon.oh@samsung.com>

diff --git a/src/crimson/os/seastore/random_block_manager/nvme_manager.cc b/src/crimson/os/seastore/random_block_manager/nvme_manager.cc
index 558cad59db2a636f2eb5f41fdcd45b5e6b131b64..42410214c772806b99266e06fd279453ccffa233 100644 (file)
--- a/src/crimson/os/seastore/random_block_manager/nvme_manager.cc
+++ b/src/crimson/os/seastore/random_block_manager/nvme_manager.cc
@@ -264,15 +264,21 @@ NVMeManager::allocate_ertr::future<> NVMeManager::alloc_extent(
    *
    */
   return find_free_block(t, size
-      ).safe_then([] (auto alloc_extent) mutable
+      ).safe_then([this] (auto alloc_extent) mutable
        -> allocate_ertr::future<> {
        logger().debug("after find_free_block: allocated {}", alloc_extent);
        if (!alloc_extent.empty()) {
-         rbm_alloc_delta_t alloc_info {
-           extent_types_t::RBM_ALLOC_INFO,
-           alloc_extent,
-           rbm_alloc_delta_t::op_types_t::SET
-         };
+         rbm_alloc_delta_t alloc_info;
+         for (auto p : alloc_extent) {
+           paddr_t paddr = convert_blk_paddr_to_paddr(
+             p.first * super.block_size,
+             super.block_size,
+             super.blocks_per_segment,
+             0);
+           size_t len = p.second * super.block_size;
+           alloc_info.alloc_blk_ranges.push_back(std::make_pair(paddr, len));
+           alloc_info.op = rbm_alloc_delta_t::op_types_t::SET;
+         }
          // TODO: add alloc info to delta
        } else {
          return crimson::ct_error::enospc::make();
@@ -297,15 +303,14 @@ NVMeManager::free_block_ertr::future<> NVMeManager::add_free_extent(
     std::vector<rbm_alloc_delta_t>& v, blk_paddr_t from, size_t len)
 {
   ceph_assert(!(len % super.block_size));
-  blk_id_t blk_id_start = from / super.block_size;
-
-  interval_set<blk_id_t> free_extent;
-  free_extent.insert(blk_id_start, len / super.block_size);
-  rbm_alloc_delta_t alloc_info {
-    extent_types_t::RBM_ALLOC_INFO,
-    free_extent,
-    rbm_alloc_delta_t::op_types_t::CLEAR
-  };
+  paddr_t paddr = convert_blk_paddr_to_paddr(
+    from,
+    super.block_size,
+    super.blocks_per_segment,
+    0);
+  rbm_alloc_delta_t alloc_info;
+  alloc_info.alloc_blk_ranges.push_back(std::make_pair(paddr, len));
+  alloc_info.op = rbm_alloc_delta_t::op_types_t::CLEAR;
   v.push_back(alloc_info);
   return free_block_ertr::now();
 }
@@ -438,31 +443,40 @@ NVMeManager::write_ertr::future<> NVMeManager::sync_allocation(
     [&, this] (auto &alloc_blocks) mutable {
     return crimson::do_for_each(alloc_blocks,
       [this](auto &alloc) {
-      return crimson::do_for_each(alloc.alloc_blk_ids,
+      return crimson::do_for_each(alloc.alloc_blk_ranges,
         [this, &alloc] (auto &range) -> write_ertr::future<> {
         logger().debug("range {} ~ {}", range.first, range.second);
        bitmap_op_types_t op =
          (alloc.op == rbm_alloc_delta_t::op_types_t::SET) ?
          bitmap_op_types_t::ALL_SET :
          bitmap_op_types_t::ALL_CLEAR;
-       return rbm_sync_block_bitmap_by_range(
+       blk_paddr_t addr = convert_paddr_to_blk_paddr(
          range.first,
-         range.first + range.second - 1,
+         super.block_size,
+         super.blocks_per_segment);
+       blk_id_t start = addr / super.block_size;
+       blk_id_t end = start +
+         (round_up_to(range.second, super.block_size)) / super.block_size
+          - 1;
+       return rbm_sync_block_bitmap_by_range(
+         start,
+         end,
          op);
       });
     }).safe_then([this, &alloc_blocks]() mutable {
       int alloc_block_count = 0;
       for (const auto& b : alloc_blocks) {
-       for (interval_set<blk_id_t>::const_iterator r = b.alloc_blk_ids.begin();
-            r != b.alloc_blk_ids.end(); ++r) {
+       for (auto r : b.alloc_blk_ranges) {
          if (b.op == rbm_alloc_delta_t::op_types_t::SET) {
-           alloc_block_count += r.get_len();
+           alloc_block_count +=
+             round_up_to(r.second, super.block_size) / super.block_size;
            logger().debug(" complete alloc block: start {} len {} ",
-                          r.get_start(), r.get_len());
+                          r.first, r.second);
          } else {
-           alloc_block_count -= r.get_len();
-           logger().debug(" complete free block:  start {} len {} ",
-                          r.get_start(), r.get_len());
+           alloc_block_count -=
+             round_up_to(r.second, super.block_size) / super.block_size;
+           logger().debug(" complete alloc block: start {} len {} ",
+                          r.first, r.second);
          }
        }
       }

diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h
index b7b521eb9b8b2dce13ad293a6c273b5f74af5a19..5a186765916168856abbbee542a4bd1aca92f7b9 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.h
+++ b/src/crimson/os/seastore/seastore_types.h
@@ -1069,12 +1069,21 @@ constexpr blk_id_t NULL_BLK_ID =
 using blk_paddr_t = uint64_t;
 struct rbm_alloc_delta_t {
   enum class op_types_t : uint8_t {
+    NONE = 0,
     SET = 1,
     CLEAR = 2
   };
-  extent_types_t type;
-  interval_set<blk_id_t> alloc_blk_ids;
-  op_types_t op;
+  std::vector<std::pair<paddr_t, size_t>> alloc_blk_ranges;
+  op_types_t op = op_types_t::NONE;
+
+  rbm_alloc_delta_t() = default;
+
+  DENC(rbm_alloc_delta_t, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.alloc_blk_ranges, p);
+    denc(v.op, p);
+    DENC_FINISH(p);
+  }
 };
 
 paddr_t convert_blk_paddr_to_paddr(blk_paddr_t addr, size_t block_size,

diff --git a/src/test/crimson/seastore/test_randomblock_manager.cc b/src/test/crimson/seastore/test_randomblock_manager.cc
index b92ae3444aa1591bfec481e10b03b7f6ee31837f..563db420e205a39759fea4bc075a3b208d80adfe 100644 (file)
--- a/src/test/crimson/seastore/test_randomblock_manager.cc
+++ b/src/test/crimson/seastore/test_randomblock_manager.cc
@@ -113,11 +113,17 @@ struct rbm_test_t : public  seastar_test_suite_t,
     auto tt = create_mutate_transaction(); // dummy transaction
     auto extent = rbm_manager->find_free_block(*tt, size).unsafe_get0();
     if (!extent.empty()) {
-      rbm_alloc_delta_t alloc_info {
-       extent_types_t::RBM_ALLOC_INFO,
-         extent,
-         rbm_alloc_delta_t::op_types_t::SET
-      };
+      rbm_alloc_delta_t alloc_info;
+      for (auto p : extent) {
+       paddr_t paddr = convert_blk_paddr_to_paddr(
+           p.first * block_size,
+           block_size,
+           config.blocks_per_segment,
+           0);
+       size_t len = p.second * block_size;
+       alloc_info.alloc_blk_ranges.push_back(std::make_pair(paddr, len));
+       alloc_info.op = rbm_alloc_delta_t::op_types_t::SET;
+      }
       t.add_rbm_allocated_blocks(alloc_info);
     }
   }
@@ -135,7 +141,14 @@ struct rbm_test_t : public  seastar_test_suite_t,
     auto allocated_blocks = t.get_rbm_allocated_blocks();
     interval_set<blk_id_t> alloc_ids;
     for (auto p : allocated_blocks) {
-      alloc_ids.insert(p.alloc_blk_ids);
+      for (auto b : p.alloc_blk_ranges) {
+       blk_paddr_t addr =
+         convert_paddr_to_blk_paddr(
+           b.first,
+           block_size,
+           config.blocks_per_segment);
+       alloc_ids.insert(addr / block_size, b.second / block_size);
+      }
     }
     logger().debug(" get allocated blockid {}", alloc_ids);
     return alloc_ids;