crimson/os/seastore/cbj: rename size-related interfaces with grouping

Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>
Signed-off-by: Myoungwon Oh <myoungwon.oh@samsung.com>

diff --git a/src/crimson/os/seastore/journal/circular_bounded_journal.cc b/src/crimson/os/seastore/journal/circular_bounded_journal.cc
index 241c897e1870eda1695a6b5d8418ba3fb8dd700a..003d6546bce25d20a18152b99f75a54721928723 100644 (file)
--- a/src/crimson/os/seastore/journal/circular_bounded_journal.cc
+++ b/src/crimson/os/seastore/journal/circular_bounded_journal.cc
@@ -56,7 +56,7 @@ CircularBoundedJournal::open_for_mkfs()
   head.dirty_tail =
     journal_seq_t{0,
       convert_abs_addr_to_paddr(
-       get_start_addr(),
+       get_records_start(),
        device->get_device_id())};
   head.alloc_tail = head.dirty_tail;
   encode(head, bl);
@@ -112,21 +112,21 @@ CircularBoundedJournal::submit_record_ret CircularBoundedJournal::submit_record(
   assert(written_to.segment_seq != NULL_SEG_SEQ);
   auto r_size = record_group_size_t(record.size, get_block_size());
   auto encoded_size = r_size.get_encoded_length();
-  if (encoded_size > get_available_size()) {
+  if (encoded_size > get_records_available_size()) {
     ERROR("record size {}, but available size {}",
-          encoded_size, get_available_size());
+          encoded_size, get_records_available_size());
     return crimson::ct_error::erange::make();
   }
   if (encoded_size + get_rbm_addr(get_written_to()) > get_journal_end()) {
     DEBUG("roll");
     paddr_t paddr = convert_abs_addr_to_paddr(
-      get_start_addr(),
+      get_records_start(),
       get_device_id());
     set_written_to(
       journal_seq_t{++written_to.segment_seq, paddr});
-    if (encoded_size > get_available_size()) {
+    if (encoded_size > get_records_available_size()) {
       ERROR("rolled, record size {}, but available size {}",
-            encoded_size, get_available_size());
+            encoded_size, get_records_available_size());
       return crimson::ct_error::erange::make();
     }
   }
@@ -142,7 +142,7 @@ CircularBoundedJournal::submit_record_ret CircularBoundedJournal::submit_record(
     assert(new_written_to == get_journal_end());
     DEBUG("roll");
     paddr_t paddr = convert_abs_addr_to_paddr(
-      get_start_addr(),
+      get_records_start(),
       get_device_id());
     set_written_to(
       journal_seq_t{++written_to.segment_seq, paddr});
@@ -171,7 +171,7 @@ CircularBoundedJournal::submit_record_ret CircularBoundedJournal::submit_record(
     r_size,
     FNAME] {
     DEBUG("commit target {} used_size {} written length {}",
-          target, get_used_size(), length);
+          target, get_records_used_size(), length);
 
     paddr_t paddr = convert_abs_addr_to_paddr(
       target + r_size.get_mdlength(),
@@ -287,7 +287,7 @@ Journal::replay_ret CircularBoundedJournal::replay(
              return replay_ertr::make_ready_future<
                seastar::stop_iteration>(seastar::stop_iteration::yes);
            } else {
-             cursor_addr = get_start_addr();
+             cursor_addr = get_records_start();
              ++expected_seq;
              is_rolled = true;
              return replay_ertr::make_ready_future<
@@ -320,7 +320,7 @@ Journal::replay_ret CircularBoundedJournal::replay(
          cursor_addr += bl.length();
          if (cursor_addr >= get_journal_end()) {
            assert(cursor_addr == get_journal_end());
-           cursor_addr = get_start_addr();
+           cursor_addr = get_records_start();
            ++expected_seq;
            is_rolled = true;
          }

diff --git a/src/crimson/os/seastore/journal/circular_bounded_journal.h b/src/crimson/os/seastore/journal/circular_bounded_journal.h
index 34cd1268ebf4511ed7d08dc1d8636ec657677c60..e6f8f23556108be07aedfaa6082d4949c665efeb 100644 (file)
--- a/src/crimson/os/seastore/journal/circular_bounded_journal.h
+++ b/src/crimson/os/seastore/journal/circular_bounded_journal.h
@@ -181,26 +181,6 @@ public:
    *
    */
 
-  size_t get_used_size() const {
-    auto rbm_written_to = get_rbm_addr(get_written_to());
-    auto rbm_tail = get_rbm_addr(get_dirty_tail());
-    return rbm_written_to >= rbm_tail ?
-      rbm_written_to - rbm_tail :
-      rbm_written_to + get_total_size() + get_block_size()
-      - rbm_tail;
-  }
-  size_t get_total_size() const {
-    assert(device);
-    return device->get_journal_size() - get_block_size();
-  }
-  rbm_abs_addr get_start_addr() const {
-    assert(device);
-    return device->get_journal_start() + get_block_size();
-  }
-  size_t get_available_size() const {
-    return get_total_size() - get_used_size();
-  }
-
   seastar::future<> update_journal_tail(
     journal_seq_t dirty,
     journal_seq_t alloc) {
@@ -235,7 +215,7 @@ public:
   }
   void set_written_to(journal_seq_t seq) {
     rbm_abs_addr addr = convert_paddr_to_abs_addr(seq.offset);
-    assert(addr >= get_start_addr());
+    assert(addr >= get_records_start());
     assert(addr < get_journal_end());
     written_to = seq;
   }
@@ -246,10 +226,46 @@ public:
     assert(device);
     return device->get_block_size();
   }
+
+  /* 
+    Size-related interfaces
+     +---------------------------------------------------------+
+     |   header      | record | record | record | record | ... | 
+     +---------------------------------------------------------+
+     ^               ^                                         ^
+     |               |                                         |
+   get_journal_start |                                     get_journal_end
+              get_records_start
+                     <-- get_records_total_size + block_size -->
+     <--------------- get_journal_size ------------------------>
+  */
+
+  size_t get_records_used_size() const {
+    auto rbm_written_to = get_rbm_addr(get_written_to());
+    auto rbm_tail = get_rbm_addr(get_dirty_tail());
+    return rbm_written_to >= rbm_tail ?
+      rbm_written_to - rbm_tail :
+      rbm_written_to + get_records_total_size() + get_block_size()
+      - rbm_tail;
+  }
+  size_t get_records_total_size() const {
+    assert(device);
+    // a block is for header and a block is reserved to denote the end
+    return device->get_journal_size() - (2 * get_block_size());
+  }
+  rbm_abs_addr get_records_start() const {
+    assert(device);
+    return device->get_journal_start() + get_block_size();
+  }
+  size_t get_records_available_size() const {
+    return get_records_total_size() - get_records_used_size();
+  }
   rbm_abs_addr get_journal_end() const {
-    return get_start_addr() + get_total_size() + get_block_size(); // journal size + header length
+    assert(device);
+    return device->get_journal_start() + device->get_journal_size();
   }
   seastar::future<> finish_commit(transaction_type_t type) final;
+
 private:
   cbj_header_t header;
   JournalTrimmer &trimmer;
@@ -265,7 +281,7 @@ private:
   bool initialized = false;
 
   // start address where the newest record will be written
-  // should be in range [get_start_addr(), get_journal_end())
+  // should be in range [get_records_start(), get_journal_end())
   // written_to.segment_seq is circulation seq to track 
   // the sequence to written records
   journal_seq_t written_to;

diff --git a/src/crimson/os/seastore/random_block_manager/rbm_device.h b/src/crimson/os/seastore/random_block_manager/rbm_device.h
index b6425f26487cf604d7cb1625d5e239be8ab60fb0..8e32238da49896935c9d67db63cc92238ecc8046 100644 (file)
--- a/src/crimson/os/seastore/random_block_manager/rbm_device.h
+++ b/src/crimson/os/seastore/random_block_manager/rbm_device.h
@@ -169,7 +169,7 @@ public:
   }
 
   void set_journal_size(uint64_t size) {
-    super.journal_size = size;
+    super.journal_size = size + get_block_size();
   }
 
   static rbm_abs_addr get_journal_start() {

diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc
index 32143ef555599cb09f87194fa021c1b02555f1ba..29d2c4873a0e67af4b3e744c388a65d579221f3c 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.cc
+++ b/src/crimson/os/seastore/transaction_manager.cc
@@ -649,8 +649,8 @@ TransactionManagerRef make_transaction_manager(
     roll_start = 0;
   } else {
     roll_size = static_cast<random_block_device::RBMDevice*>(primary_device)
-               ->get_journal_size();
-    // see CircularBoundedJournal::get_start_addr()
+               ->get_journal_size() - primary_device->get_block_size();
+    // see CircularBoundedJournal::get_records_start()
     roll_start = static_cast<random_block_device::RBMDevice*>(primary_device)
                 ->get_journal_start() + primary_device->get_block_size();
     ceph_assert_always(roll_size <= DEVICE_OFF_MAX);

diff --git a/src/test/crimson/seastore/test_cbjournal.cc b/src/test/crimson/seastore/test_cbjournal.cc
index 5f13739976c79bb8956fa6220c2d0e5880e61573..62465e8a504b6d41d7cbebe55ad1f502efdb5aff 100644 (file)
--- a/src/test/crimson/seastore/test_cbjournal.cc
+++ b/src/test/crimson/seastore/test_cbjournal.cc
@@ -260,11 +260,11 @@ struct cbjournal_test_t : public seastar_test_suite_t, JournalTrimmer
       return seastar::now();
     }).unsafe_get0();
   }
-  auto get_available_size() {
-    return cbj->get_available_size();
+  auto get_records_available_size() {
+    return cbj->get_records_available_size();
   }
-  auto get_total_size() {
-    return cbj->get_total_size();
+  auto get_records_total_size() {
+    return cbj->get_records_total_size();
   }
   auto get_block_size() {
     return device->get_block_size();
@@ -278,8 +278,8 @@ struct cbjournal_test_t : public seastar_test_suite_t, JournalTrimmer
   auto get_journal_tail() {
     return cbj->get_dirty_tail();
   }
-  auto get_used_size() {
-    return cbj->get_used_size();
+  auto get_records_used_size() {
+    return cbj->get_records_used_size();
   }
   void update_journal_tail(rbm_abs_addr addr, uint32_t len) {
     paddr_t paddr =
@@ -348,7 +348,7 @@ TEST_F(cbjournal_test_t, submit_full_records)
     auto record_total_size = r_size.get_encoded_length();
 
     submit_record(std::move(rec));
-    while (record_total_size <= get_available_size()) {
+    while (record_total_size <= get_records_available_size()) {
      submit_record(
        record_t {
        { generate_extent(1), generate_extent(2) },
@@ -356,10 +356,10 @@ TEST_F(cbjournal_test_t, submit_full_records)
        });
     }
 
-    uint64_t avail = get_available_size();
+    uint64_t avail = get_records_available_size();
     update_journal_tail(entries.back().addr, record_total_size);
-    ASSERT_EQ(get_total_size(),
-            get_available_size());
+    ASSERT_EQ(get_records_total_size(),
+            get_records_available_size());
 
     // will be appended at the begining of log
     submit_record(
@@ -368,14 +368,14 @@ TEST_F(cbjournal_test_t, submit_full_records)
       { generate_delta(20), generate_delta(21) }
       });
 
-    while (record_total_size <= get_available_size()) {
+    while (record_total_size <= get_records_available_size()) {
      submit_record(
        record_t {
        { generate_extent(1), generate_extent(2) },
        { generate_delta(20), generate_delta(21) }
        });
     }
-    ASSERT_EQ(avail, get_available_size());
+    ASSERT_EQ(avail, get_records_available_size());
   });
 }
 
@@ -391,7 +391,7 @@ TEST_F(cbjournal_test_t, boudary_check_verify)
     auto r_size = record_group_size_t(rec.size, block_size);
     auto record_total_size = r_size.get_encoded_length();
     submit_record(std::move(rec));
-    while (record_total_size <= get_available_size()) {
+    while (record_total_size <= get_records_available_size()) {
      submit_record(
        record_t {
        { generate_extent(1), generate_extent(2) },
@@ -399,18 +399,18 @@ TEST_F(cbjournal_test_t, boudary_check_verify)
        });
     }
 
-    uint64_t avail = get_available_size();
+    uint64_t avail = get_records_available_size();
     update_journal_tail(entries.front().addr, record_total_size);
     entries.erase(entries.begin());
-    ASSERT_EQ(avail + record_total_size, get_available_size());
-    avail = get_available_size();
+    ASSERT_EQ(avail + record_total_size, get_records_available_size());
+    avail = get_records_available_size();
     // will be appended at the begining of WAL
     submit_record(
      record_t {
       { generate_extent(1), generate_extent(2) },
       { generate_delta(20), generate_delta(21) }
       });
-    ASSERT_EQ(avail - record_total_size, get_available_size());
+    ASSERT_EQ(avail - record_total_size, get_records_available_size());
     replay_and_check();
   });
 }
@@ -451,7 +451,7 @@ TEST_F(cbjournal_test_t, replay)
     auto r_size = record_group_size_t(rec.size, block_size);
     auto record_total_size = r_size.get_encoded_length();
     submit_record(std::move(rec));
-    while (record_total_size <= get_available_size()) {
+    while (record_total_size <= get_records_available_size()) {
     submit_record(
       record_t {
        { generate_extent(1), generate_extent(2) },
@@ -459,17 +459,17 @@ TEST_F(cbjournal_test_t, replay)
        });
     }
     // will be appended at the begining of WAL
-    uint64_t avail = get_available_size();
+    uint64_t avail = get_records_available_size();
     update_journal_tail(entries.front().addr, record_total_size);
     entries.erase(entries.begin());
-    ASSERT_EQ(avail + record_total_size, get_available_size());
-    avail = get_available_size();
+    ASSERT_EQ(avail + record_total_size, get_records_available_size());
+    avail = get_records_available_size();
     submit_record(
       record_t {
        { generate_extent(1), generate_extent(2) },
        { generate_delta(20), generate_delta(21) }
        });
-    ASSERT_EQ(avail - record_total_size, get_available_size());
+    ASSERT_EQ(avail - record_total_size, get_records_available_size());
     cbj->close().unsafe_get0();
     replay();
   });
@@ -487,7 +487,7 @@ TEST_F(cbjournal_test_t, replay_after_reset)
     auto r_size = record_group_size_t(rec.size, block_size);
     auto record_total_size = r_size.get_encoded_length();
     submit_record(std::move(rec));
-    while (record_total_size <= get_available_size()) {
+    while (record_total_size <= get_records_available_size()) {
     submit_record(
       record_t {
        { generate_extent(1), generate_extent(2) },
@@ -495,16 +495,16 @@ TEST_F(cbjournal_test_t, replay_after_reset)
        });
     }
     auto old_written_to = get_written_to();
-    auto old_used_size = get_used_size();
+    auto old_used_size = get_records_used_size();
     set_written_to(
       journal_seq_t{0,
        convert_abs_addr_to_paddr(
-         cbj->get_start_addr(),
+         cbj->get_records_start(),
          cbj->get_device_id())});
     cbj->close().unsafe_get0();
     replay();
     ASSERT_EQ(old_written_to, get_written_to());
     ASSERT_EQ(old_used_size,
-      get_used_size());
+      get_records_used_size());
   });
 }