test/crimsons/seastore/object_data_handler: add overwrite test cases

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

diff --git a/src/test/crimson/seastore/test_object_data_handler.cc b/src/test/crimson/seastore/test_object_data_handler.cc
index 47607643946ec38bd40de45a0e07f63d4d6755ef..ae44cb94a62d79bd8cc91a20d218fa08045317f5 100644 (file)
--- a/src/test/crimson/seastore/test_object_data_handler.cc
+++ b/src/test/crimson/seastore/test_object_data_handler.cc
@@ -127,14 +127,19 @@ struct object_data_handler_test_t:
        offset,
        len));
     with_trans_intr(t, [&](auto &t) {
-      return ObjectDataHandler(MAX_OBJECT_SIZE).write(
-        ObjectDataHandler::context_t{
-          *tm,
-          t,
-          *onode,
-        },
-        offset,
-        bl);
+      return seastar::do_with(
+       std::move(bl),
+       ObjectDataHandler(MAX_OBJECT_SIZE),
+       [=, this, &t](auto &bl, auto &objhandler) {
+         return objhandler.write(
+           ObjectDataHandler::context_t{
+             *tm,
+             t,
+             *onode,
+           },
+           offset,
+           bl);
+       });
     }).unsafe_get0();
   }
   void write(objaddr_t offset, extent_len_t len, char fill) {
@@ -150,13 +155,17 @@ struct object_data_handler_test_t:
        0,
        size - offset);
       with_trans_intr(t, [&](auto &t) {
-        return ObjectDataHandler(MAX_OBJECT_SIZE).truncate(
-          ObjectDataHandler::context_t{
-            *tm,
-            t,
-            *onode
-          },
-          offset);
+      return seastar::do_with(
+       ObjectDataHandler(MAX_OBJECT_SIZE),
+       [=, this, &t](auto &objhandler) {
+         return objhandler.truncate(
+           ObjectDataHandler::context_t{
+             *tm,
+             t,
+             *onode
+           },
+           offset);
+       });
       }).unsafe_get0();
     }
     size = offset;
@@ -222,21 +231,15 @@ struct object_data_handler_test_t:
     size = 0;
     return tm_teardown();
   }
-};
 
-TEST_P(object_data_handler_test_t, single_write)
-{
-  run_async([this] {
-    write(1<<20, 8<<10, 'c');
-
-    read_near(1<<20, 8<<10, 1);
-    read_near(1<<20, 8<<10, 512);
-  });
-}
+  void set_overwrite_threshold() {
+    crimson::common::local_conf().set_val("seastore_data_delta_based_overwrite", "131072").get();
+  }
+  void unset_overwrite_threshold() {
+    crimson::common::local_conf().set_val("seastore_data_delta_based_overwrite", "0").get();
+  }
 
-TEST_P(object_data_handler_test_t, multi_write)
-{
-  run_async([this] {
+  void test_multi_write() {
     write((1<<20) - (4<<10), 4<<10, 'a');
     write(1<<20, 4<<10, 'b');
     write((1<<20) + (4<<10), 4<<10, 'c');
@@ -246,12 +249,9 @@ TEST_P(object_data_handler_test_t, multi_write)
 
     read_near((1<<20)-(4<<10), 12<<10, 1);
     read_near((1<<20)-(4<<10), 12<<10, 512);
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, write_hole)
-{
-  run_async([this] {
+  void test_write_hole() {
     write((1<<20) - (4<<10), 4<<10, 'a');
     // hole at 1<<20
     write((1<<20) + (4<<10), 4<<10, 'c');
@@ -261,23 +261,17 @@ TEST_P(object_data_handler_test_t, write_hole)
 
     read_near((1<<20)-(4<<10), 12<<10, 1);
     read_near((1<<20)-(4<<10), 12<<10, 512);
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, overwrite_single)
-{
-  run_async([this] {
+  void test_overwrite_single() {
     write((1<<20), 4<<10, 'a');
     write((1<<20), 4<<10, 'c');
 
     read_near(1<<20, 4<<10, 1);
     read_near(1<<20, 4<<10, 512);
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, overwrite_double)
-{
-  run_async([this] {
+  void test_overwrite_double() {
     write((1<<20), 4<<10, 'a');
     write((1<<20)+(4<<10), 4<<10, 'c');
     write((1<<20), 8<<10, 'b');
@@ -290,12 +284,9 @@ TEST_P(object_data_handler_test_t, overwrite_double)
 
     read_near((1<<20) + (4<<10), 4<<10, 1);
     read_near((1<<20) + (4<<10), 4<<10, 512);
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, overwrite_partial)
-{
-  run_async([this] {
+  void test_overwrite_partial() {
     write((1<<20), 12<<10, 'a');
     read_near(1<<20, 12<<10, 1);
 
@@ -315,12 +306,9 @@ TEST_P(object_data_handler_test_t, overwrite_partial)
 
     read_near((1<<20) + (4<<10), 4<<10, 1);
     read_near((1<<20) + (4<<10), 4<<10, 512);
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, unaligned_write)
-{
-  run_async([this] {
+  void test_unaligned_write() {
     objaddr_t base = 1<<20;
     write(base, (4<<10)+(1<<10), 'a');
     read_near(base-(4<<10), 12<<10, 512);
@@ -332,12 +320,9 @@ TEST_P(object_data_handler_test_t, unaligned_write)
     base = (1<<20) + (128<<10);
     write(base-(1<<10), (4<<10)+(2<<20), 'c');
     read_near(base-(4<<10), 12<<10, 512);
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, unaligned_overwrite)
-{
-  run_async([this] {
+  void test_unaligned_overwrite() {
     objaddr_t base = 1<<20;
     write(base, (128<<10) + (16<<10), 'x');
 
@@ -353,12 +338,9 @@ TEST_P(object_data_handler_test_t, unaligned_overwrite)
     read_near(base-(4<<10), 12<<10, 2<<10);
 
     read(base, (128<<10) + (16<<10));
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, truncate)
-{
-  run_async([this] {
+  void test_truncate() {
     objaddr_t base = 1<<20;
     write(base, 8<<10, 'a');
     write(base+(8<<10), 8<<10, 'b');
@@ -375,11 +357,9 @@ TEST_P(object_data_handler_test_t, truncate)
 
     truncate(base - (12<<10));
     read(base, 64<<10);
-  });
-}
+  }
 
-TEST_P(object_data_handler_test_t, no_split) {
-  run_async([this] {
+  void write_same() {
     write(0, 8<<10, 'x');
     write(0, 8<<10, 'a');
 
@@ -387,14 +367,197 @@ TEST_P(object_data_handler_test_t, no_split) {
     EXPECT_EQ(pins.size(), 1);
 
     read(0, 8<<10);
+  }
+
+  void write_right() {
+    write(0, 128<<10, 'x');
+    write(64<<10, 60<<10, 'a');
+  }
+
+  void write_left() {
+    write(0, 128<<10, 'x');
+    write(4<<10, 60<<10, 'a');
+  }
+
+  void write_right_left() {
+    write(0, 128<<10, 'x');
+    write(48<<10, 32<<10, 'a');
+  }
+
+  void multiple_write() {
+    write(0, 128<<10, 'x');
+
+    auto t = create_mutate_transaction();
+    // normal split
+    write(*t, 120<<10, 4<<10, 'a');
+    // not aligned right
+    write(*t, 4<<10, 5<<10, 'b');
+    // split right extent of last split result
+    write(*t, 32<<10, 4<<10, 'c');
+    // non aligned overwrite
+    write(*t, 13<<10, 4<<10, 'd');
+
+    write(*t, 64<<10, 32<<10, 'e');
+    // not split right
+    write(*t, 60<<10, 8<<10, 'f');
+
+    submit_transaction(std::move(t));
+  }
+};
+
+TEST_P(object_data_handler_test_t, single_write)
+{
+  run_async([this] {
+    write(1<<20, 8<<10, 'c');
+
+    read_near(1<<20, 8<<10, 1);
+    read_near(1<<20, 8<<10, 512);
   });
 }
 
-TEST_P(object_data_handler_test_t, split_left) {
+TEST_P(object_data_handler_test_t, multi_write)
+{
   run_async([this] {
-    write(0, 128<<10, 'x');
+    test_multi_write();
+  });
+}
 
-    write(64<<10, 60<<10, 'a');
+TEST_P(object_data_handler_test_t, delta_over_multi_write)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_multi_write();
+  });
+}
+
+TEST_P(object_data_handler_test_t, write_hole)
+{
+  run_async([this] {
+    test_write_hole();
+  });
+}
+
+TEST_P(object_data_handler_test_t, delta_over_write_hole)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_write_hole();
+  });
+}
+
+TEST_P(object_data_handler_test_t, overwrite_single)
+{
+  run_async([this] {
+    test_overwrite_single();
+  });
+}
+
+TEST_P(object_data_handler_test_t, delta_over_overwrite_single)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_overwrite_single();
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, overwrite_double)
+{
+  run_async([this] {
+    test_overwrite_double();
+  });
+}
+
+TEST_P(object_data_handler_test_t, delta_over_overwrite_double)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_overwrite_double();
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, overwrite_partial)
+{
+  run_async([this] {
+    test_overwrite_partial();
+  });
+}
+
+TEST_P(object_data_handler_test_t, delta_over_overwrite_partial)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_overwrite_partial();
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, unaligned_write)
+{
+  run_async([this] {
+    test_unaligned_write();
+  });
+}
+
+TEST_P(object_data_handler_test_t, delta_over_unaligned_write)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_unaligned_write();
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, unaligned_overwrite)
+{
+  run_async([this] {
+    test_unaligned_overwrite();
+  });
+}
+
+TEST_P(object_data_handler_test_t, delta_over_unaligned_overwrite)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_unaligned_overwrite();
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, truncate)
+{
+  run_async([this] {
+    test_truncate();
+  });
+}
+
+TEST_P(object_data_handler_test_t, delta_over_truncate)
+{
+  run_async([this] {
+    set_overwrite_threshold();
+    test_truncate();
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, no_remap) {
+  run_async([this] {
+    write_same();
+  });
+}
+
+TEST_P(object_data_handler_test_t, no_overwrite) {
+  run_async([this] {
+    set_overwrite_threshold();
+    write_same();
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, remap_left) {
+  run_async([this] {
+    write_right();
 
     auto pins = get_mappings(0, 128<<10);
     EXPECT_EQ(pins.size(), 2);
@@ -410,10 +573,21 @@ TEST_P(object_data_handler_test_t, split_left) {
   });
 }
 
-TEST_P(object_data_handler_test_t, split_right) {
+TEST_P(object_data_handler_test_t, overwrite_right) {
   run_async([this] {
-    write(0, 128<<10, 'x');
-    write(4<<10, 60<<10, 'a');
+    set_overwrite_threshold();
+    write_right();
+
+    auto pins = get_mappings(0, 128<<10);
+    EXPECT_EQ(pins.size(), 1);
+    read(0, 128<<10);
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, remap_right) {
+  run_async([this] {
+    write_left();
 
     auto pins = get_mappings(0, 128<<10);
     EXPECT_EQ(pins.size(), 2);
@@ -428,10 +602,21 @@ TEST_P(object_data_handler_test_t, split_right) {
     read(0, 128<<10);
   });
 }
-TEST_P(object_data_handler_test_t, split_left_right) {
+
+TEST_P(object_data_handler_test_t, overwrite_left) {
   run_async([this] {
-    write(0, 128<<10, 'x');
-    write(48<<10, 32<<10, 'a');
+    set_overwrite_threshold();
+    write_left();
+    auto pins = get_mappings(0, 128<<10);
+    EXPECT_EQ(pins.size(), 1);
+    read(0, 128<<10);
+    unset_overwrite_threshold();
+  });
+}
+
+TEST_P(object_data_handler_test_t, remap_right_left) {
+  run_async([this] {
+    write_right_left();
 
     auto pins = get_mappings(0, 128<<10);
     EXPECT_EQ(pins.size(), 3);
@@ -445,26 +630,21 @@ TEST_P(object_data_handler_test_t, split_left_right) {
     }
   });
 }
-TEST_P(object_data_handler_test_t, multiple_split) {
-  run_async([this] {
-    write(0, 128<<10, 'x');
-
-    auto t = create_mutate_transaction();
-    // normal split
-    write(*t, 120<<10, 4<<10, 'a');
-    // not aligned right
-    write(*t, 4<<10, 5<<10, 'b');
-    // split right extent of last split result
-    write(*t, 32<<10, 4<<10, 'c');
-    // non aligned overwrite
-    write(*t, 13<<10, 4<<10, 'd');
-
-    write(*t, 64<<10, 32<<10, 'e');
-    // not split right
-    write(*t, 60<<10, 8<<10, 'f');
 
-    submit_transaction(std::move(t));
+TEST_P(object_data_handler_test_t, overwrite_right_left) {
+  run_async([this] {
+    set_overwrite_threshold();
+    write_right_left();
+    auto pins = get_mappings(0, 128<<10);
+    EXPECT_EQ(pins.size(), 1);
+    read(0, 128<<10);
+    unset_overwrite_threshold();
+  });
+}
 
+TEST_P(object_data_handler_test_t, multiple_remap) {
+  run_async([this] {
+    multiple_write();
     auto pins = get_mappings(0, 128<<10);
     EXPECT_EQ(pins.size(), 10);
 
@@ -480,6 +660,17 @@ TEST_P(object_data_handler_test_t, multiple_split) {
   });
 }
 
+TEST_P(object_data_handler_test_t, multiple_overwrite) {
+  run_async([this] {
+    set_overwrite_threshold();
+    multiple_write();
+    auto pins = get_mappings(0, 128<<10);
+    EXPECT_EQ(pins.size(), 1);
+    read(0, 128<<10);
+    unset_overwrite_threshold();
+  });
+}
+
 INSTANTIATE_TEST_SUITE_P(
   object_data_handler_test,
   object_data_handler_test_t,
@@ -488,5 +679,3 @@ INSTANTIATE_TEST_SUITE_P(
     "circularbounded"
   )
 );
-
-