Struct BinaryBenchmarkConfig

pub struct BinaryBenchmarkConfig {
    pub current_dir: Option<PathBuf>,
    pub default_tool: Option<ValgrindTool>,
    pub env_clear: Option<bool>,
    pub envs: Vec<(OsString, Option<OsString>)>,
    pub exit_with: Option<ExitWith>,
    pub output_format: Option<OutputFormat>,
    pub sandbox: Option<Sandbox>,
    pub setup_parallel: Option<bool>,
    pub tools: Tools,
    pub tools_override: Option<Tools>,
    pub valgrind_args: RawArgs,
}

Available on crate feature api only.

The model for the configuration in binary benchmarks

This is the configuration which is built from the configuration of the UI and for internal use only.

Fields

current_dir: Option<PathBuf>

If some, set the the working directory of the benchmarked binary to this path

default_tool: Option<ValgrindTool>

The valgrind tool to run instead of the default callgrind

env_clear: Option<bool>

True if the environment variables should be cleared

envs: Vec<(OsString, Option<OsString>)>

The environment variables to set or pass through to the binary

exit_with: Option<ExitWith>

The ExitWith to set the expected exit code/signal of the benchmarked binary

output_format: Option<OutputFormat>

The configuration of the output format

sandbox: Option<Sandbox>

Run the benchmarked binary in a Sandbox or not

setup_parallel: Option<bool>

Run the setup function parallel to the benchmarked binary

tools: Tools

The valgrind tools to run in addition to the default tool

tools_override: Option<Tools>

The tool override at this configuration level

valgrind_args: RawArgs

The arguments to pass to all tools

Implementations

impl BinaryBenchmarkConfig

pub fn update_from_all<'a, T>(self, others: T) -> Self

where T: IntoIterator<Item = Option<&'a Self>>,

Update this configuration with all other configurations in the given order

pub fn resolve_envs(&self) -> Vec<(OsString, OsString)>

Resolve the environment variables and create key, value pairs out of them

This is done especially for pass-through environment variables which have a None value at first.

pub fn collect_envs(&self) -> Vec<(OsString, OsString)>

Collect all environment variables which don’t have a None value

Pass-through variables have a None value.

Trait Implementations

impl Clone for BinaryBenchmarkConfig

fn clone(&self) -> BinaryBenchmarkConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryBenchmarkConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BinaryBenchmarkConfig

fn default() -> BinaryBenchmarkConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BinaryBenchmarkConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BinaryBenchmarkConfig

fn eq(&self, other: &BinaryBenchmarkConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BinaryBenchmarkConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BinaryBenchmarkConfig