test: ceph_test_rados_io_sequence - seq 14 - write object filling gaps

New sequence - write object initially with gaps and fill in the holes
until the object is fully populated. Permutate the step (gap between
writes), start at randomized offsets to produce gaps at the start of
the object as well as between writes

Signed-off-by: Bill Scales <bill_scales@uk.ibm.com>

diff --git a/src/common/io_exerciser/EcIoSequence.cc b/src/common/io_exerciser/EcIoSequence.cc
index 8eb5e4defcb6f421911c58989e707830c1b51665..03732632c7b2c328ae404381c3230a10958134a8 100644 (file)
--- a/src/common/io_exerciser/EcIoSequence.cc
+++ b/src/common/io_exerciser/EcIoSequence.cc
@@ -39,6 +39,8 @@ std::unique_ptr<IoSequence> EcIoSequence::generate_sequence(
     case Sequence::SEQUENCE_SEQ12:
       [[fallthrough]];
     case Sequence::SEQUENCE_SEQ13:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ14:
       return std::make_unique<ReadInjectSequence>(obj_size_range, seed,
                                                   sequence, k, m);
     case Sequence::SEQUENCE_SEQ10:

diff --git a/src/common/io_exerciser/IoSequence.cc b/src/common/io_exerciser/IoSequence.cc
index a5d316f5d0c677615e2bc9b8f8d71aaaf3579985..2f00f13e6147beaba9f63ffb173cd840f591a010 100644 (file)
--- a/src/common/io_exerciser/IoSequence.cc
+++ b/src/common/io_exerciser/IoSequence.cc
@@ -1,4 +1,5 @@
 #include "IoSequence.h"
+#include <algorithm>
 
 using IoOp = ceph::io_exerciser::IoOp;
 using Sequence = ceph::io_exerciser::Sequence;
@@ -49,6 +50,9 @@ std::ostream& ceph::io_exerciser::operator<<(std::ostream& os,
     case Sequence::SEQUENCE_SEQ13:
       os << "SEQUENCE_SEQ13";
       break;
+    case Sequence::SEQUENCE_SEQ14:
+      os << "SEQUENCE_SEQ14";
+      break;
     case Sequence::SEQUENCE_END:
       os << "SEQUENCE_END";
       break;
@@ -94,6 +98,8 @@ std::unique_ptr<IoSequence> IoSequence::generate_sequence(
       return std::make_unique<Seq12>(obj_size_range, seed);
     case Sequence::SEQUENCE_SEQ13:
       return std::make_unique<Seq13>(obj_size_range, seed);
+    case Sequence::SEQUENCE_SEQ14:
+      return std::make_unique<Seq14>(obj_size_range, seed);
     default:
       break;
   }
@@ -636,3 +642,69 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq13::_next() {
   barrier = true;
   return SingleWriteOp::generate((count * obj_size) + gap, obj_size - gap);
 }
+
+ceph::io_exerciser::Seq14::Seq14(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(std::make_pair(0, obj_size_range.second), seed),
+      offset(0),
+      step(1) {
+  startrng = std::default_random_engine(seed);
+  target_obj_size = std::max(obj_size_range.first, 3);
+  if (target_obj_size > max_obj_size) {
+    done = true;
+  }
+  setup_starts();
+}
+
+void ceph::io_exerciser::Seq14::setup_starts() {
+  starts.resize(step);
+  for (size_t i = 0; i < step; i++) {
+    starts[i] = i;
+  }
+  std::shuffle(std::begin(starts), std::end(starts), startrng);
+  startidx = 0;
+  offset = starts[0];
+}
+
+Sequence ceph::io_exerciser::Seq14::get_id() const {
+  return Sequence::SEQUENCE_SEQ14;
+}
+
+std::string ceph::io_exerciser::Seq14::get_name() const {
+  return "Permutations of gap stepped write I/Os";
+}
+
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq14::_next() {
+  if (offset >= target_obj_size) {
+    if (!doneread) {
+      doneread = true;
+      return SingleReadOp::generate(0, current_size);
+    }
+    doneread = false;
+    startidx++;
+    if (startidx >= starts.size()) {
+      step++;
+      current_size = 0;
+      create = true;
+      barrier = true;
+      remove = true;
+      if (step >= target_obj_size) {
+        step = 1;
+        target_obj_size++;
+        if (target_obj_size > max_obj_size) {
+          done = true;
+        }
+      }
+      setup_starts();
+    } else {
+      offset = starts[startidx];
+    }
+    return BarrierOp::generate();
+  }
+  std::unique_ptr<IoOp> r = SingleWriteOp::generate(offset, 1);
+  current_size = std::max(current_size, offset + 1);
+  offset += step;
+  if (offset >= target_obj_size) {
+    barrier = true;
+  }
+  return r;
+}

diff --git a/src/common/io_exerciser/IoSequence.h b/src/common/io_exerciser/IoSequence.h
index 28b1618da2bb88c36db481fbb8c0082a8781fe46..c0680408db1342e76ba47e384b04bafdf15d4c26 100644 (file)
--- a/src/common/io_exerciser/IoSequence.h
+++ b/src/common/io_exerciser/IoSequence.h
@@ -45,6 +45,7 @@ enum class Sequence {
   SEQUENCE_SEQ11,
   SEQUENCE_SEQ12,
   SEQUENCE_SEQ13,
+  SEQUENCE_SEQ14,
 
   SEQUENCE_END,
   SEQUENCE_BEGIN = SEQUENCE_SEQ0
@@ -279,5 +280,25 @@ class Seq13 : public IoSequence {
   std::string get_name() const override;
   std::unique_ptr<IoOp> _next() override;
 };
+
+class Seq14 : public IoSequence {
+ private:
+  uint64_t offset;
+  uint64_t step;
+  uint64_t target_obj_size;
+  uint64_t current_size = 0;
+  std::default_random_engine startrng;
+  std::vector<uint64_t> starts;
+  size_t startidx;
+  bool doneread = false;
+
+ public:
+  Seq14(std::pair<int, int> obj_size_range, int seed);
+
+  void setup_starts();
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+};
 }  // namespace io_exerciser
 }  // namespace ceph