Struct BenchmarkOptions

pub struct BenchmarkOptions {

    pub num_chains: 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_chains_ms: Option<u64>,
    pub config_path: Option<PathBuf>,
    pub single_destination_per_block: bool,
}

Fields

num_chains: usize

How many chains to use.

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_chains_ms: Option<u64>

The delay between chains, in milliseconds. For example, if set to 200ms, the first chain 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.

config_path: Option<PathBuf>

Path to YAML file containing chain IDs to send transfers to. If not provided, only transfers between chains in the same wallet.

single_destination_per_block: bool

Transaction distribution mode. If false (default), distributes transactions evenly across chains within each block. If true, sends all transactions in each block to a single chain, rotating through chains for subsequent blocks.

Trait Implementations

impl Args for BenchmarkOptions

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 BenchmarkOptions

fn clone(&self) -> BenchmarkOptions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for BenchmarkOptions

fn default() -> Self

Returns the “default value” for a type.

impl FromArgMatches for BenchmarkOptions

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 BenchmarkOptions

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

where __S: Serializer,

Serialize this value into the given Serde serializer.