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,
    pub client_mode: ClientMode,
    pub fan_out: Option<usize>,
    pub skip_message_processing: bool,
    pub max_incoming_bundles_per_block: Option<usize>,
    pub mixed_self_transfers: bool,
    pub light_certificates: bool,
}

Options controlling the behavior of the benchmark command.

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.

client_mode: ClientMode

Which client to drive the chains with.

fan_out: Option<usize>

How many distinct destination chains each chain sends to. Unset means every other benchmarked chain, so cross-chain fan-out grows with --num-chains and cannot be varied on its own; setting it pins fan-out while everything else is held fixed.

skip_message_processing: bool

Keep sending cross-chain messages but never drain the inboxes they fill, isolating the sending side. Inboxes then grow for the whole run, which is fine for a short benchmark and is not a realistic steady state. --client-mode lite only.

max_incoming_bundles_per_block: Option<usize>

The maximum number of incoming message bundles to drain into each block, on top of its own operations. Defaults to twice the block’s operation count, so a backlog is spread over several blocks instead of one huge one. --client-mode lite only.

mixed_self_transfers: bool

Mix self-transfers in with the cross-chain ones, so roughly half the traffic stays on its own chain. Which half is random, not alternating: the generator shuffles its destination list, so this sets the ratio rather than an order. Without this a chain only ever sends elsewhere; with --fan-out 0 it only ever sends to itself, and this flag is then ignored. Under --single-destination-per-block the mix applies per block rather than per transaction, so whole blocks are self-transfers.

light_certificates: bool

Broadcast each confirmed certificate in its compact, value-free form (hash plus signatures) where possible. A validator that has forgotten the value transparently gets a retry with the full certificate. --client-mode lite only.

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 duplicate 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.