From: JonBailey1993 Date: Thu, 19 Sep 2024 14:44:22 +0000 (+0100) Subject: common/io_exerciser: performance, readability and safety improvements X-Git-Tag: v20.0.0~890^2~2 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=81c8c8c71f0e5efe3aaa466a09af1c477770ab06;p=ceph.git 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 --- diff --git a/src/common/io_exerciser/DataGenerator.cc b/src/common/io_exerciser/DataGenerator.cc index 5bc7302cc85d..276bdd7bd6c9 100644 --- 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::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::create_generator( + GenerationType generationType, const ObjectModel& model) { switch(generationType) { @@ -38,23 +41,20 @@ std::unique_ptr 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 -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 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 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 ff95368bd11e..6b652e356b6f 100644 --- 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 +std::unique_ptr IoOp ::generate_done() { return std::make_unique(OpType::Done); } -std::unique_ptr ceph::io_exerciser::IoOp +std::unique_ptr IoOp ::generate_barrier() { return std::make_unique(OpType::BARRIER); } -std::unique_ptr ceph::io_exerciser::IoOp +std::unique_ptr IoOp ::generate_create(uint64_t size) { return std::make_unique(OpType::CREATE,0,size); } -std::unique_ptr ceph::io_exerciser::IoOp +std::unique_ptr IoOp ::generate_remove() { return std::make_unique(OpType::REMOVE); } -std::unique_ptr ceph::io_exerciser::IoOp +std::unique_ptr IoOp ::generate_read(uint64_t offset, uint64_t length) { return std::make_unique(OpType::READ, offset, length); } -std::unique_ptr ceph::io_exerciser::IoOp +std::unique_ptr 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 offset2, length2); } -std::unique_ptr ceph::io_exerciser::IoOp +std::unique_ptr 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 offset3, length3); } -std::unique_ptr ceph::io_exerciser::IoOp - ::generate_write(uint64_t offset, uint64_t length) { - +std::unique_ptr IoOp::generate_write(uint64_t offset, uint64_t length) { return std::make_unique(OpType::WRITE, offset, length); } -std::unique_ptr ceph::io_exerciser::IoOp - ::generate_write2(uint64_t offset1, uint64_t length1, - uint64_t offset2, uint64_t length2) { - +std::unique_ptr 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 offset2, length2); } -std::unique_ptr 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::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 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 fb413bfb4906..716752c53c28 100644 --- 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 obj_size_range, +using IoSequence = ceph::io_exerciser::IoSequence; + +IoSequence::IoSequence(std::pair 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 obj_size_range, rng.seed(seed); } -std::unique_ptr - ceph::io_exerciser::IoSequence::generate_sequence - ( - Sequence s, - std::pair obj_size_range, - int seed - ) +std::unique_ptr IoSequence::generate_sequence(Sequence s, + std::pair obj_size_range, + int seed) { switch (s) { case SEQUENCE_SEQ0: @@ -44,17 +42,17 @@ std::unique_ptr 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::IoSequence::increment_object_size() +std::unique_ptr IoSequence::increment_object_size() { obj_size++; if (obj_size > max_obj_size) { @@ -93,7 +90,7 @@ std::unique_ptr return IoOp::generate_barrier(); } -std::unique_ptr ceph::io_exerciser::IoSequence::next() +std::unique_ptr IoSequence::next() { step++; if (remove) { diff --git a/src/common/io_exerciser/Model.cc b/src/common/io_exerciser/Model.cc index f287d361b931..50812ecbb155 100644 --- 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 6e34fc15ded4..58d107409a65 100644 --- 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 ba21c621250c..4558ae78fa10 100644 --- 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 +#include +#include + +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 ceph::io_exerciser::ObjectModel::get_seed_offsets(int seed) const +std::vector ObjectModel::get_seed_offsets(int seed) const { std::vector offsets; for (size_t i = 0; i < contents.size(); i++) @@ -26,7 +32,7 @@ std::vector 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 c47f59b1cfe4..93c70f414297 100644 --- a/src/common/io_exerciser/ObjectModel.h +++ b/src/common/io_exerciser/ObjectModel.h @@ -36,7 +36,7 @@ namespace ceph { interval_set reads; interval_set 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 get_seed_offsets(int seed) const; diff --git a/src/common/io_exerciser/RadosIo.cc b/src/common/io_exerciser/RadosIo.cc index 4a92dbfdcf7f..3a9a2c1c2858 100644 --- 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 op_info; diff --git a/src/common/io_exerciser/RadosIo.h b/src/common/io_exerciser/RadosIo.h index 6ae3a9562f66..179c5bba3aea 100644 --- 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 om; std::unique_ptr 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,