Configurable data payload size for dbsim.

dbsim/db_client.cpp

@@ -34,10 +34,13 @@ db::client::client(db::server& server,
     , client_state_(mutex_, cond_, server_state_, client_service_, client_id, mode)
     , client_service_(*this)
     , se_trx_(server.storage_engine())
+    , data_()
     , random_device_()
     , random_engine_(random_device_())
     , stats_()
-{ }
+{
+    data_.resize(params.max_data_size);
+}
 
 void db::client::start()
 {
@@ -119,18 +122,23 @@ void db::client::run_one_transaction()
             assert(transaction.active());
             assert(err == 0);
             std::uniform_int_distribution<size_t> uniform_dist(0, params_.n_rows);
-            const size_t data(uniform_dist(random_engine_));
+            const size_t randkey(uniform_dist(random_engine_));
-            std::ostringstream os;
+            ::memcpy(data_.data(), &randkey,
-            os << data;
+                     std::min(sizeof(randkey), data_.size()));
             wsrep::key key(wsrep::key::exclusive);
             key.append_key_part("dbms", 4);
             unsigned long long client_key(client_state_.id().get());
             key.append_key_part(&client_key, sizeof(client_key));
-            key.append_key_part(&data, sizeof(data));
+            key.append_key_part(&randkey, sizeof(randkey));
             err = client_state_.append_key(key);
+            size_t bytes_to_append(data_.size());
+            if (params_.random_data_size)
+            {
+                bytes_to_append = std::uniform_int_distribution<size_t>(
+                    1, data_.size())(random_engine_);
+            }
             err = err || client_state_.append_data(
-                wsrep::const_buffer(os.str().c_str(),
+                wsrep::const_buffer(data_.data(), bytes_to_append));
-                                    os.str().size()));
             return err;
         });
 

dbsim/db_client.hpp

@@ -79,6 +79,7 @@ namespace db
         db::client_state client_state_;
         db::client_service client_service_;
         db::storage_engine::transaction se_trx_;
+        wsrep::mutable_buffer data_;
         std::random_device random_device_;
         std::default_random_engine random_engine_;
         struct stats stats_;

dbsim/db_params.cpp

@@ -67,6 +67,10 @@ db::params db::parse_args(int argc, char** argv)
          "number of transactions run by a client")
         ("rows", po::value<size_t>(&params.n_rows),
          "number of rows per table")
+        ("max-data-size", po::value<size_t>(&params.max_data_size),
+         "maximum size of data payload (default 8)")
+        ("random-data-size", po::value<bool>(&params.random_data_size),
+         "randomized payload data size (default 0)")
         ("alg-freq", po::value<size_t>(&params.alg_freq),
          "ALG frequency")
         ("sync-wait", po::value<bool>(&params.sync_wait),

dbsim/db_params.hpp

@@ -31,6 +31,8 @@ namespace db
         size_t n_clients;
         size_t n_transactions;
         size_t n_rows;
+        size_t max_data_size; // Maximum size of write set data payload.
+        bool random_data_size; // If true, randomize data payload size.
         size_t alg_freq;
         bool sync_wait;
         std::string topology;
@@ -45,6 +47,8 @@ namespace db
             , n_clients(0)
             , n_transactions(0)
             , n_rows(1000)
+            , max_data_size(8)
+            , random_data_size(false)
             , alg_freq(0)
             , sync_wait(false)
             , topology()