[cpp] use smart pointers everywhere

cpp/CMakeLists.txt

@@ -205,3 +205,8 @@ if(TESTING)
     add_executable(tests ${testSources})
     target_link_libraries(tests microbench::microbench GTest::gtest GTest::gtest_main)
 endif()
+
+# TODO: untangle exe when microbench will be separated
+add_executable(json-example microbench/json_example/json_example.cpp)
+target_include_directories(json-example PUBLIC ${DSDir}/_dummy/_dummy1_noop)
+target_link_libraries(json-example PUBLIC microbench::microbench ${libs})

cpp/microbench/globals_t_impl.h

@@ -30,8 +30,6 @@ namespace microbench {
 
 struct globals_t {
     PAD;
-    // const
-    //    void *const NO_VALUE;
     VALUE_TYPE const NO_VALUE;
     const test_type KEY_MIN;  // must be smaller than any key that can be inserted/deleted
     const test_type

cpp/microbench/json_example/example.json

@@ -57,12 +57,5 @@
                 }
             }
         ]
-    },
-    "warmUp": {
-        "numThreads": 0,
-        "stopCondition": {
-            "ClassName": "Timer",
-            "workTime": 5000
-        }
     }
-}
+}

cpp/microbench/json_example/json_example.cpp

@@ -1,95 +1,113 @@
 //
 // Created by Ravil Galiev on 25.07.2023.
 //
-#pragma once
+
+#define DISTR_CONV_IMPL
 
 #include <fstream>
 #include <iostream>
-#include "json/single_include/nlohmann/json.hpp"
-
-#include "workloads/args_generators/impls/default_args_generator.h"
-#include "workloads/args_generators/impls/generalized_args_generator.h"
+#include <memory>
+#include "args_generators/args_generator_builder.h"
+#include "args_generators/impls/creakers_and_wave_args_generator_builder.h"
+#include "args_generators/impls/temporary_skewed_args_generator_builder.h"
+#include "data_maps/builders/array_data_map_builder.h"
+#include "data_maps/builders/id_data_map_builder.h"
+
+#include "parameters.h"
+#include "stop_condition/impls/operation_counter.h"
+#include "thread_loops/impls/prefill_insert_thread_loop.h"
+#include "workloads/args_generators/impls/generalized_args_generator_builder.h"
 #include "workloads/thread_loops/impls/default_thread_loop.h"
 #include "workloads/bench_parameters.h"
 
-ArgsGeneratorBuilder* get_default_args_generator_builder() {
-    return (new DefaultArgsGeneratorBuilder())
-        ->set_distribution_builder((new ZipfianDistributionBuilder())->set_alpha(1.0))
-        ->set_data_map_builder(new ArrayDataMapBuilder());
+using namespace microbench::workload;
+
+ArgsGeneratorBuilderPtr get_default_args_generator_builder() {
+    auto zipf = std::make_unique<ZipfianDistributionBuilder>();
+    zipf->set_alpha(1.0);
+
+    auto builder = std::make_unique<DefaultArgsGeneratorBuilder>();
+    builder->set_distribution_builder(std::move(zipf))
+        .set_data_map_builder(std::make_shared<ArrayDataMapBuilder>());
+    return builder;
 }
 
-ArgsGeneratorBuilder* get_temporary_skewed_args_generator_builder() {
-    return (new TemporarySkewedArgsGeneratorBuilder())
-        ->set_set_number(5)
-        ->set_hot_times(new int64_t[5]{1, 2, 3, 4, 5})
-        ->set_relax_times(new int64_t[5]{1, 2, 3, 4, 5})
-        ->set_hot_size_and_ratio(0, 0.1, 0.8)
-        ->set_hot_size_and_ratio(1, 0.2, 0.7)
-        ->set_hot_size_and_ratio(2, 0.3, 0.6)
-        ->set_hot_size_and_ratio(3, 0.4, 0.6)
-        ->set_hot_size_and_ratio(4, 0.5, 0.7)
-        ->enable_manual_setting_set_begins()
-        ->set_set_begins(new double[5]{0, 0.1, 0.2, 0.3, 0.05});
+ArgsGeneratorBuilderPtr get_temporary_skewed_args_generator_builder() {
+    auto builder = std::make_unique<TemporarySkewedArgsGeneratorBuilder>();
+    builder->set_set_number(5)
+        .set_hot_times({1, 2, 3, 4, 5})
+        .set_relax_times({1, 2, 3, 4, 5})
+        .set_hot_size_and_ratio(0, 0.1, 0.8)
+        .set_hot_size_and_ratio(1, 0.2, 0.7)
+        .set_hot_size_and_ratio(2, 0.3, 0.6)
+        .set_hot_size_and_ratio(3, 0.4, 0.6)
+        .set_hot_size_and_ratio(4, 0.5, 0.7)
+        .enable_manual_setting_set_begins()
+        .set_set_begins({0, 0.1, 0.2, 0.3, 0.05});
+    return builder;
 }
 
-ArgsGeneratorBuilder* get_creakers_and_wave_args_generator_builder() {
-    return (new CreakersAndWaveArgsGeneratorBuilder())
-        ->set_creakers_ratio(0.2)
-        ->set_wave_size(0.2)
-        ->set_creakers_size(0.1)
-        ->set_data_map_builder(new IdDataMapBuilder());
+ArgsGeneratorBuilderPtr get_creakers_and_wave_args_generator_builder() {
+    auto builder = std::make_unique<CreakersAndWaveArgsGeneratorBuilder>();
+    builder->set_creakers_ratio(0.2).set_wave_size(0.3).set_creakers_size(0.2).set_data_map_builder(
+        std::make_shared<IdDataMapBuilder>());
+    return builder;
 }
 
-ArgsGeneratorBuilder* get_null_args_generator_builder() {
-    return (new NullArgsGeneratorBuilder());
+ArgsGeneratorBuilderPtr get_null_args_generator_builder() {
+    return std::make_unique<NullArgsGeneratorBuilder>();
 }
 
-ArgsGeneratorBuilder* get_range_query_args_generator_builder() {
-    return (new RangeQueryArgsGeneratorBuilder())
-        ->set_distribution_builder((new ZipfianDistributionBuilder())->set_alpha(1.0))
-        ->set_data_map_builder(new ArrayDataMapBuilder())
-        ->set_interval(100);
+ArgsGeneratorBuilderPtr get_range_query_args_generator_builder() {
+    auto zipf = std::make_unique<ZipfianDistributionBuilder>();
+    zipf->set_alpha(1.0);
+    auto builder = std::make_unique<RangeQueryArgsGeneratorBuilder>();
+    builder->set_distribution_builder(std::move(zipf))
+        .set_data_map_builder(std::make_shared<ArrayDataMapBuilder>())
+        .set_interval(100);
+    return builder;
 }
 
-ArgsGeneratorBuilder* get_generalized_args_generator_builder(ArgsGeneratorBuilder* inside) {
-    // std::vector<std::string> operations{"get", "insert", "remove"};
-    return (new GeneralizedArgsGeneratorBuilder())
-        ->add_args_generator_builder({"get"}, inside)
-        ->add_args_generator_builder({"insert"}, get_creakers_and_wave_args_generator_builder())
-        ->add_args_generator_builder({"remove"}, get_default_args_generator_builder())
-        ->add_args_generator_builder({"rangeQuery"}, get_range_query_args_generator_builder());
-    // ->setDistributionBuilder((new ZipfianDistributionBuilder())->setAlpha(1.0))
-    // ->setDataMapBuilder(new ArrayDataMapBuilder()));
+ArgsGeneratorBuilderPtr get_generalized_args_generator_builder(ArgsGeneratorBuilderPtr inside) {
+    auto builder = std::make_unique<GeneralizedArgsGeneratorBuilder>();
+    builder->add_args_generator_builder({"get"}, std::move(inside))
+        .add_args_generator_builder({"insert"}, get_creakers_and_wave_args_generator_builder())
+        .add_args_generator_builder({"remove"}, get_default_args_generator_builder())
+        .add_args_generator_builder({"rangeQuery"}, get_range_query_args_generator_builder());
+    return builder;
 }
 
-ThreadLoopBuilder* get_default_thread_loop_builder(ArgsGeneratorBuilder* args_generator_builder) {
-    return (new DefaultThreadLoopBuilder())
-        ->set_ins_ratio(0.1)
-        ->set_rem_ratio(0.1)
-        ->set_rq_ratio(0)
-        ->setArgsGeneratorBuilder(args_generator_builder);
+ThreadLoopBuilderPtr get_default_thread_loop_builder(
+    ArgsGeneratorBuilderPtr args_generator_builder) {
+    auto builder = std::make_unique<DefaultThreadLoopBuilder>();
+    builder->set_ins_ratio(0.1).set_rem_ratio(0.1).set_rq_ratio(0).set_args_generator_builder(
+        std::move(args_generator_builder));
+    return builder;
 }
 
-ThreadLoopBuilder* get_temporary_operation_thread_loop_builder(
-    ArgsGeneratorBuilder* args_generator_builder) {
-    return (new TemporaryOperationsThreadLoopBuilder())
-        ->set_stages_number(3)
-        ->set_stages_durations(new size_t[3]{1000, 2000, 3000})
-        ->set_ratios(0, new RatioThreadLoopParameters(0.1, 0.1, 0))
-        ->set_ratios(1, new RatioThreadLoopParameters(0.2, 0.2, 0))
-        ->set_ratios(2, new RatioThreadLoopParameters(0.3, 0.3, 0))
-        ->set_args_generator_builder(args_generator_builder);
+ThreadLoopBuilderPtr get_temporary_operation_thread_loop_builder(
+    ArgsGeneratorBuilderPtr args_generator_builder) {
+    auto builder = std::make_unique<TemporaryOperationsThreadLoopBuilder>();
+    builder->set_stages_number(3)
+        .set_stages_durations({1000, 2000, 3000})
+        .set_ratios(0, RatioThreadLoopParameters(0.1, 0.1, 0))
+        .set_ratios(1, RatioThreadLoopParameters(0.2, 0.2, 0))
+        .set_ratios(2, RatioThreadLoopParameters(0.3, 0.3, 0))
+        .set_args_generator_builder(std::move(args_generator_builder));
+    return builder;
 }
 
-Parameters* get_creakers_and_wave_prefiller(size_t range,
-                                        CreakersAndWaveArgsGeneratorBuilder* args_generator_builder) {
-    CreakersAndWavePrefillArgsGeneratorBuilder* prefill_args_generator_builder =
-        new CreakersAndWavePrefillArgsGeneratorBuilder(args_generator_builder);
-    return (new Parameters())
-        ->add_thread_loop_builder((new PrefillInsertThreadLoopBuilder())
-                                   ->set_args_generator_builder(prefill_args_generator_builder))
-        ->set_stop_condition(
-            new OperationCounter(prefill_args_generator_builder->get_prefill_length(range)));
+Parameters get_creakers_and_wave_prefiller(
+    size_t range, std::unique_ptr<CreakersAndWaveArgsGeneratorBuilder> args_generator_builder) {
+    auto prefill_args_generator_builder =
+        std::make_unique<CreakersAndWavePrefillArgsGeneratorBuilder>();
+    prefill_args_generator_builder->set_parameters_by_builder(*args_generator_builder);
+    auto lim = prefill_args_generator_builder->get_prefill_length();
+    auto prefill_insert_builder = std::make_unique<PrefillInsertThreadLoopBuilder>();
+    prefill_insert_builder->set_args_generator_builder(std::move(prefill_args_generator_builder));
+    return Parameters()
+        .add_thread_loop_builder(std::move(prefill_insert_builder))
+        .set_stop_condition(std::make_shared<OperationCounter>(lim));
 }
 
 int main() {
@@ -109,15 +127,15 @@ int main() {
      * Create the Parameters class for benchmarking (test).
      */
 
-    Parameters* test = new Parameters();
+    Parameters test = Parameters();
 
     /**
      * We will need to set the stop condition and workloads.
      *
      * First, let's create a stop condition: Timer with 10 second (10000 millis).
      */
 
-    StopCondition* stop_condition = new Timer(10000);
+    StopConditionPtr stop_condition = std::make_shared<Timer>(10000);
 
     /**
      * Setup a workload.
@@ -128,7 +146,7 @@ int main() {
      * TemporarySkewedArgsGeneratorBuilder and CreakersAndWaveArgsGeneratorBuilder are also
      * presented in the corresponding functions
      */
-    ArgsGeneratorBuilder* args_generator_builder = get_default_args_generator_builder();
+    ArgsGeneratorBuilderPtr args_generator_builder = get_default_args_generator_builder();
     //               = getCreakersAndWaveArgsGeneratorBuilder();
     //                = getTemporarySkewedArgsGeneratorBuilder();
     /*
@@ -140,16 +158,17 @@ int main() {
      * in addition to the DefaultThreadLoopBuilder,
      * TemporaryOperationThreadLoopBuilder is also presented in the corresponding function
      */
-    ThreadLoopBuilder* thread_loop_builder = get_default_thread_loop_builder(args_generator_builder);
+    ThreadLoopBuilderPtr thread_loop_builder =
+        get_default_thread_loop_builder(std::move(args_generator_builder));
     //                = getTemporaryOperationThreadLoopBuilder(argsGeneratorBuilder);
 
     /**
      * now add the ThreadLoopBuilders (you can add several different)
      * to the parameter class indicating the number of threads.
      * You can also optionally specify the cores to which threads should bind (-1 without binding).
      */
-    test->add_thread_loop_builder(thread_loop_builder, 8, "~2.0.0.1-3.3")
-        ->set_stop_condition(stop_condition);
+    test.add_thread_loop_builder(std::move(thread_loop_builder), 8, "~2.0.0.1-3.3")
+        .set_stop_condition(std::move(stop_condition));
 
     bench_parameters.set_test(test).create_default_prefill();
     //        .setPrefill(getCreakersAndWavePrefiller(

cpp/microbench/main.cpp

@@ -16,8 +16,9 @@
 #include <perftools.h>
 #include <regex>
 
-#include "random_xoshiro256p.h"
+#define DISTR_CONV_IMPL
 
+#include "random_xoshiro256p.h"
 
 #define MAIN_BENCH
 
@@ -203,21 +204,21 @@ Statistic get_statistic(int64_t elapsed_millis) {
     return Statistic(elapsed_millis / 1000.);
 }
 
-void execute(globals_t* g, Parameters* parameters) {
+void execute(globals_t* g, Parameters const& parameters) {
     std::thread** threads = new std::thread*[MAX_THREADS_POW2];
-    ThreadLoop** thread_loops = parameters->get_workload(g, g->rngs);
+    std::vector<ThreadLoopPtr> thread_loops = parameters.get_workload(g, g->rngs);
 
     std::cout << "binding threads...\n";
-    binding_setCustom(parameters->get_pin());
-    bind_threads(parameters->get_num_threads());
+    binding_setCustom(parameters.get_pin());
+    bind_threads(parameters.get_num_threads());
 
     std::cout << "creating threads...\n";
 
-    for (int i = 0; i < parameters->get_num_threads(); ++i) {
-        threads[i] = new std::thread(&ThreadLoop::run, thread_loops[i]);
+    for (int i = 0; i < parameters.get_num_threads(); ++i) {
+        threads[i] = new std::thread(&ThreadLoop::run, thread_loops[i].get());
     }
 
-    while (g->running < parameters->get_num_threads()) {
+    while (g->running < parameters.get_num_threads()) {
         TRACE COUTATOMIC("main thread: waiting for threads to START running=" << g->running
                                                                               << std::endl);
     }  // wait for all threads to be ready
@@ -233,11 +234,11 @@ void execute(globals_t* g, Parameters* parameters) {
     ___timeline_use = 1;
 #endif
 
-    parameters->stopCondition->start(parameters->get_num_threads());
+    parameters.stopCondition->start(parameters.get_num_threads());
     g->start = true;
     SOFTWARE_BARRIER;
 
-    for (size_t i = 0; i < parameters->get_num_threads(); ++i) {
+    for (size_t i = 0; i < parameters.get_num_threads(); ++i) {
         threads[i]->join();
     }
 
@@ -298,9 +299,8 @@ void execute(globals_t* g, Parameters* parameters) {
     g->elapsedMillis =
         std::chrono::duration_cast<std::chrono::milliseconds>(g->endTime - g->startTime).count();
 
-    parameters->stopCondition->clean();
+    parameters.stopCondition->clean();
     delete[] threads;
-    delete[] thread_loops;
     binding_deinit();
 
     g->start = false;
@@ -345,16 +345,16 @@ void run(globals_t* g) {
     /**
      * PREFILL STAGE
      */
-    if (g->benchParameters->prefill->get_num_threads() != 0) {
+    if (g->benchParameters->prefill.has_value()) {
         COUTATOMIC(to_string_stage("Prefill stage"))
 
-        execute(g, g->benchParameters->prefill);
+        execute(g, *g->benchParameters->prefill);
 
         {
             // print prefilling status information
             using namespace std::chrono;
             const int64_t total_updates = GSTATS_OBJECT_NAME.get_sum<int64_t>(num_inserts) +
-                                           GSTATS_OBJECT_NAME.get_sum<int64_t>(num_removes);
+                                          GSTATS_OBJECT_NAME.get_sum<int64_t>(num_removes);
             g->curKeySum += GSTATS_OBJECT_NAME.get_sum<int64_t>(key_checksum);
             g->curSize += GSTATS_OBJECT_NAME.get_sum<int64_t>(num_successful_inserts) -
                           GSTATS_OBJECT_NAME.get_sum<int64_t>(num_successful_removes);
@@ -378,15 +378,15 @@ void run(globals_t* g) {
     /**
      * WARM UP STAGE
      */
-    if (g->benchParameters->warmUp->get_num_threads() != 0) {
+    if (g->benchParameters->warmUp.has_value()) {
         COUTATOMIC(to_string_stage("WarmUp stage"))
 
-        execute(g, g->benchParameters->warmUp);
+        execute(g, *g->benchParameters->warmUp);
 
         // print warm up status information
         using namespace std::chrono;
         const int64_t total_updates = GSTATS_OBJECT_NAME.get_sum<int64_t>(num_inserts) +
-                                       GSTATS_OBJECT_NAME.get_sum<int64_t>(num_removes);
+                                      GSTATS_OBJECT_NAME.get_sum<int64_t>(num_removes);
         g->curKeySum += GSTATS_OBJECT_NAME.get_sum<int64_t>(key_checksum);
         g->curSize += GSTATS_OBJECT_NAME.get_sum<int64_t>(num_successful_inserts) -
                       GSTATS_OBJECT_NAME.get_sum<int64_t>(num_successful_removes);
@@ -409,7 +409,7 @@ void run(globals_t* g) {
 
     std::cout << to_string_stage("Test stage");
 
-    execute(g, g->benchParameters->test);
+    execute(g, *g->benchParameters->test);
 
     COUTATOMIC(std::endl);
     COUTATOMIC(to_string_big_stage("END RUNNING"))
@@ -662,13 +662,13 @@ int main(int argc, char** argv) {
     }
 
     if (prefill != nullptr) {
-        bench_parameters->set_prefill(prefill);
+        bench_parameters->set_prefill(std::move(*prefill));
     }
     if (test != nullptr) {
-        bench_parameters->set_test(test);
+        bench_parameters->set_test(std::move(*test));
     }
     if (warm_up != nullptr) {
-        bench_parameters->set_warm_up(warm_up);
+        bench_parameters->set_warm_up(std::move(*warm_up));
     }
     if (range != -1) {
         bench_parameters->set_range(range);