Struct BenchmarkCommand

pub struct BenchmarkCommand {
    pub dont_use_cross_chain_messages: bool,
    pub num_chain_groups: Option<usize>,
    pub tokens_per_chain: Amount,
    pub transactions_per_block: usize,
    pub fungible_application_id: Option<ApplicationId>,
    pub bps: usize,
    pub close_chains: bool,
    pub health_check_endpoints: Option<String>,
    pub wrap_up_max_in_flight: usize,
    pub confirm_before_start: bool,
    pub runtime_in_seconds: Option<u64>,
    pub delay_between_chain_groups_ms: Option<u64>,
}

Fields

dont_use_cross_chain_messages: bool

Wether to use cross chain messages in the transactions or not. This effectively sets the chain group size to 1.

num_chain_groups: Option<usize>

How many chain groups to use. If not provided, the number of CPUs will be used.

tokens_per_chain: Amount

How many tokens to assign to each newly created chain. These need to cover the transaction fees per chain for the benchmark.

transactions_per_block: usize

How many transactions to put in each block.

fungible_application_id: Option<ApplicationId>

The application ID of a fungible token on the wallet’s default chain. If none is specified, the benchmark uses the native token.

bps: usize

The fixed BPS (Blocks Per Second) rate that block proposals will be sent at.

close_chains: bool

If provided, will close the chains after the benchmark is finished. Keep in mind that closing the chains might take a while, and will increase the validator latency while they’re being closed.

health_check_endpoints: Option<String>

A comma-separated list of host:port pairs to query for health metrics. If provided, the benchmark will check these endpoints for validator health and terminate if any validator is unhealthy. Example: “127.0.0.1:21100,validator-1.some-network.linera.net:21100”

wrap_up_max_in_flight: usize

The maximum number of in-flight requests to validators when wrapping up the benchmark. While wrapping up, this controls the concurrency level when processing inboxes and closing chains.

confirm_before_start: bool

Confirm before starting the benchmark.

runtime_in_seconds: Option<u64>

How long to run the benchmark for. If not provided, the benchmark will run until it is interrupted.

delay_between_chain_groups_ms: Option<u64>

The delay between chain groups, in milliseconds. For example, if set to 200ms, the first chain group will start, then the second will start 200 ms after the first one, the third 200 ms after the second one, and so on. This is used for slowly ramping up the TPS, so we don’t pound the validators with the full TPS all at once.

Trait Implementations

impl Args for BenchmarkCommand

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl Clone for BenchmarkCommand

fn clone(&self) -> BenchmarkCommand

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for BenchmarkCommand

fn default() -> Self

Returns the “default value” for a type.

impl FromArgMatches for BenchmarkCommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Serialize for BenchmarkCommand

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.