sysio::txn_test_gen_plugin_impl Struct Reference

Collaboration diagram for sysio::txn_test_gen_plugin_impl:

Public Member Functions
void	push_next_transaction (const std::shared_ptr< std::vector< signed_transaction > > &trxs, const std::function< void(const fc::exception_ptr &)> &next)
void	push_transactions (std::vector< signed_transaction > &&trxs, const std::function< void(fc::exception_ptr)> &next)
void	create_test_accounts (const std::string &init_name, const std::string &init_priv_key, const std::function< void(const fc::exception_ptr &)> &next)
string	start_generation (const std::string &salt, const uint64_t &period, const uint64_t &batch_size)
void	arm_timer (boost::asio::high_resolution_timer::time_point s)
void	send_transaction (std::function< void(const fc::exception_ptr &)> next, uint64_t nonce_prefix)
void	stop_generation ()

Public Attributes
uint64_t	_total_us = 0
uint64_t	_txcount = 0
uint16_t	thread_pool_size
std::optional< sysio::chain::named_thread_pool >	thread_pool
std::shared_ptr< boost::asio::high_resolution_timer >	timer
name	newaccountA
name	newaccountB
name	newaccountT
bool	running {false}
unsigned	timer_timeout
unsigned	batch
uint64_t	nonce_prefix
action	act_a_to_b
action	act_b_to_a
int32_t	txn_reference_block_lag

Detailed Description

Definition at line 94 of file txn_test_gen_plugin.cpp.

Member Function Documentation

arm_timer()

void sysio::txn_test_gen_plugin_impl::arm_timer ( boost::asio::high_resolution_timer::time_point s )

inline

Definition at line 329 of file txn_test_gen_plugin.cpp.

                                                              {
      timer->expires_at(s + std::chrono::milliseconds(timer_timeout));
      boost::asio::post( thread_pool->get_executor(), [this]() {
         send_transaction([this](const fc::exception_ptr& e){
            if (e) {
               elog("pushing transaction failed: ${e}", ("e", e->to_detail_string()));
               if(running)
                  stop_generation();
            }
         }, nonce_prefix++);
      });
      timer->async_wait([this](const boost::system::error_code& ec) {
         if(!running || ec)
            return;
         arm_timer(timer->expires_at());
      });
   }

create_test_accounts()

void sysio::txn_test_gen_plugin_impl::create_test_accounts ( const std::string & init_name, const std::string & init_priv_key, const std::function< void(const fc::exception_ptr &)> & next )

inline

Definition at line 138 of file txn_test_gen_plugin.cpp.

                                                                                                                                                {
      ilog("create_test_accounts");
      std::vector<signed_transaction> trxs;
      trxs.reserve(2);
 
      try {
         name creator(init_name);
 
         abi_def currency_abi_def = fc::json::from_string(contracts::sysio_token_abi().data()).as<abi_def>();
 
         controller& cc = app().get_plugin<chain_plugin>().chain();
         auto chainid = app().get_plugin<chain_plugin>().get_chain_id();
         auto abi_serializer_max_time = app().get_plugin<chain_plugin>().get_abi_serializer_max_time();
 
         abi_serializer sysio_token_serializer{fc::json::from_string(contracts::sysio_token_abi().data()).as<abi_def>(),
                                               abi_serializer::create_yield_function( abi_serializer_max_time )};
 
         fc::crypto::private_key txn_test_receiver_A_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
         fc::crypto::private_key txn_test_receiver_B_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));
         fc::crypto::private_key txn_test_receiver_C_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'c')));
         fc::crypto::public_key  txn_text_receiver_A_pub_key = txn_test_receiver_A_priv_key.get_public_key();
         fc::crypto::public_key  txn_text_receiver_B_pub_key = txn_test_receiver_B_priv_key.get_public_key();
         fc::crypto::public_key  txn_text_receiver_C_pub_key = txn_test_receiver_C_priv_key.get_public_key();
         fc::crypto::private_key creator_priv_key = fc::crypto::private_key(init_priv_key);
 
         //create some test accounts
         {
            signed_transaction trx;
 
            //create "A" account
            {
            auto owner_auth   = sysio::chain::authority{1, {{txn_text_receiver_A_pub_key, 1}}, {}};
            auto active_auth  = sysio::chain::authority{1, {{txn_text_receiver_A_pub_key, 1}}, {}};
 
            trx.actions.emplace_back(vector<chain::permission_level>{{creator,name("active")}}, newaccount{creator, newaccountA, owner_auth, active_auth});
            }
            //create "B" account
            {
            auto owner_auth   = sysio::chain::authority{1, {{txn_text_receiver_B_pub_key, 1}}, {}};
            auto active_auth  = sysio::chain::authority{1, {{txn_text_receiver_B_pub_key, 1}}, {}};
 
            trx.actions.emplace_back(vector<chain::permission_level>{{creator,name("active")}}, newaccount{creator, newaccountB, owner_auth, active_auth});
            }
            //create "T" account
            {
            auto owner_auth   = sysio::chain::authority{1, {{txn_text_receiver_C_pub_key, 1}}, {}};
            auto active_auth  = sysio::chain::authority{1, {{txn_text_receiver_C_pub_key, 1}}, {}};
 
            trx.actions.emplace_back(vector<chain::permission_level>{{creator,name("active")}}, newaccount{creator, newaccountT, owner_auth, active_auth});
            }
 
            trx.expiration = cc.head_block_time() + fc::seconds(180);
            trx.set_reference_block(cc.head_block_id());
            trx.sign(creator_priv_key, chainid);
            trxs.emplace_back(std::move(trx));
         }
 
         //set newaccountT contract to sysio.token & initialize it
         {
            signed_transaction trx;
 
            vector<uint8_t> wasm = contracts::sysio_token_wasm();
 
            setcode handler;
            handler.account = newaccountT;
            handler.code.assign(wasm.begin(), wasm.end());
 
            trx.actions.emplace_back( vector<chain::permission_level>{{newaccountT,name("active")}}, handler);
 
            {
               setabi handler;
               handler.account = newaccountT;
               handler.abi = fc::raw::pack(json::from_string(contracts::sysio_token_abi().data()).as<abi_def>());
               trx.actions.emplace_back( vector<chain::permission_level>{{newaccountT,name("active")}}, handler);
            }
 
            {
               action act;
               act.account = newaccountT;
               act.name = "create"_n;
               act.authorization = vector<permission_level>{{newaccountT,config::active_name}};
               act.data = sysio_token_serializer.variant_to_binary("create",
                                                                   fc::json::from_string(fc::format_string("{\"issuer\":\"${issuer}\",\"maximum_supply\":\"1000000000.0000 CUR\"}}",
                                                                   fc::mutable_variant_object()("issuer",newaccountT.to_string()))),
                                                                   abi_serializer::create_yield_function( abi_serializer_max_time ));
               trx.actions.push_back(act);
            }
            {
               action act;
               act.account = newaccountT;
               act.name = "issue"_n;
               act.authorization = vector<permission_level>{{newaccountT,config::active_name}};
               act.data = sysio_token_serializer.variant_to_binary("issue",
                                                                   fc::json::from_string(fc::format_string("{\"to\":\"${to}\",\"quantity\":\"60000.0000 CUR\",\"memo\":\"\"}",
                                                                   fc::mutable_variant_object()("to",newaccountT.to_string()))),
                                                                   abi_serializer::create_yield_function( abi_serializer_max_time ));
               trx.actions.push_back(act);
            }
            {
               action act;
               act.account = newaccountT;
               act.name = "transfer"_n;
               act.authorization = vector<permission_level>{{newaccountT,config::active_name}};
               act.data = sysio_token_serializer.variant_to_binary("transfer",
                                                                   fc::json::from_string(fc::format_string("{\"from\":\"${from}\",\"to\":\"${to}\",\"quantity\":\"20000.0000 CUR\",\"memo\":\"\"}",
                                                                   fc::mutable_variant_object()("from",newaccountT.to_string())("to",newaccountA.to_string()))),
                                                                   abi_serializer::create_yield_function( abi_serializer_max_time ));
               trx.actions.push_back(act);
            }
            {
               action act;
               act.account = newaccountT;
               act.name = "transfer"_n;
               act.authorization = vector<permission_level>{{newaccountT,config::active_name}};
               act.data = sysio_token_serializer.variant_to_binary("transfer",
                                                                   fc::json::from_string(fc::format_string("{\"from\":\"${from}\",\"to\":\"${to}\",\"quantity\":\"20000.0000 CUR\",\"memo\":\"\"}",
                                                                   fc::mutable_variant_object()("from",newaccountT.to_string())("to",newaccountB.to_string()))),
                                                                   abi_serializer::create_yield_function( abi_serializer_max_time ));
               trx.actions.push_back(act);
            }
 
            trx.expiration = cc.head_block_time() + fc::seconds(180);
            trx.set_reference_block(cc.head_block_id());
            trx.max_net_usage_words = 5000;
            trx.sign(txn_test_receiver_C_priv_key, chainid);
            trxs.emplace_back(std::move(trx));
         }
      } catch ( const std::bad_alloc& ) {
        throw;
      } catch ( const boost::interprocess::bad_alloc& ) {
        throw;
      } catch (const fc::exception& e) {
         next(e.dynamic_copy_exception());
         return;
      } catch (const std::exception& e) {
         next(fc::std_exception_wrapper::from_current_exception(e).dynamic_copy_exception());
         return;
      }
 
      push_transactions(std::move(trxs), next);
   }

Here is the call graph for this function:

push_next_transaction()

void sysio::txn_test_gen_plugin_impl::push_next_transaction ( const std::shared_ptr< std::vector< signed_transaction > > & trxs, const std::function< void(const fc::exception_ptr &)> & next )

inline

Definition at line 106 of file txn_test_gen_plugin.cpp.

                                                                                                                                                {
      chain_plugin& cp = app().get_plugin<chain_plugin>();
 
      for (size_t i = 0; i < trxs->size(); ++i) {
         cp.accept_transaction( std::make_shared<packed_transaction>(trxs->at(i)), [=](const std::variant<fc::exception_ptr, transaction_trace_ptr>& result){
 
            fc::exception_ptr except_ptr;
            if (std::holds_alternative<fc::exception_ptr>(result)) {
               except_ptr = std::get<fc::exception_ptr>(result);
            } else if (std::get<transaction_trace_ptr>(result)->except) {
               except_ptr = std::get<transaction_trace_ptr>(result)->except->dynamic_copy_exception();
            }
 
            if (except_ptr) {
               next(std::get<fc::exception_ptr>(result));
            } else {
               if (std::holds_alternative<transaction_trace_ptr>(result) && std::get<transaction_trace_ptr>(result)->receipt) {
                  _total_us += std::get<transaction_trace_ptr>(result)->receipt->cpu_usage_us;
                  ++_txcount;
               }
            }
         });
      }
   }

Here is the call graph for this function:

push_transactions()

void sysio::txn_test_gen_plugin_impl::push_transactions ( std::vector< signed_transaction > && trxs, const std::function< void(fc::exception_ptr)> & next )

inline

Definition at line 131 of file txn_test_gen_plugin.cpp.

                                                                                                                  {
      auto trxs_copy = std::make_shared<std::decay_t<decltype(trxs)>>(std::move(trxs));
      app().post(priority::low, [this, trxs_copy, next]() {
         push_next_transaction(trxs_copy, next);
      });
   }

Here is the call graph for this function:

send_transaction()

void sysio::txn_test_gen_plugin_impl::send_transaction ( std::function< void(const fc::exception_ptr &)> next, uint64_t nonce_prefix )

inline

Definition at line 347 of file txn_test_gen_plugin.cpp.

                                                                                                {
      std::vector<signed_transaction> trxs;
      trxs.reserve(2*batch);
 
      try {
         controller& cc = app().get_plugin<chain_plugin>().chain();
         auto chainid = app().get_plugin<chain_plugin>().get_chain_id();
 
         static fc::crypto::private_key a_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
         static fc::crypto::private_key b_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));
 
         static uint64_t nonce = static_cast<uint64_t>(fc::time_point::now().sec_since_epoch()) << 32;
 
         uint32_t reference_block_num = cc.last_irreversible_block_num();
         if (txn_reference_block_lag >= 0) {
            reference_block_num = cc.head_block_num();
            if (reference_block_num <= (uint32_t)txn_reference_block_lag) {
               reference_block_num = 0;
            } else {
               reference_block_num -= (uint32_t)txn_reference_block_lag;
            }
         }
 
         block_id_type reference_block_id = cc.get_block_id_for_num(reference_block_num);
 
         for(unsigned int i = 0; i < batch; ++i) {
         {
         signed_transaction trx;
         trx.actions.push_back(act_a_to_b);
         trx.context_free_actions.emplace_back(action({}, config::null_account_name, name("nonce"), fc::raw::pack( std::to_string(nonce_prefix)+std::to_string(nonce++) )));
         trx.set_reference_block(reference_block_id);
         trx.expiration = cc.head_block_time() + fc::seconds(30);
         trx.max_net_usage_words = 100;
         trx.sign(a_priv_key, chainid);
         trxs.emplace_back(std::move(trx));
         }
 
         {
         signed_transaction trx;
         trx.actions.push_back(act_b_to_a);
         trx.context_free_actions.emplace_back(action({}, config::null_account_name, name("nonce"), fc::raw::pack( std::to_string(nonce_prefix)+std::to_string(nonce++) )));
         trx.set_reference_block(reference_block_id);
         trx.expiration = cc.head_block_time() + fc::seconds(30);
         trx.max_net_usage_words = 100;
         trx.sign(b_priv_key, chainid);
         trxs.emplace_back(std::move(trx));
         }
         }
      } catch ( const std::bad_alloc& ) {
        throw;
      } catch ( const boost::interprocess::bad_alloc& ) {
        throw;
      } catch ( const fc::exception& e ) {
         next(e.dynamic_copy_exception());
      } catch (const std::exception& e) {
         next(fc::std_exception_wrapper::from_current_exception(e).dynamic_copy_exception());
      }
 
      push_transactions(std::move(trxs), next);
   }

Here is the call graph for this function:

start_generation()

string sysio::txn_test_gen_plugin_impl::start_generation ( const std::string & salt, const uint64_t & period, const uint64_t & batch_size )

inline

Definition at line 280 of file txn_test_gen_plugin.cpp.

                                                                                                      {
      ilog("Starting transaction test plugin");
      if(running)
         return "start_generation already running";
      if(period < 1 || period > 2500)
         return "period must be between 1 and 2500";
      if(batch_size < 1 || batch_size > 250)
         return "batch_size must be between 1 and 250";
      if(batch_size & 1)
         return "batch_size must be even";
      ilog("Starting transaction test plugin valid");
 
      running = true;
 
      auto abi_serializer_max_time = app().get_plugin<chain_plugin>().get_abi_serializer_max_time();
      abi_serializer sysio_token_serializer{fc::json::from_string(contracts::sysio_token_abi().data()).as<abi_def>(), abi_serializer::create_yield_function( abi_serializer_max_time )};
      //create the actions here
      act_a_to_b.account = newaccountT;
      act_a_to_b.name = "transfer"_n;
      act_a_to_b.authorization = vector<permission_level>{{newaccountA,config::active_name}};
      act_a_to_b.data = sysio_token_serializer.variant_to_binary("transfer",
                                                                  fc::json::from_string(fc::format_string("{\"from\":\"${from}\",\"to\":\"${to}\",\"quantity\":\"1.0000 CUR\",\"memo\":\"${l}\"}",
                                                                  fc::mutable_variant_object()("from",newaccountA.to_string())("to",newaccountB.to_string())("l", salt))),
                                                                  abi_serializer::create_yield_function( abi_serializer_max_time ));
 
      act_b_to_a.account = newaccountT;
      act_b_to_a.name = "transfer"_n;
      act_b_to_a.authorization = vector<permission_level>{{newaccountB,config::active_name}};
      act_b_to_a.data = sysio_token_serializer.variant_to_binary("transfer",
                                                                  fc::json::from_string(fc::format_string("{\"from\":\"${from}\",\"to\":\"${to}\",\"quantity\":\"1.0000 CUR\",\"memo\":\"${l}\"}",
                                                                  fc::mutable_variant_object()("from",newaccountB.to_string())("to",newaccountA.to_string())("l", salt))),
                                                                  abi_serializer::create_yield_function( abi_serializer_max_time ));
 
      timer_timeout = period;
      batch = batch_size/2;
      nonce_prefix = 0;
 
      thread_pool.emplace( "txntest", thread_pool_size );
      timer = std::make_shared<boost::asio::high_resolution_timer>(thread_pool->get_executor());
 
      ilog("Started transaction test plugin; generating ${p} transactions every ${m} ms by ${t} load generation threads",
         ("p", batch_size) ("m", period) ("t", thread_pool_size));
 
      boost::asio::post( thread_pool->get_executor(), [this]() {
         arm_timer(boost::asio::high_resolution_timer::clock_type::now());
      });
      return "success";
   }

Here is the call graph for this function:

stop_generation()

void sysio::txn_test_gen_plugin_impl::stop_generation ( )

inline

Definition at line 408 of file txn_test_gen_plugin.cpp.

                          {
      if(!running)
         throw fc::exception(fc::invalid_operation_exception_code);
      timer->cancel();
      running = false;
      if( thread_pool )
         thread_pool->stop();
 
      ilog("Stopping transaction generation test");
 
      if (_txcount) {
         ilog("${d} transactions executed, ${t}us / transaction", ("d", _txcount)("t", _total_us / (double)_txcount));
         _txcount = _total_us = 0;
      }
   }

Member Data Documentation

_total_us

uint64_t sysio::txn_test_gen_plugin_impl::_total_us = 0

Definition at line 96 of file txn_test_gen_plugin.cpp.

_txcount

uint64_t sysio::txn_test_gen_plugin_impl::_txcount = 0

Definition at line 97 of file txn_test_gen_plugin.cpp.

act_a_to_b

action sysio::txn_test_gen_plugin_impl::act_a_to_b

Definition at line 430 of file txn_test_gen_plugin.cpp.

act_b_to_a

action sysio::txn_test_gen_plugin_impl::act_b_to_a

Definition at line 431 of file txn_test_gen_plugin.cpp.

batch

unsigned sysio::txn_test_gen_plugin_impl::batch

Definition at line 427 of file txn_test_gen_plugin.cpp.

newaccountA

name sysio::txn_test_gen_plugin_impl::newaccountA

Definition at line 102 of file txn_test_gen_plugin.cpp.

newaccountB

name sysio::txn_test_gen_plugin_impl::newaccountB

Definition at line 103 of file txn_test_gen_plugin.cpp.

newaccountT

name sysio::txn_test_gen_plugin_impl::newaccountT

Definition at line 104 of file txn_test_gen_plugin.cpp.

nonce_prefix

uint64_t sysio::txn_test_gen_plugin_impl::nonce_prefix

Definition at line 428 of file txn_test_gen_plugin.cpp.

running

bool sysio::txn_test_gen_plugin_impl::running {false}

Definition at line 424 of file txn_test_gen_plugin.cpp.

{false};

thread_pool

std::optional<sysio::chain::named_thread_pool> sysio::txn_test_gen_plugin_impl::thread_pool

Definition at line 100 of file txn_test_gen_plugin.cpp.

thread_pool_size

uint16_t sysio::txn_test_gen_plugin_impl::thread_pool_size

Definition at line 99 of file txn_test_gen_plugin.cpp.

timer

std::shared_ptr<boost::asio::high_resolution_timer> sysio::txn_test_gen_plugin_impl::timer

Definition at line 101 of file txn_test_gen_plugin.cpp.

timer_timeout

unsigned sysio::txn_test_gen_plugin_impl::timer_timeout

Definition at line 426 of file txn_test_gen_plugin.cpp.

txn_reference_block_lag

int32_t sysio::txn_test_gen_plugin_impl::txn_reference_block_lag

Definition at line 433 of file txn_test_gen_plugin.cpp.

---

The documentation for this struct was generated from the following file:

• plugins/txn_test_gen_plugin/txn_test_gen_plugin.cpp