test: ceph_test_rados_io_sequence append sequences

Sequence 11 - sequential appends of fixed size
Sequence 12 - sequentiial overwrite+append of fixed size and different offsets

Signed-off-by: Bill Scales <[email protected]>

Author: bill-scales

src/common/io_exerciser/EcIoSequence.cc

@@ -33,6 +33,10 @@ std::unique_ptr<IoSequence> EcIoSequence::generate_sequence(
     case Sequence::SEQUENCE_SEQ8:
       [[fallthrough]];
     case Sequence::SEQUENCE_SEQ9:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ11:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ12:
       return std::make_unique<ReadInjectSequence>(obj_size_range, seed,
                                                   sequence, k, m);
     case Sequence::SEQUENCE_SEQ10:
@@ -264,4 +268,4 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq10::_next() {
     ceph_abort_msg("Sequence in undefined state. Aborting");
     return DoneOp::generate();
   }
-}
+}

src/common/io_exerciser/IoSequence.cc

@@ -40,6 +40,12 @@ std::ostream& ceph::io_exerciser::operator<<(std::ostream& os,
     case Sequence::SEQUENCE_SEQ10:
       os << "SEQUENCE_SEQ10";
       break;
+    case Sequence::SEQUENCE_SEQ11:
+      os << "SEQUENCE_SEQ11";
+      break;
+    case Sequence::SEQUENCE_SEQ12:
+      os << "SEQUENCE_SEQ12";
+      break;
     case Sequence::SEQUENCE_END:
       os << "SEQUENCE_END";
       break;
@@ -79,6 +85,10 @@ std::unique_ptr<IoSequence> IoSequence::generate_sequence(
           "Sequence 10 only supported for erasure coded pools "
           "through the EcIoSequence interface");
       return nullptr;
+    case Sequence::SEQUENCE_SEQ11:
+      return std::make_unique<Seq11>(obj_size_range, seed);
+    case Sequence::SEQUENCE_SEQ12:
+      return std::make_unique<Seq12>(obj_size_range, seed);
     default:
       break;
   }
@@ -514,4 +524,73 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq9::_next() {
   doneread = false;
   donebarrier = false;
   return SingleWriteOp::generate(offset, length);
-}
+}
+
+ceph::io_exerciser::Seq11::Seq11(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed),
+      count(0),
+      doneread(false),
+      donebarrier(false) {}
+
+Sequence ceph::io_exerciser::Seq11::get_id() const {
+  return Sequence::SEQUENCE_SEQ11;
+}
+
+std::string ceph::io_exerciser::Seq11::get_name() const {
+  return "Permutations of length sequential append I/O";
+}
+
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq11::_next() {
+  if (count >= 16) {
+    if (!doneread) {
+      if (!donebarrier) {
+        donebarrier = true;
+        return BarrierOp::generate();
+      }
+      doneread = true;
+      return SingleReadOp::generate(0, obj_size * (count + 1));
+    }
+    doneread = false;
+    donebarrier = false;
+    count = 0;
+    return increment_object_size();
+  }
+  count++;
+  return SingleAppendOp::generate(obj_size);
+}
+
+ceph::io_exerciser::Seq12::Seq12(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed), count(0), overlap(1), doneread(false) {}
+
+Sequence ceph::io_exerciser::Seq12::get_id() const {
+  return Sequence::SEQUENCE_SEQ12;
+}
+
+std::string ceph::io_exerciser::Seq12::get_name() const {
+  return "Permutations of length sequential overwrite+append I/O";
+}
+
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq12::_next() {
+  if (count >= 16) {
+    if (!doneread) {
+      doneread = true;
+      return SingleReadOp::generate(0, obj_size * (count + 1));
+    }
+    doneread = false;
+    count = 0;
+    overlap++;
+    if (overlap > obj_size) {
+      overlap = 1;
+      return increment_object_size();
+    } else {
+      create = true;
+      barrier = true;
+      remove = true;
+      return BarrierOp::generate();
+    }
+  }
+  count++;
+  barrier = true;
+  return SingleWriteOp::generate((count * obj_size) - overlap,
+                                 obj_size + overlap);
+}

src/common/io_exerciser/IoSequence.h

@@ -42,6 +42,8 @@ enum class Sequence {
   SEQUENCE_SEQ8,
   SEQUENCE_SEQ9,
   SEQUENCE_SEQ10,
+  SEQUENCE_SEQ11,
+  SEQUENCE_SEQ12,
 
   SEQUENCE_END,
   SEQUENCE_BEGIN = SEQUENCE_SEQ0
@@ -228,9 +230,38 @@ class Seq9 : public IoSequence {
  public:
   Seq9(std::pair<int, int> obj_size_range, int seed);
 
+      Sequence get_id() const override;
+      std::string get_name() const override;
+      std::unique_ptr<IoOp> _next() override;
+    };
+
+class Seq11 : public IoSequence {
+ private:
+  uint64_t count;
+  bool doneread = true;
+  bool donebarrier = false;
+
+ public:
+  Seq11(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+};
+
+class Seq12 : public IoSequence {
+ private:
+  uint64_t count;
+  uint64_t overlap;
+  bool doneread = true;
+  bool donebarrier = false;
+
+ public:
+  Seq12(std::pair<int, int> obj_size_range, int seed);
+
   Sequence get_id() const override;
   std::string get_name() const override;
   std::unique_ptr<IoOp> _next() override;
 };
 }  // namespace io_exerciser
-}  // namespace ceph
+}  // namespace ceph