Struct ExperimentalOptions 

pub struct ExperimentalOptions {

    pub use_sched_fifo: Option<bool>,
    pub use_syscall_counters: Option<bool>,
    pub use_object_counters: Option<bool>,
    pub use_preload_libc: Option<bool>,
    pub use_preload_openssl_rng: Option<bool>,
    pub use_preload_openssl_crypto: Option<bool>,
    pub use_memory_manager: Option<bool>,
    pub use_cpu_pinning: Option<bool>,
    pub use_worker_spinning: Option<bool>,
    pub runahead: Option<NullableOption<Time<TimePrefix>>>,
    pub use_dynamic_runahead: Option<bool>,
    pub socket_send_buffer: Option<Bytes<SiPrefixUpper>>,
    pub socket_send_autotune: Option<bool>,
    pub socket_recv_buffer: Option<Bytes<SiPrefixUpper>>,
    pub socket_recv_autotune: Option<bool>,
    pub interface_qdisc: Option<QDiscMode>,
    pub strace_logging_mode: Option<StraceLoggingMode>,
    pub max_unapplied_cpu_latency: Option<Time<TimePrefix>>,
    pub unblocked_syscall_latency: Option<Time<TimePrefix>>,
    pub unblocked_vdso_latency: Option<Time<TimePrefix>>,
    pub scheduler: Option<Scheduler>,
    pub report_errors_to_stderr: Option<bool>,
    pub use_new_tcp: Option<bool>,
    pub native_preemption_enabled: Option<bool>,
    pub native_preemption_native_interval: Option<Time<TimePrefix>>,
    pub native_preemption_sim_interval: Option<Time<TimePrefix>>,
}

Fields

use_sched_fifo: Option<bool>

Use the SCHED_FIFO scheduler. Requires CAP_SYS_NICE. See sched(7), capabilities(7)

use_syscall_counters: Option<bool>

Count the number of occurrences for individual syscalls

use_object_counters: Option<bool>

Count object allocations and deallocations. If disabled, we will not be able to detect object memory leaks

use_preload_libc: Option<bool>

Preload our libc library for all managed processes for fast syscall interposition when possible.

use_preload_openssl_rng: Option<bool>

Preload our OpenSSL RNG library for all managed processes to mitigate non-deterministic use of OpenSSL.

use_preload_openssl_crypto: Option<bool>

Preload our OpenSSL crypto library for all managed processes to skip some crypto operations (may speed up simulation if your CPU lacks AES-NI support, but can cause bugs so do not use unless you know what you’re doing).

use_memory_manager: Option<bool>

Use the MemoryManager in memory-mapping mode. This can improve performance, but disables support for dynamically spawning processes inside the simulation (e.g. the fork syscall).

use_cpu_pinning: Option<bool>

Pin each thread and any processes it executes to the same logical CPU Core to improve cache affinity

use_worker_spinning: Option<bool>

Each worker thread will spin in a sched_yield loop while waiting for a new task. This is ignored if not using the thread-per-core scheduler.

runahead: Option<NullableOption<Time<TimePrefix>>>

If set, overrides the automatically calculated minimum time workers may run ahead when sending events between nodes

use_dynamic_runahead: Option<bool>

Update the minimum runahead dynamically throughout the simulation.

socket_send_buffer: Option<Bytes<SiPrefixUpper>>

Initial size of the socket’s send buffer

socket_send_autotune: Option<bool>

Enable send window autotuning

socket_recv_buffer: Option<Bytes<SiPrefixUpper>>

Initial size of the socket’s receive buffer

socket_recv_autotune: Option<bool>

Enable receive window autotuning

interface_qdisc: Option<QDiscMode>

The queueing discipline to use at the network interface

strace_logging_mode: Option<StraceLoggingMode>

Log the syscalls for each process to individual “strace” files

max_unapplied_cpu_latency: Option<Time<TimePrefix>>

Max amount of execution-time latency allowed to accumulate before the clock is moved forward. Moving the clock forward is a potentially expensive operation, so larger values reduce simulation overhead, at the cost of coarser time jumps. Note also that accumulated-but-unapplied latency is discarded when a thread is blocked on a syscall.

unblocked_syscall_latency: Option<Time<TimePrefix>>

Simulated latency of an unblocked syscall. For efficiency Shadow only actually adds this latency if and when max_unapplied_cpu_latency is reached.

unblocked_vdso_latency: Option<Time<TimePrefix>>

Simulated latency of a vdso “syscall”. For efficiency Shadow only actually adds this latency if and when max_unapplied_cpu_latency is reached.

scheduler: Option<Scheduler>

The host scheduler implementation, which decides how to assign hosts to threads and threads to CPU cores

report_errors_to_stderr: Option<bool>

When true, report error-level messages to stderr in addition to logging to stdout.

use_new_tcp: Option<bool>

Use the rust TCP implementation

native_preemption_enabled: Option<bool>

When true, and when managed code runs for an extended time without returning control to shadow (e.g. by making a syscall), shadow preempts the managed code and moves simulated time forward. This can be used to escape “pure-CPU busy-loops”, but isn’t usually needed, breaks simulation determinism, and significantly affects simulation performance.

native_preemption_native_interval: Option<Time<TimePrefix>>

When native_preemption_enabled is true, amount of native CPU-time to wait before preempting managed code that hasn’t returned control to shadow. Only supports microsecond granularity, and values below 1 microsecond are rejected.

native_preemption_sim_interval: Option<Time<TimePrefix>>

When native_preemption_enabled is true, amount of simulated time to consume after native_preemption_native_interval has elapsed without returning control to shadow.

Implementations

impl ExperimentalOptions

pub fn with_defaults(self, default: Self) -> Self

Replace unset (None) values of base with values from default.

Trait Implementations

impl Args for ExperimentalOptions

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 ExperimentalOptions

fn clone(&self) -> ExperimentalOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommandFactory for ExperimentalOptions

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for ExperimentalOptions

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

Formats the value using the given formatter.

impl Default for ExperimentalOptions

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExperimentalOptions

where ExperimentalOptions: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromArgMatches for ExperimentalOptions

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 JsonSchema for ExperimentalOptions

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Merge for ExperimentalOptions

fn merge(&mut self, other: Self)

Merge another object into this object.

impl Parser for ExperimentalOptions

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl Serialize for ExperimentalOptions

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

where __S: Serializer,

Serialize this value into the given Serde serializer.