common/io_exerciser: performance, readability and safety improvements

Removes use of const members to allow possibility of moving.
Changes strings that were passed by value to now be const ref.
Adds readability improvements to shorten repeated use of long namespace names in cpp files.
Use std::generator for initialisation of seeds instead of previous for loop

Signed-off-by: Jon Bailey <jonathan.bailey1@ibm.com>

diff --git a/src/common/io_exerciser/DataGenerator.cc b/src/common/io_exerciser/DataGenerator.cc
index 5bc7302cc85ddd9e5411a912103a0b99ae90eddc..276bdd7bd6c9440b36b33927210d7a0fcc695d05 100644 (file)
--- a/src/common/io_exerciser/DataGenerator.cc
+++ b/src/common/io_exerciser/DataGenerator.cc
@@ -14,16 +14,19 @@
 #define dout_subsys ceph_subsys_rados
 #define dout_context g_ceph_context
 
-std::mutex ceph::io_exerciser::data_generation::DataGenerator
-  ::DataGenerationSingleton::m_mutex;
-ceph::io_exerciser::data_generation::DataGenerator::DataGenerationSingleton
-  ceph::io_exerciser::data_generation::DataGenerator::DataGenerationSingleton::m_singletonInstance =
-    ceph::io_exerciser::data_generation::DataGenerator::DataGenerationSingleton();
-
-std::unique_ptr<ceph::io_exerciser::data_generation::DataGenerator>
-  ceph::io_exerciser::data_generation::DataGenerator::create_generator(
-    ceph::io_exerciser::data_generation::GenerationType generationType,
-    const ObjectModel& model)
+using DataGenerator = ceph::io_exerciser::data_generation::DataGenerator;
+using SeededRandomGenerator = ceph::io_exerciser::data_generation
+                                ::SeededRandomGenerator;
+using HeaderedSeededRandomGenerator = ceph::io_exerciser::data_generation
+                                        ::HeaderedSeededRandomGenerator;
+
+std::mutex DataGenerator::DataGenerationSingleton::m_mutex;
+DataGenerator::DataGenerationSingleton
+  DataGenerator::DataGenerationSingleton::m_singletonInstance =
+    DataGenerator::DataGenerationSingleton();
+
+std::unique_ptr<DataGenerator> DataGenerator::create_generator(
+    GenerationType generationType, const ObjectModel& model)
 {
   switch(generationType)
   {
@@ -38,23 +41,20 @@ std::unique_ptr<ceph::io_exerciser::data_generation::DataGenerator>
   return nullptr;
 }
 
-ceph::io_exerciser::data_generation::DataGenerator
-  ::DataGenerationSingleton::DataGenerationSingleton()
+DataGenerator::DataGenerationSingleton::DataGenerationSingleton()
 {
   m_created = false;
 }
 
-ceph::io_exerciser::data_generation::DataGenerator
-  ::DataGenerationSingleton::DataGenerationSingleton(uint64_t unique_id)
+DataGenerator::DataGenerationSingleton
+  ::DataGenerationSingleton(uint64_t unique_id)
 {
   m_uniqueId = unique_id;
   m_created = true;
 }
 
-const ceph::io_exerciser::data_generation
-  ::DataGenerator::DataGenerationSingleton& 
-  ceph::io_exerciser::data_generation::DataGenerator
-    ::DataGenerationSingleton::createSpecificInstance(uint64_t unique_id)
+const DataGenerator::DataGenerationSingleton& 
+DataGenerator::DataGenerationSingleton::createSpecificInstance(uint64_t unique_id)
 {
   std::scoped_lock lock(m_mutex);
   ceph_assert(!m_singletonInstance.m_created);
@@ -63,9 +63,8 @@ const ceph::io_exerciser::data_generation
   return m_singletonInstance;
 }
 
-const ceph::io_exerciser::data_generation::DataGenerator::DataGenerationSingleton&
-  ceph::io_exerciser::data_generation::DataGenerator
-  ::DataGenerationSingleton::getInstance()
+const DataGenerator::DataGenerationSingleton&
+  DataGenerator::DataGenerationSingleton::getInstance()
 {
   if (!m_singletonInstance.m_created)
   {
@@ -81,15 +80,13 @@ const ceph::io_exerciser::data_generation::DataGenerator::DataGenerationSingleto
   return m_singletonInstance;
 }
 
-const uint64_t ceph::io_exerciser::data_generation::DataGenerator
-  ::DataGenerationSingleton::getUniqueId()
+const uint64_t DataGenerator::DataGenerationSingleton::getUniqueId()
 {
   return getInstance().m_uniqueId;
 }
 
-void ceph::io_exerciser::data_generation
-  ::DataGenerator::generate_wrong_data(uint64_t offset, uint64_t length,
-                                       ceph::bufferlist& retlist)
+void DataGenerator::generate_wrong_data(uint64_t offset, uint64_t length,
+                                        bufferlist& retlist)
 {
   uint64_t block_size = m_model.get_block_size();
   char buffer[block_size];
@@ -102,8 +99,7 @@ void ceph::io_exerciser::data_generation
   }
 }
 
-bool ceph::io_exerciser::data_generation
-  ::DataGenerator::validate(ceph::bufferlist& bufferlist, uint64_t offset, uint64_t length)
+bool DataGenerator::validate(bufferlist& bufferlist, uint64_t offset, uint64_t length)
 {
   ceph::bufferlist comparison_list;
   generate_data(offset, length, comparison_list);
@@ -112,8 +108,7 @@ bool ceph::io_exerciser::data_generation
 
 #include <bitset>
 
-ceph::bufferptr ceph::io_exerciser::data_generation
-  ::SeededRandomGenerator::generate_block(uint64_t block_offset)
+ceph::bufferptr SeededRandomGenerator::generate_block(uint64_t block_offset)
 {
   uint64_t block_size = m_model.get_block_size();
   char buffer[block_size];
@@ -145,8 +140,8 @@ ceph::bufferptr ceph::io_exerciser::data_generation
   return ceph::bufferptr(buffer, block_size);
 }
 
-void ceph::io_exerciser::data_generation
-  ::SeededRandomGenerator::generate_data(uint64_t offset, uint64_t length, ceph::bufferlist& retlist)
+void SeededRandomGenerator::generate_data(uint64_t offset, uint64_t length,
+                                          bufferlist& retlist)
 {
   ceph_assert(retlist.length() == 0);
 
@@ -156,8 +151,7 @@ void ceph::io_exerciser::data_generation
   }
 }
 
-ceph::bufferptr ceph::io_exerciser::data_generation
-  ::HeaderedSeededRandomGenerator::generate_block(uint64_t block_offset)
+ceph::bufferptr HeaderedSeededRandomGenerator::generate_block(uint64_t block_offset)
 {
   UniqueIdBytes unique_run_id = DataGenerator::DataGenerationSingleton::getUniqueId();
   SeedBytes seed = m_model.get_seed(block_offset);
@@ -173,10 +167,9 @@ ceph::bufferptr ceph::io_exerciser::data_generation
   return bufferptr;
 }
 
-void ceph::io_exerciser::data_generation
-  ::HeaderedSeededRandomGenerator::generate_wrong_data(uint64_t offset,
-                                                       uint64_t length,
-                                                       ceph::bufferlist& retlist)
+void HeaderedSeededRandomGenerator::generate_wrong_data(uint64_t offset,
+                                                        uint64_t length,
+                                                        bufferlist& retlist)
 {
   ceph_assert(retlist.length() == 0);
   ceph_assert(m_model.get_block_size() >= headerLength());
@@ -199,10 +192,9 @@ void ceph::io_exerciser::data_generation
   }
 }
 
-const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::UniqueIdBytes
-  ceph::io_exerciser::data_generation
-    ::HeaderedSeededRandomGenerator::readUniqueRunId(uint64_t block_offset,
-                                                     const ceph::bufferlist& bufferlist)
+const HeaderedSeededRandomGenerator::UniqueIdBytes
+  HeaderedSeededRandomGenerator::readUniqueRunId(uint64_t block_offset,
+                                                 const bufferlist& bufferlist)
 {
   UniqueIdBytes read_unique_run_id = 0;
   std::memcpy(&read_unique_run_id,
@@ -211,10 +203,9 @@ const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::Unique
   return read_unique_run_id;
 }
 
-const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::SeedBytes
-  ceph::io_exerciser::data_generation
-    ::HeaderedSeededRandomGenerator::readSeed(uint64_t block_offset,
-                                              const ceph::bufferlist& bufferlist)
+const HeaderedSeededRandomGenerator::SeedBytes
+  HeaderedSeededRandomGenerator::readSeed(uint64_t block_offset,
+                                          const bufferlist& bufferlist)
 {
   SeedBytes read_seed = 0;
   std::memcpy(&read_seed,
@@ -223,10 +214,9 @@ const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::SeedBy
   return read_seed;
 }
 
-const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::TimeBytes
-  ceph::io_exerciser::data_generation
-  ::HeaderedSeededRandomGenerator::readDateTime(uint64_t block_offset,
-                                                const ceph::bufferlist& bufferlist)
+const HeaderedSeededRandomGenerator::TimeBytes
+  HeaderedSeededRandomGenerator::readDateTime(uint64_t block_offset,
+                                              const bufferlist& bufferlist)
 {
   TimeBytes read_time = 0;
   std::memcpy(&read_time,
@@ -235,9 +225,8 @@ const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::TimeBy
   return read_time;
 }
 
-bool ceph::io_exerciser::data_generation
-  ::HeaderedSeededRandomGenerator::validate(ceph::bufferlist& bufferlist,
-                                            uint64_t offset, uint64_t length)
+bool HeaderedSeededRandomGenerator::validate(bufferlist& bufferlist,
+                                             uint64_t offset, uint64_t length)
 {
   std::vector<uint64_t> invalid_block_offsets;
 
@@ -261,9 +250,8 @@ bool ceph::io_exerciser::data_generation
   return invalid_block_offsets.empty();
 }
 
-bool ceph::io_exerciser::data_generation
-  ::HeaderedSeededRandomGenerator::validate_block(uint64_t block_offset,
-                                                  const char* buffer_start)
+bool HeaderedSeededRandomGenerator::validate_block(uint64_t block_offset,
+                                                   const char* buffer_start)
 {
   // We validate the block matches what we generate byte for byte, however we ignore the time section of the header
   ceph::bufferptr bufferptr = generate_block(block_offset);
@@ -274,10 +262,10 @@ bool ceph::io_exerciser::data_generation
   return valid;
 }
  
-const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::ErrorType
-  ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
-    ::getErrorTypeForBlock(uint64_t read_offset, uint64_t block_offset,
-                           const ceph::bufferlist& bufferlist)
+const HeaderedSeededRandomGenerator::ErrorType
+  HeaderedSeededRandomGenerator::getErrorTypeForBlock(uint64_t read_offset,
+                                                      uint64_t block_offset,
+                                                      const bufferlist& bufferlist)
 {
   try
   {
@@ -310,9 +298,9 @@ const ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator::ErrorT
   return ErrorType::UNKNOWN;
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
   ::printDebugInformationForBlock(uint64_t read_offset, uint64_t block_offset,
-                                  const ceph::bufferlist& bufferlist)
+                                  const bufferlist& bufferlist)
 {
   ErrorType blockError = getErrorTypeForBlock(read_offset, block_offset, bufferlist);
 
@@ -432,12 +420,12 @@ void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
   dout(0) << ss.str() << dendl;
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
   ::printDebugInformationForRange(uint64_t read_offset,
                                   uint64_t start_block_offset,
                                   uint64_t range_length_in_blocks,
                                   ErrorType rangeError,
-                                  const ceph::bufferlist& bufferlist)
+                                  const bufferlist& bufferlist)
 {
   switch(rangeError)
   {
@@ -466,11 +454,11 @@ void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
   }
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
   ::printDebugInformationForRunIdMismatchRange(uint64_t read_offset,
                                                uint64_t start_block_offset,
                                                uint64_t range_length_in_blocks,
-                                               const ceph::bufferlist& bufferlist)
+                                               const bufferlist& bufferlist)
 {
   uint64_t range_start = start_block_offset;
   uint64_t range_length = 0;
@@ -533,11 +521,11 @@ void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
   }
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
   ::printDebugInformationForSeedMismatchRange(uint64_t read_offset,
                                               uint64_t start_block_offset,
                                               uint64_t range_length_in_blocks,
-                                              const ceph::bufferlist& bufferlist)
+                                              const bufferlist& bufferlist)
 {
   uint64_t range_start = start_block_offset;
   uint64_t range_length = 0;
@@ -614,11 +602,11 @@ void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
   }
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
 ::printDebugInformationDataBodyMismatchRange(uint64_t read_offset,
                                              uint64_t start_block_offset,
                                              uint64_t range_length_in_blocks,
-                                             const ceph::bufferlist& bufferlist)
+                                             const bufferlist& bufferlist)
 {
   dout(0) << "Data Mismatch detected in blocks "
           << "from " << start_block_offset
@@ -634,11 +622,11 @@ void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
   }
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
   ::printDebugInformationCorruptRange(uint64_t read_offset,
                                       uint64_t start_block_offset,
                                       uint64_t range_length_in_blocks,
-                                      const ceph::bufferlist& bufferlist)
+                                      const bufferlist& bufferlist)
 {
   dout(0) << "Data Mismatch detected in blocks "
   << "from " << start_block_offset 
@@ -653,11 +641,11 @@ void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
   }
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
   ::printDebugInformationDataNotFoundRange(uint64_t read_offset,
                                            uint64_t start_block_offset,
                                            uint64_t range_length_in_blocks,
-                                           const ceph::bufferlist& bufferlist)
+                                           const bufferlist& bufferlist)
 {
   dout(0) << "Data not found for blocks "
           << "from " << start_block_offset
@@ -670,10 +658,10 @@ void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
   }
 }
 
-void ceph::io_exerciser::data_generation::HeaderedSeededRandomGenerator
+void HeaderedSeededRandomGenerator
   ::printDebugInformationForOffsets(uint64_t read_offset,
                                     std::vector<uint64_t> offsets,
-                                    const ceph::bufferlist& bufferlist)
+                                    const bufferlist& bufferlist)
 {
   uint64_t range_start = 0;
   uint64_t range_length = 0;

diff --git a/src/common/io_exerciser/IoOp.cc b/src/common/io_exerciser/IoOp.cc
index ff95368bd11e7fd2af7070075259648dfca3ba6e..6b652e356b6f773f0c09f43a09bce157ea4430fb 100644 (file)
--- a/src/common/io_exerciser/IoOp.cc
+++ b/src/common/io_exerciser/IoOp.cc
@@ -1,9 +1,11 @@
 #include "IoOp.h"
 
-ceph::io_exerciser::IoOp::IoOp( OpType op,
-                          uint64_t offset1, uint64_t length1,
-                          uint64_t offset2, uint64_t length2,
-                          uint64_t offset3, uint64_t length3) :
+using IoOp = ceph::io_exerciser::IoOp;
+
+IoOp::IoOp( OpType op,
+            uint64_t offset1, uint64_t length1,
+            uint64_t offset2, uint64_t length2,
+            uint64_t offset3, uint64_t length3) :
   op(op),
   offset1(offset1), length1(length1),
   offset2(offset2), length2(length2),
@@ -12,7 +14,7 @@ ceph::io_exerciser::IoOp::IoOp( OpType op,
   
 }
 
-std::string ceph::io_exerciser::IoOp::value_to_string(uint64_t v) const
+std::string IoOp::value_to_string(uint64_t v) const
 {
   if (v < 1024 || (v % 1024) != 0) {
     return std::to_string(v);
@@ -23,37 +25,37 @@ std::string ceph::io_exerciser::IoOp::value_to_string(uint64_t v) const
   }
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
+std::unique_ptr<IoOp> IoOp
   ::generate_done() {
 
     return std::make_unique<IoOp>(OpType::Done);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
+std::unique_ptr<IoOp> IoOp
   ::generate_barrier() {
 
   return std::make_unique<IoOp>(OpType::BARRIER);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
+std::unique_ptr<IoOp> IoOp
   ::generate_create(uint64_t size) {
 
   return std::make_unique<IoOp>(OpType::CREATE,0,size);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
+std::unique_ptr<IoOp> IoOp
   ::generate_remove() {
 
   return std::make_unique<IoOp>(OpType::REMOVE);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
+std::unique_ptr<IoOp> IoOp
   ::generate_read(uint64_t offset, uint64_t length) {
 
   return std::make_unique<IoOp>(OpType::READ, offset, length);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
+std::unique_ptr<IoOp> IoOp
   ::generate_read2(uint64_t offset1, uint64_t length1,
                    uint64_t offset2, uint64_t length2) {
 
@@ -68,7 +70,7 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
                                 offset2, length2);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
+std::unique_ptr<IoOp> IoOp
   ::generate_read3(uint64_t offset1, uint64_t length1,
                    uint64_t offset2, uint64_t length2,
                    uint64_t offset3, uint64_t length3) {
@@ -94,16 +96,12 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
                                 offset3, length3);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
-  ::generate_write(uint64_t offset, uint64_t length) {
-
+std::unique_ptr<IoOp> IoOp::generate_write(uint64_t offset, uint64_t length) {
   return std::make_unique<IoOp>(OpType::WRITE, offset, length);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
-  ::generate_write2(uint64_t offset1, uint64_t length1, 
-                    uint64_t offset2, uint64_t length2) {
-
+std::unique_ptr<IoOp> IoOp::generate_write2(uint64_t offset1, uint64_t length1,
+                                            uint64_t offset2, uint64_t length2) {
   if (offset1 < offset2) {
     ceph_assert( offset1 + length1 <= offset2 );
   } else {
@@ -114,11 +112,9 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
                                 offset2, length2);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
-  ::generate_write3(uint64_t offset1, uint64_t length1, 
-                    uint64_t offset2, uint64_t length2,
-                    uint64_t offset3, uint64_t length3) {
-
+std::unique_ptr<IoOp> IoOp::generate_write3(uint64_t offset1, uint64_t length1, 
+                                            uint64_t offset2, uint64_t length2,
+                                            uint64_t offset3, uint64_t length3) {
   if (offset1 < offset2) {
     ceph_assert( offset1 + length1 <= offset2 );
   } else {
@@ -140,11 +136,11 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoOp
                                 offset3, length3);
 }
 
-bool ceph::io_exerciser::IoOp::done() {
+bool IoOp::done() {
   return (op == OpType::Done);
 }
 
-std::string ceph::io_exerciser::IoOp::to_string(uint64_t block_size) const
+std::string IoOp::to_string(uint64_t block_size) const
 {
   switch (op) {
   case OpType::Done:

diff --git a/src/common/io_exerciser/IoSequence.cc b/src/common/io_exerciser/IoSequence.cc
index fb413bfb4906f776867c40ec12ffbff7ad048a03..716752c53c28baa83185fa3c40d71487ab51a9eb 100644 (file)
--- a/src/common/io_exerciser/IoSequence.cc
+++ b/src/common/io_exerciser/IoSequence.cc
@@ -1,6 +1,8 @@
 #include "IoSequence.h"
 
-ceph::io_exerciser::IoSequence::IoSequence(std::pair<int,int> obj_size_range,
+using IoSequence = ceph::io_exerciser::IoSequence;
+
+IoSequence::IoSequence(std::pair<int,int> obj_size_range,
                                            int seed) :
         min_obj_size(obj_size_range.first), max_obj_size(obj_size_range.second),
         create(true), barrier(false), done(false), remove(false),
@@ -9,13 +11,9 @@ ceph::io_exerciser::IoSequence::IoSequence(std::pair<int,int> obj_size_range,
   rng.seed(seed);
 }
 
-std::unique_ptr<ceph::io_exerciser::IoSequence>
-  ceph::io_exerciser::IoSequence::generate_sequence
-  ( 
-    Sequence s,
-    std::pair<int,int> obj_size_range,
-    int seed
-  )
+std::unique_ptr<IoSequence> IoSequence::generate_sequence(Sequence s,
+                                                          std::pair<int,int> obj_size_range,
+                                                          int seed)
 {
   switch (s) {
     case SEQUENCE_SEQ0:
@@ -44,17 +42,17 @@ std::unique_ptr<ceph::io_exerciser::IoSequence>
   return nullptr;
 }
 
-int ceph::io_exerciser::IoSequence::get_step() const
+int IoSequence::get_step() const
 {
   return step;
 }
 
-int ceph::io_exerciser::IoSequence::get_seed() const
+int IoSequence::get_seed() const
 {
   return seed;
 }
 
-void ceph::io_exerciser::IoSequence::set_min_object_size(uint64_t size)
+void IoSequence::set_min_object_size(uint64_t size)
 {
   min_obj_size = size;
   if (obj_size < size) {
@@ -65,7 +63,7 @@ void ceph::io_exerciser::IoSequence::set_min_object_size(uint64_t size)
   }
 }
 
-void ceph::io_exerciser::IoSequence::set_max_object_size(uint64_t size)
+void IoSequence::set_max_object_size(uint64_t size)
 {
   max_obj_size = size;
   if (obj_size > size) {
@@ -73,15 +71,14 @@ void ceph::io_exerciser::IoSequence::set_max_object_size(uint64_t size)
   }
 }
 
-void ceph::io_exerciser::IoSequence::select_random_object_size()
+void IoSequence::select_random_object_size()
 {
   if (max_obj_size != min_obj_size) {
     obj_size = min_obj_size + rng(max_obj_size - min_obj_size);
   }
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp>
-  ceph::io_exerciser::IoSequence::increment_object_size()
+std::unique_ptr<ceph::io_exerciser::IoOp> IoSequence::increment_object_size()
 {
   obj_size++;
   if (obj_size > max_obj_size) {
@@ -93,7 +90,7 @@ std::unique_ptr<ceph::io_exerciser::IoOp>
   return IoOp::generate_barrier();
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::IoSequence::next()
+std::unique_ptr<ceph::io_exerciser::IoOp> IoSequence::next()
 {
   step++;
   if (remove) {

diff --git a/src/common/io_exerciser/Model.cc b/src/common/io_exerciser/Model.cc
index f287d361b9312171f77d2df50caff79edb8a043a..50812ecbb155d6ce282a1600bdf35614b2d2b372 100644 (file)
--- a/src/common/io_exerciser/Model.cc
+++ b/src/common/io_exerciser/Model.cc
@@ -2,7 +2,9 @@
 // vim: ts=8 sw=2 smarttab
 #include "Model.h"
 
-ceph::io_exerciser::Model::Model(const std::string oid, uint64_t block_size) : 
+using Model = ceph::io_exerciser::Model;
+
+Model::Model(const std::string& oid, uint64_t block_size) : 
 num_io(0),
 oid(oid),
 block_size(block_size)
@@ -10,17 +12,17 @@ block_size(block_size)
 
 }
 
-const uint64_t ceph::io_exerciser::Model::get_block_size() const
+const uint64_t Model::get_block_size() const
 {
   return block_size;
 }
 
-const std::string& ceph::io_exerciser::Model::get_oid() const
+const std::string Model::get_oid() const
 {
   return oid;
 }
 
-int ceph::io_exerciser::Model::get_num_io() const
+int Model::get_num_io() const
 {
   return num_io;
 }
\ No newline at end of file

diff --git a/src/common/io_exerciser/Model.h b/src/common/io_exerciser/Model.h
index 6e34fc15ded42aca1b0393ec576641a58c8d2ac8..58d107409a654d7e0b416105d1f3b5690086b6dd 100644 (file)
--- a/src/common/io_exerciser/Model.h
+++ b/src/common/io_exerciser/Model.h
@@ -26,18 +26,18 @@ namespace ceph {
     class Model
     {
     protected:
-      int num_io;
-      const std::string oid;
+      int num_io{0};
+      std::string oid;
       uint64_t block_size;
 
     public:
-      Model(const std::string oid, uint64_t block_size);
+      Model(const std::string& oid, uint64_t block_size);
       virtual ~Model() = default;
 
       virtual bool readyForIoOp(IoOp& op) = 0;
       virtual void applyIoOp(IoOp& op) = 0;
       
-      const std::string& get_oid() const;
+      const std::string get_oid() const;
       const uint64_t get_block_size() const;
       int get_num_io() const;
     };

diff --git a/src/common/io_exerciser/ObjectModel.cc b/src/common/io_exerciser/ObjectModel.cc
index ba21c621250cb3dd6cb702194d3653ba87cc4036..4558ae78fa106c354d44863b72973f1f215545e5 100644 (file)
--- a/src/common/io_exerciser/ObjectModel.cc
+++ b/src/common/io_exerciser/ObjectModel.cc
@@ -1,18 +1,24 @@
 #include "ObjectModel.h"
 
-ceph::io_exerciser::ObjectModel::ObjectModel(const std::string oid, uint64_t block_size, int seed) :
+#include <algorithm>
+#include <execution>
+#include <iterator>
+
+using ObjectModel = ceph::io_exerciser::ObjectModel;
+
+ObjectModel::ObjectModel(const std::string& oid, uint64_t block_size, int seed) :
   Model(oid, block_size), created(false)
 {
   rng.seed(seed);
 }
 
-int ceph::io_exerciser::ObjectModel::get_seed(uint64_t offset) const
+int ObjectModel::get_seed(uint64_t offset) const
 {
   ceph_assert(offset < contents.size());
   return contents[offset];
 }
 
-std::vector<int> ceph::io_exerciser::ObjectModel::get_seed_offsets(int seed) const
+std::vector<int> ObjectModel::get_seed_offsets(int seed) const
 {
   std::vector<int> offsets;
   for (size_t i = 0; i < contents.size(); i++)
@@ -26,7 +32,7 @@ std::vector<int> ceph::io_exerciser::ObjectModel::get_seed_offsets(int seed) con
   return offsets;
 }
 
-std::string ceph::io_exerciser::ObjectModel::to_string(int mask) const
+std::string ObjectModel::to_string(int mask) const
 {
   if (!created) {
     return "Object does not exist";
@@ -42,13 +48,17 @@ std::string ceph::io_exerciser::ObjectModel::to_string(int mask) const
   return result;
 }
 
-bool ceph::io_exerciser::ObjectModel::readyForIoOp(IoOp& op)
+bool ObjectModel::readyForIoOp(IoOp& op)
 {
   return true;
 }
 
-void ceph::io_exerciser::ObjectModel::applyIoOp(IoOp& op)
+void ObjectModel::applyIoOp(IoOp& op)
 {
+  auto generate_random = [&rng = rng]() {
+    return rng();
+  };
+
   switch (op.op) {
   case BARRIER:
     reads.clear();
@@ -61,9 +71,8 @@ void ceph::io_exerciser::ObjectModel::applyIoOp(IoOp& op)
     ceph_assert(writes.empty());
     created = true;
     contents.resize(op.length1);
-    for (uint64_t i = 0; i < contents.size(); i++) {
-      contents[i] = rng();
-    }
+    std::generate(std::execution::seq, contents.begin(), contents.end(),
+                  generate_random);
     break;
 
   case REMOVE:
@@ -98,17 +107,18 @@ void ceph::io_exerciser::ObjectModel::applyIoOp(IoOp& op)
     reads.union_insert(op.offset1, op.length1);
     num_io++;
     break;
-    
+
   case WRITE3:
     ceph_assert(created);
     // Not allowed: write overlapping with parallel read or write
     ceph_assert(!reads.intersects(op.offset3, op.length3));
     ceph_assert(!writes.intersects(op.offset3, op.length3));
     writes.union_insert(op.offset3, op.length3);
-    for (uint64_t i = op.offset3; i < op.offset3 + op.length3; i++) {
-      ceph_assert(i < contents.size());
-      contents[i] = rng();
-    }
+    ceph_assert(op.offset3 + op.length3 <= contents.size());
+    std::generate(std::execution::seq,
+                  std::next(contents.begin(), op.offset3),
+                  std::next(contents.begin(), op.offset3 + op.length3),
+                  generate_random);
     [[fallthrough]];
 
   case WRITE2:
@@ -117,39 +127,41 @@ void ceph::io_exerciser::ObjectModel::applyIoOp(IoOp& op)
     ceph_assert(!reads.intersects(op.offset2, op.length2));
     ceph_assert(!writes.intersects(op.offset2, op.length2));
     writes.union_insert(op.offset2, op.length2);
-    for (uint64_t i = op.offset2; i < op.offset2 + op.length2; i++) {
-      ceph_assert(i < contents.size());
-      contents[i] = rng();
-    }
+    ceph_assert(op.offset2 + op.length2 <= contents.size());
+    std::generate(std::execution::seq,
+                  std::next(contents.begin(), op.offset2),
+                  std::next(contents.begin(), op.offset2 + op.length2),
+                  generate_random);
     [[fallthrough]];
-    
+
   case WRITE:
     ceph_assert(created);
     // Not allowed: write overlapping with parallel read or write
     ceph_assert(!reads.intersects(op.offset1, op.length1));
     ceph_assert(!writes.intersects(op.offset1, op.length1));
     writes.union_insert(op.offset1, op.length1);
-    for (uint64_t i = op.offset1; i < op.offset1 + op.length1; i++) {
-      ceph_assert(i < contents.size());
-      contents[i] = rng();
-    }
+    ceph_assert(op.offset1 + op.length1 <= contents.size());
+    std::generate(std::execution::seq,
+                  std::next(contents.begin(), op.offset1),
+                  std::next(contents.begin(), op.offset1 + op.length1),
+                  generate_random);
     num_io++;
     break;
   default:
     break;
   }
 }
-  
-void ceph::io_exerciser::ObjectModel::encode(ceph::buffer::list& bl) const {
+
+void ObjectModel::encode(ceph::buffer::list& bl) const {
   ENCODE_START(1, 1, bl);
   encode(created, bl);
   if (created) {
     encode(contents, bl);
   }
   ENCODE_FINISH(bl);
-}    
+}
 
-void ceph::io_exerciser::ObjectModel::decode(ceph::buffer::list::const_iterator& bl) {
+void ObjectModel::decode(ceph::buffer::list::const_iterator& bl) {
   DECODE_START(1, bl);
   DECODE_OLDEST(1);
   decode(created, bl);

diff --git a/src/common/io_exerciser/ObjectModel.h b/src/common/io_exerciser/ObjectModel.h
index c47f59b1cfe4a30ec660b294ba28d2ab8ebeb5b5..93c70f4142978b740bfddb772147c2ed4900bb17 100644 (file)
--- a/src/common/io_exerciser/ObjectModel.h
+++ b/src/common/io_exerciser/ObjectModel.h
@@ -36,7 +36,7 @@ namespace ceph {
       interval_set<uint64_t> reads;
       interval_set<uint64_t> writes;
     public:
-      ObjectModel(const std::string oid, uint64_t block_size, int seed);
+      ObjectModel(const std::string& oid, uint64_t block_size, int seed);
       
       int get_seed(uint64_t offset) const;
       std::vector<int> get_seed_offsets(int seed) const;

diff --git a/src/common/io_exerciser/RadosIo.cc b/src/common/io_exerciser/RadosIo.cc
index 4a92dbfdcf7f3cb211004e8052f9e0d0423e3a3f..3a9a2c1c28588f94c6526926cb8997a616b22952 100644 (file)
--- a/src/common/io_exerciser/RadosIo.cc
+++ b/src/common/io_exerciser/RadosIo.cc
@@ -2,10 +2,12 @@
 
 #include "DataGenerator.h"
 
-ceph::io_exerciser::RadosIo::RadosIo(librados::Rados& rados,
+using RadosIo = ceph::io_exerciser::RadosIo;
+
+RadosIo::RadosIo(librados::Rados& rados,
         boost::asio::io_context& asio,
-        const std::string pool,
-        const std::string oid,
+        const std::string& pool,
+        const std::string& oid,
         uint64_t block_size,
         int seed,
        int threads,
@@ -29,17 +31,17 @@ ceph::io_exerciser::RadosIo::RadosIo(librados::Rados& rados,
   allow_ec_overwrites(true);
 }
 
-ceph::io_exerciser::RadosIo::~RadosIo()
+RadosIo::~RadosIo()
 {
 }
 
-void ceph::io_exerciser::RadosIo::start_io()
+void RadosIo::start_io()
 {
   std::lock_guard l(lock);
   outstanding_io++;
 }
 
-void ceph::io_exerciser::RadosIo::finish_io()
+void RadosIo::finish_io()
 {
   std::lock_guard l(lock);
   ceph_assert(outstanding_io > 0);
@@ -47,7 +49,7 @@ void ceph::io_exerciser::RadosIo::finish_io()
   cond.notify_all();
 }
 
-void ceph::io_exerciser::RadosIo::wait_for_io(int count)
+void RadosIo::wait_for_io(int count)
 {
   std::unique_lock l(lock);
   while (outstanding_io > count) {
@@ -55,7 +57,7 @@ void ceph::io_exerciser::RadosIo::wait_for_io(int count)
   }
 }
 
-void ceph::io_exerciser::RadosIo::allow_ec_overwrites(bool allow)
+void RadosIo::allow_ec_overwrites(bool allow)
 {
   int rc;
   bufferlist inbl, outbl;
@@ -67,10 +69,9 @@ void ceph::io_exerciser::RadosIo::allow_ec_overwrites(bool allow)
   ceph_assert(rc == 0);
 }
 
-ceph::io_exerciser::RadosIo::AsyncOpInfo::AsyncOpInfo(
-        uint64_t offset1, uint64_t length1,
-        uint64_t offset2, uint64_t length2,
-        uint64_t offset3, uint64_t length3 ) :
+RadosIo::AsyncOpInfo::AsyncOpInfo(uint64_t offset1, uint64_t length1,
+                                  uint64_t offset2, uint64_t length2,
+                                  uint64_t offset3, uint64_t length3 ) :
   offset1(offset1), length1(length1),
   offset2(offset2), length2(length2),
   offset3(offset3), length3(length3)
@@ -78,7 +79,7 @@ ceph::io_exerciser::RadosIo::AsyncOpInfo::AsyncOpInfo(
 
 }
 
-bool ceph::io_exerciser::RadosIo::readyForIoOp(IoOp &op)
+bool RadosIo::readyForIoOp(IoOp &op)
 {
   ceph_assert(lock.is_locked_by_me()); //Must be called with lock held
   if (!om->readyForIoOp(op)) {
@@ -93,7 +94,7 @@ bool ceph::io_exerciser::RadosIo::readyForIoOp(IoOp &op)
   }
 }
 
-void ceph::io_exerciser::RadosIo::applyIoOp(IoOp &op)
+void RadosIo::applyIoOp(IoOp &op)
 {
   std::shared_ptr<AsyncOpInfo> op_info;
 

diff --git a/src/common/io_exerciser/RadosIo.h b/src/common/io_exerciser/RadosIo.h
index 6ae3a9562f661865fc7c65f3085e380996302d97..179c5bba3aea0a8ce16470623896ccb7fa91dce2 100644 (file)
--- a/src/common/io_exerciser/RadosIo.h
+++ b/src/common/io_exerciser/RadosIo.h
@@ -25,7 +25,7 @@ namespace ceph {
       boost::asio::io_context& asio;
       std::unique_ptr<ObjectModel> om;
       std::unique_ptr<ceph::io_exerciser::data_generation::DataGenerator> db;
-      const std::string pool;
+      std::string pool;
       int threads;
       ceph::mutex& lock;
       ceph::condition_variable& cond;
@@ -39,8 +39,8 @@ namespace ceph {
     public:
       RadosIo(librados::Rados& rados,
               boost::asio::io_context& asio,
-              const std::string pool,
-              const std::string oid,
+              const std::string& pool,
+              const std::string& oid,
               uint64_t block_size,
               int seed,
               int threads,