Merge pull request ceph#61771 from aainscow/new_io_sequencer_sequences

test: Add new sequences to the IO sequencer.

Author: aainscow

src/common/io_exerciser/DataGenerator.cc

@@ -56,28 +56,32 @@ bool DataGenerator::validate(bufferlist& bufferlist, uint64_t offset,
 ceph::bufferptr SeededRandomGenerator::generate_block(uint64_t block_offset) {
   uint64_t block_size = m_model.get_block_size();
   char buffer[block_size];
+  SeedBytes seed = m_model.get_seed(block_offset);
+  if (seed != 0) {
+    std::mt19937_64 random_generator(seed);
+    uint64_t rand1 = random_generator();
+    uint64_t rand2 = random_generator();
 
-  std::mt19937_64 random_generator(m_model.get_seed(block_offset));
-  uint64_t rand1 = random_generator();
-  uint64_t rand2 = random_generator();
-
-  constexpr size_t generation_length = sizeof(uint64_t);
+    constexpr size_t generation_length = sizeof(uint64_t);
 
-  for (uint64_t i = 0; i < block_size;
-       i += (2 * generation_length), rand1++, rand2--) {
-    std::memcpy(buffer + i, &rand1, generation_length);
-    std::memcpy(buffer + i + generation_length, &rand2, generation_length);
-  }
+    for (uint64_t i = 0; i < block_size;
+         i += (2 * generation_length), rand1++, rand2--) {
+      std::memcpy(buffer + i, &rand1, generation_length);
+      std::memcpy(buffer + i + generation_length, &rand2, generation_length);
+    }
 
-  size_t remainingBytes = block_size % (generation_length * 2);
-  if (remainingBytes > generation_length) {
-    size_t remainingBytes2 = remainingBytes - generation_length;
-    std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
-    std::memcpy(buffer + block_size - remainingBytes2, &rand2, remainingBytes2);
-  } else if (remainingBytes > 0) {
-    std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
+    size_t remainingBytes = block_size % (generation_length * 2);
+    if (remainingBytes > generation_length) {
+      size_t remainingBytes2 = remainingBytes - generation_length;
+      std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
+      std::memcpy(buffer + block_size - remainingBytes2, &rand2,
+                  remainingBytes2);
+    } else if (remainingBytes > 0) {
+      std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
+    }
+  } else {
+    std::memset(buffer, 0, block_size);
   }
-
   return ceph::bufferptr(buffer, block_size);
 }
 
@@ -159,10 +163,12 @@ ceph::bufferptr HeaderedSeededRandomGenerator::generate_block(
   ceph::bufferptr bufferptr =
       SeededRandomGenerator::generate_block(block_offset);
 
-  std::memcpy(bufferptr.c_str() + uniqueIdStart(), &unique_run_id,
-              uniqueIdLength());
-  std::memcpy(bufferptr.c_str() + seedStart(), &seed, seedLength());
-  std::memcpy(bufferptr.c_str() + timeStart(), &current_time, timeLength());
+  if (seed != 0) {
+    std::memcpy(bufferptr.c_str() + uniqueIdStart(), &unique_run_id,
+                uniqueIdLength());
+    std::memcpy(bufferptr.c_str() + seedStart(), &seed, seedLength());
+    std::memcpy(bufferptr.c_str() + timeStart(), &current_time, timeLength());
+  }
 
   return bufferptr;
 }
@@ -650,4 +656,4 @@ void HeaderedSeededRandomGenerator ::printDebugInformationForOffsets(
     printDebugInformationForRange(read_offset, range_start, range_length,
                                   rangeError, bufferlist);
   }
-}
+}

src/common/io_exerciser/DataGenerator.h

@@ -51,6 +51,8 @@ class DataGenerator {
   // Used for testing debug outputs from data generation
   virtual bufferlist generate_wrong_data(uint64_t offset, uint64_t length);
 
+  using SeedBytes = int;
+
  protected:
   const ObjectModel& m_model;
 

src/common/io_exerciser/EcIoSequence.cc

@@ -33,6 +33,14 @@ 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:
+      [[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:
@@ -264,4 +272,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/IoOp.cc

@@ -19,6 +19,8 @@ using TripleWriteOp = ceph::io_exerciser::TripleWriteOp;
 using SingleFailedWriteOp = ceph::io_exerciser::SingleFailedWriteOp;
 using DoubleFailedWriteOp = ceph::io_exerciser::DoubleFailedWriteOp;
 using TripleFailedWriteOp = ceph::io_exerciser::TripleFailedWriteOp;
+using SingleAppendOp = ceph::io_exerciser::SingleAppendOp;
+using TruncateOp = ceph::io_exerciser::TruncateOp;
 
 namespace {
 std::string value_to_string(uint64_t v) {
@@ -100,16 +102,21 @@ template <OpType opType, int numIOs>
 std::string ceph::io_exerciser::ReadWriteOp<opType, numIOs>::to_string(
     uint64_t block_size) const {
   std::string offset_length_desc;
+  std::string length_desc;
   if (numIOs > 0) {
     offset_length_desc += fmt::format(
         "offset1={}", value_to_string(this->offset[0] * block_size));
-    offset_length_desc += fmt::format(
-        ",length1={}", value_to_string(this->length[0] * block_size));
+    length_desc += fmt::format("length1={}",
+                               value_to_string(this->length[0] * block_size));
+    offset_length_desc += "," + length_desc;
     for (int i = 1; i < numIOs; i++) {
+      std::string length;
       offset_length_desc += fmt::format(
           ",offset{}={}", i + 1, value_to_string(this->offset[i] * block_size));
-      offset_length_desc += fmt::format(
-          ",length{}={}", i + 1, value_to_string(this->length[i] * block_size));
+      length += fmt::format(",length{}={}", i + 1,
+                            value_to_string(this->length[i] * block_size));
+      length_desc += length;
+      offset_length_desc += length;
     }
   }
   switch (opType) {
@@ -125,6 +132,8 @@ std::string ceph::io_exerciser::ReadWriteOp<opType, numIOs>::to_string(
       [[fallthrough]];
     case OpType::Write3:
       return fmt::format("Write{} ({})", numIOs, offset_length_desc);
+    case OpType::Append:
+      return fmt::format("Append{} ({})", numIOs, length_desc);
     case OpType::FailedWrite:
       [[fallthrough]];
     case OpType::FailedWrite2:
@@ -200,6 +209,24 @@ std::unique_ptr<TripleWriteOp> TripleWriteOp::generate(
                                          offset3, length3);
 }
 
+SingleAppendOp::SingleAppendOp(uint64_t length)
+    : ReadWriteOp<OpType::Append, 1>({0}, {length}) {}
+
+std::unique_ptr<SingleAppendOp> SingleAppendOp::generate(uint64_t length) {
+  return std::make_unique<SingleAppendOp>(length);
+}
+
+TruncateOp::TruncateOp(uint64_t size)
+    : TestOp<OpType::Truncate>(), size(size) {}
+
+std::unique_ptr<TruncateOp> TruncateOp::generate(uint64_t size) {
+  return std::make_unique<TruncateOp>(size);
+}
+
+std::string TruncateOp::to_string(uint64_t block_size) const {
+  return "Truncate (size=" + value_to_string(size * block_size) + ")";
+}
+
 SingleFailedWriteOp::SingleFailedWriteOp(uint64_t offset, uint64_t length)
     : ReadWriteOp<OpType::FailedWrite, 1>({offset}, {length}) {}
 
@@ -313,4 +340,4 @@ std::unique_ptr<ceph::io_exerciser::ClearWriteErrorInjectOp>
 ceph::io_exerciser ::ClearWriteErrorInjectOp::generate(
     int shard, const std::optional<uint64_t>& type) {
   return std::make_unique<ClearWriteErrorInjectOp>(shard, type);
-}
+}

src/common/io_exerciser/IoOp.h

@@ -125,6 +125,20 @@ class TripleWriteOp : public ReadWriteOp<OpType::Write3, 3> {
       uint64_t offset3, uint64_t length3);
 };
 
+class SingleAppendOp : public ReadWriteOp<OpType::Append, 1> {
+ public:
+  SingleAppendOp(uint64_t length);
+  static std::unique_ptr<SingleAppendOp> generate(uint64_t length);
+};
+
+class TruncateOp : public TestOp<OpType::Truncate> {
+ public:
+  TruncateOp(uint64_t size);
+  static std::unique_ptr<TruncateOp> generate(uint64_t size);
+  std::string to_string(uint64_t block_size) const override;
+  uint64_t size;
+};
+
 class SingleFailedWriteOp : public ReadWriteOp<OpType::FailedWrite, 1> {
  public:
   SingleFailedWriteOp(uint64_t offset, uint64_t length);