From 1adfe920f288d82f776396f9cca9c70d443cd540 Mon Sep 17 00:00:00 2001
From: Bill Scales <bill_scales@uk.ibm.com>
Date: Mon, 16 Dec 2024 13:03:51 +0000
Subject: [PATCH] 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>
---
 src/common/io_exerciser/EcIoSequence.cc |  2 +
 src/common/io_exerciser/IoSequence.cc   | 72 +++++++++++++++++++++++++
 src/common/io_exerciser/IoSequence.h    | 21 ++++++++
 3 files changed, 95 insertions(+)

diff --git a/src/common/io_exerciser/EcIoSequence.cc b/src/common/io_exerciser/EcIoSequence.cc
index 8eb5e4defcb6f..03732632c7b2c 100644
--- 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 a5d316f5d0c67..2f00f13e6147b 100644
--- 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 28b1618da2bb8..c0680408db134 100644
--- 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
-- 
2.39.5