Struct Config 

pub struct Config {

    pub virtualize_time: bool,
    pub virtualize_cpuid: bool,
    pub cpuid_virtualized_by_backend: bool,
    pub backend_supports_madvise: bool,
    pub discover_live_file_metadata: bool,
    pub use_thread_local_clock_reads: bool,
    pub detect_host_clock_futex_timeouts: bool,
    pub syscall_clobbers_virtualized_by_backend: bool,
    pub cancel_killed_thread_rpcs: bool,
    pub backend_reports_physical_process_exits: bool,
    pub backend_serializes_fork_children: bool,
    pub backend_dispatches_thread_tools: bool,
    pub backend_tracks_process_children: bool,
    pub backend_runs_exit_robust_list: bool,
    pub backend_requires_thread_directed_process_signals: bool,
    pub backend_is_kvm: bool,
    pub kvm_shared_dequeue_timers: bool,
    pub backend_supports_parked_write_signal_interruption: bool,
    pub backend_virtualizes_capability_prctls: bool,
    pub backend_defers_vfork_child_registration: bool,
    pub epoch: DateTime<Utc>,
    pub seed: u64,
    pub rng_seed: Option<u64>,
    pub fuzz_seed: Option<u64>,
    pub clock_multiplier: Option<f64>,
    pub virtualize_metadata: bool,
    pub mountinfo_root_rewrites: Vec<MountInfoRootRewrite>,
    pub mountinfo_device_rewrites: Vec<(u64, u64)>,
    pub mountinfo_mount_ids: Vec<u64>,
    pub mountinfo_mount_ids_captured: bool,
    pub fdinfo_unlisted_mount_ids: Vec<u64>,
    pub sequentialize_threads: bool,
    pub runs_post_fork: RunsPostFork,
    pub passthru_opt: bool,
    pub imprecise_timers: bool,
    pub chaos: bool,
    pub fuzz_futexes: bool,
    pub chaos_target_races: bool,
    pub chaos_per_thread_slowdown: bool,
    pub chaos_slowdown_max_factor: f64,
    pub chaos_epoch_length_ns: u64,
    pub record_preemptions: bool,
    pub record_preemptions_to: Option<PathBuf>,
    pub replay_preemptions_from: Option<PathBuf>,
    pub replay_schedule_from: Option<PathBuf>,
    pub replay_exhausted_panic: bool,
    pub die_on_desync: bool,
    pub stacktrace_event: Vec<(u64, Option<PathBuf>)>,
    pub stacktrace_signal: Option<SigWrapper>,
    pub preemption_stacktrace: bool,
    pub preemption_stacktrace_log_file: Option<PathBuf>,
    pub deterministic_io: bool,
    pub panic_on_unsupported_syscalls: bool,
    pub exit_on_unsupported_syscall: bool,
    pub shutdown_on_unsupported_syscall: bool,
    pub unsupported_syscall_report_fd: Option<i32>,
    pub panic_on_rcb_overshoot: bool,
    pub has_uts_namespace: bool,
    pub replay_data: Option<PathBuf>,
    pub kill_daemons: bool,
    pub gdbserver: bool,
    pub gdbserver_port: u16,
    pub max_timeslice: Option<NonZero<u64>>,
    pub target_timeslice: Option<NonZero<u64>>,
    pub sigint_instakill: bool,
    pub warn_non_zero_binds: bool,
    pub sched_heuristic: SchedHeuristic,
    pub sched_seed: Option<u64>,
    pub network_trace: NetworkTraceConfig,
    pub sched_sticky_random_param: f64,
    pub recordreplay_modes: bool,
    pub stop_after_turn: Option<u64>,
    pub stop_after_iter: Option<u64>,
    pub debug_externalize_sockets: bool,
    pub debug_futex_mode: BlockingMode,
    pub no_rcb_time: bool,
    pub detlog_heap: bool,
    pub detlog_stack: bool,
    pub detlog_regs: bool,
    pub detlog_io_buffers: bool,
    pub detlog_regs_cadence: u64,
    pub sysinfo_uptime_offset: u64,
    pub memory: u64,
    pub interrupt_at: Vec<(DetPid, u64)>,
    pub happens_before: Option<HappensBeforeProgram>,
}

Configuration options for detcore.

Fields

virtualize_time: bool

Disable virtual/logical time. Note that virtual time is required for virtual metadata.

virtualize_cpuid: bool

Disable virtual cpuid

cpuid_virtualized_by_backend: bool

The execution backend installs a deterministic CPUID policy without instruction faults.

backend_supports_madvise: bool

The execution backend implements guest-visible madvise semantics.

discover_live_file_metadata: bool

The execution backend runs Detcore inside the guest and can inspect its live descriptors.

use_thread_local_clock_reads: bool

Legacy serialized setting retained for record compatibility. Guest-visible wall and monotonic clocks always use the coordinator’s virtual-time domain.

detect_host_clock_futex_timeouts: bool

Direct guest clock reads may bypass backend virtualization, so absolute futex deadlines must be classified against both the host and logical clocks.

syscall_clobbers_virtualized_by_backend: bool

The execution backend already returns deterministic values for registers clobbered by a syscall instruction, so Detcore must not write the complete register set back afterward.

cancel_killed_thread_rpcs: bool

Logically killed guest threads need an explicit scheduler response because the backend does not rely on ptrace’s kernel-driven exit-group teardown.

backend_reports_physical_process_exits: bool

The execution backend reports final physical process exits after logical tool cleanup, so Detcore can prevent virtual timers from overtaking kernel child-exit publication.

backend_serializes_fork_children: bool

The execution backend completes forked process children before returning to the parent.

backend_dispatches_thread_tools: bool

The execution backend dispatches cloned thread syscalls through this tool.

backend_tracks_process_children: bool

The backend reports every process child through Detcore’s child-registration protocol. When true, an empty scheduler selection is authoritative ECHILD rather than a reason to fall back to backend-specific wait filtering.

backend_runs_exit_robust_list: bool

The execution backend completes Linux’s robust-list cleanup before its task-exit callback lets another modeled thread run. Detcore still wakes waiters parked in its precise futex model, but it leaves the owner-word transition to Linux so it remains atomic.

backend_requires_thread_directed_process_signals: bool

The backend cannot execute process-directed signal syscalls using Detcore’s guest PID and therefore requires Detcore to translate an unambiguous process target to a specific thread.

backend_is_kvm: bool

Identifies KVM for its run-installed process alarm control.

kvm_shared_dequeue_timers: bool

Startup-only real-timer policy using acknowledged shared signal dequeues.

backend_supports_parked_write_signal_interruption: bool

The backend can wake a scheduler-managed pipe write for a cross-task signal while preserving Linux signal-mask, disposition, and syscall-restart behavior.

backend_virtualizes_capability_prctls: bool

The execution backend virtualizes capability bounding-set and ambient-capability state.

backend_defers_vfork_child_registration: bool

The execution backend does not keep a CLONE_VFORK parent blocked inside the injected clone(2) until the child registers. The ptrace backend relies on the kernel to suspend a vfork parent until the child execs or exits, so the child always registers its vfork barrier before the parent asks to continue. Out-of-process backends such as KVM service the clone by deferring the child spawn, so the child registers only after the parent posts its continuation. When this is set the scheduler keeps an unfulfilled vfork barrier in place at parent continuation (waiting for the late child) instead of treating it as a failed clone.

epoch: DateTime<Utc>

Epoch of the logical time.

This is the datetime from which all time and date modtimes begin and monotonically increase. It is in RFC3339 format such as 2026-01-01T00:00:00Z. The stable default here is for library callers and wire-format fixtures; the hermit run and hermit oci run commands replace an omitted CLI default with one host wall-clock sample taken before backend dispatch.

seed: u64

Use this number to seed the PRNG randomness for both RNG and scheduler. This acts as a global fallback in case either sched_seed or rng-seed are not explicitly specified

rng_seed: Option<u64>

Use this number to seed the PRNG that supplies randomness to the guest. This supplies guest system calls that expose randomness, as well as the /dev/[u]random files. It does not affect the rdrand instruction, which is disabled in the guest.

fuzz_seed: Option<u64>

Seeds the PRNG which drives syscall response fuzzing (i.e. chaotically exercising syscall nondeterminism). Like other seeds, this is initialized from the --seed if not specifically provided.

clock_multiplier: Option<f64>

Logical clock multiplier. Values above one make time appear to go faster within the sandbox.

virtualize_metadata: bool

Disable substitution of virtual (deterministic) file metadata in lieu of the real metadata returned by stat/statx. This also preserves raw mountinfo device numbers so those interfaces continue to agree. Raw device values are host/filesystem observations and are not promised to reproduce across machines. Virtual metadata implies virtualize_time.

mountinfo_root_rewrites: Vec<MountInfoRootRewrite>

Proven Hermit-owned mount roots to hide from /proc/*/mountinfo.

This is runtime provenance, not a user option. serde(default) keeps older serialized configurations compatible and makes backends which do not use the common container setup explicitly receive no rewrite claim.

mountinfo_device_rewrites: Vec<(u64, u64)>

Backend-proven pairs of (mountinfo raw device, stat/statx raw device).

A backend may synthesize mountinfo independently from its pathname metadata implementation. These pairs state that the two raw numbers describe the same filesystem, so Detcore can feed both surfaces through one device identity. The pairs are runtime provenance, not a user option; an absent pair must never be inferred from numeric coincidence.

mountinfo_mount_ids: Vec<u64>

Recording/container namespace mount IDs in canonical row order.

Detcore uses this same mapping for /proc/*/mountinfo and /proc/*/fdinfo/*. It is runtime provenance rather than a user option; replay retains recording-time raw IDs because its read events contain recording-time kernel bytes.

mountinfo_mount_ids_captured: bool

Whether mountinfo_mount_ids is an exact producer-owned snapshot.

The distinction matters for an empty mountinfo file: an absent snapshot asks Detcore to observe the completed guest namespace, while a captured empty snapshot must remain empty during replay.

fdinfo_unlisted_mount_ids: Vec<u64>

Raw fdinfo mount IDs absent from mountinfo, in first-observation order.

Recording persists this producer-observed order so replay does not derive identities from its fresh namespace or launch descriptor shape.

sequentialize_threads: bool

Sequentialize thread execution deterministically.

runs_post_fork: RunsPostFork

Choose which side of an ordinary fork/clone runs first after the child is registered. Random choices are deterministic under --sched-seed.

passthru_opt: bool

Use the optimized partial syscall subscription set instead of intercepting every syscall. This permits unlisted syscalls to bypass Detcore and therefore weakens deterministic accounting; leave it disabled for fail-closed execution.

imprecise_timers: bool

In chaos mode, uses much cheaper approximate preemption timers. Only makes sense when recording preemptions for later (precise) replay.

chaos: bool

Schedule threads chaotically.

The behavior of this flag is subject to change. Current behavior is to randomize thread priorities at every logical timeslice. Other randomization strategies are possible with --sched-heuristic.

Thread scheduling remains deterministic, determined by the random seed.

fuzz_futexes: bool

Uses the --fuzz-seed to generate randomness and fuzz nondeterminism in the futex semantics.

chaos_target_races: bool

Targeted chaos: bias scheduling toward known concurrency race patterns instead of exploring interleavings uniformly. At the scheduler’s existing nondeterminism points it uses --fuzz-seed to (a) deliver a process-directed signal to a randomly chosen thread in the group (signal timing races) and (b) randomize the requeue position of a force-unblocked thread (lock-ordering / wakeup races). Only takes effect with --chaos; like the rest of chaos mode it remains reproducible under a fixed seed.

chaos_per_thread_slowdown: bool

Reproducible per-thread slowdown factors for chaos mode. A factor greater than one makes each RCB consume proportionally more virtual time, while a factor below one makes it consume less. Thus scheduling deadlines and the guest-visible virtual clock describe the same slowed execution rather than applying an out-of-band scheduling bias. The factor is a pure function of scheduler seed, stable deterministic thread id, and chaos epoch. A fixed seed therefore reproduces both timing and interleavings.

chaos_slowdown_max_factor: f64

Maximum ratio between the slowest and fastest per-thread slowdown factor for --chaos-per-thread-slowdown. Each thread’s factor is drawn log-uniformly from [1/R, R] where R is this value. Must fit the Q32 virtual-time representation and be >= 1.0; 1.0 disables the spread.

chaos_epoch_length_ns: u64

Length of a deterministic slowdown epoch in elapsed per-thread logical nanoseconds. At the first scheduler commit at or after each boundary the factor is redrawn as factor(seed, stable_dettid, epoch). This is never wall time. 0 means one epoch for the entire run, making constant slowdown the single-epoch special case. Recorded preemption artifacts carry exact epoch transitions and factors for replay. Inert without chaos slowdown.

record_preemptions: bool

Record the timing of preemption events for future replay or experimentation. This is only useful in chaos modes.

record_preemptions_to: Option<PathBuf>

File to write the record of preemptions (in JSON). Implies --record-preemptions.

replay_preemptions_from: Option<PathBuf>

JSON file to read recorded preemptions from. When --chaos mode is activated, these recorded preemption points take the place of randomized scheduling decisions.

replay_schedule_from: Option<PathBuf>

File to read recorded schedule trace from. This execution will replay the schedule verbatim from the file.

replay_exhausted_panic: bool

If we run out of events while replaying a schedule, treat that as a fatal event and panic, rather than continuing execution.

die_on_desync: bool

When playing a schedule trace from disk, bail out on the first time we desynchronize from the event sequence specified in the trace.

stacktrace_event: Vec<(u64, Option<PathBuf>)>

Given schedule events traced on recording or replaying, print the stack trace at the moment after the Nth event in the trace. Optionally, provide an output file into which the stack trace will be printed, otherwise it goes to stderr.

stacktrace_signal: Option<SigWrapper>

Internal feature used to signal the guest with SIGINT at every --stacktrace-event, this is in-lieu of using hermit’s internal stacktrace printing facility, to instead have an external debugger handle it. Accepts either signal names or numbers.

preemption_stacktrace: bool

Deprecated: Print a stacktrace each time the program is preempted. Only makes sense in --chaos mode and typically goes with preemption recording/replaying.

preemption_stacktrace_log_file: Option<PathBuf>

File to write preemption stacktraces to. Implies --preemption-stacktrace. If a log file is not specified, preemption stacktraces are printed to stderr by default.

deterministic_io: bool

Enable deterministic IO by reassuring we always read/write the maximum possible bytes from IO syscalls. There might be cases that read/write syscalls return less bytes than requests. Detcore, makes an effort to request additional bytes until we reach the ones requested or EOF.

panic_on_unsupported_syscalls: bool

Fail immediately on unsupported syscalls instead of forwarding them. Ordinary hermit run enables this policy; compatibility requires the explicit --allow-unsupported-syscalls opt-out.

exit_on_unsupported_syscall: bool

Return a typed Tool error instead of unwinding through a backend callback.

shutdown_on_unsupported_syscall: bool

Terminate the whole tracer when an unsupported syscall is observed.

unsupported_syscall_report_fd: Option<i32>

Internal inherited file descriptor used to aggregate unsupported syscalls.

panic_on_rcb_overshoot: bool

Panic when a precise PMU timer overshoots its expected RCB target instead of logging an error and continuing through normal timer handling. Intended for Detcore debugging.

has_uts_namespace: bool

Internal: Set to true if we’re inside a UTS namespace.

replay_data: Option<PathBuf>

Internal: Path to the replay data folder.

kill_daemons: bool

Kill all remaining tasks iff daemons are the only ones left. Disabled by default.

gdbserver: bool

Start gdbserver on gdbserver_port for remote debugging Disabled by default.

gdbserver_port: u16

port gdbserver listening on

max_timeslice: Option<NonZero<u64>>

Configure the maximum time a guest thread may run without returning to Detcore. This is measured in virtual nanoseconds and enforced with retired conditional branch (RCB) counting. --preemption-timeout is retained as a deprecated alias.

Set this to disabled or 0 to disable PMU-backed preemption. Positive values must be at least one RCB (10 virtual nanoseconds at the default clock multiplier) and require user-space hardware performance counters.

target_timeslice: Option<NonZero<u64>>

Target logical timeslice checked at syscall boundaries, in virtual nanoseconds. This avoids PMU preemption for workloads that enter the kernel frequently. Omit this option to use only --max-timeslice.

sigint_instakill: bool

Shut down immediately upon SIGINT, rather than letting the guest handle it.

warn_non_zero_binds: bool

Warn if binds are non-zero.

sched_heuristic: SchedHeuristic

Apply a specialized scheduling heuristic which may help exercise certain bugs.

sched_seed: Option<u64>

Use this number to seed the PRNG that supplies randomness to the scheduler.

network_trace: NetworkTraceConfig

Reserved configuration for a schedule-independent external-network trace.

This is inert until a recorder/replayer integration explicitly consumes it. In particular, its perturbation seed has no fallback to seed or sched_seed.

sched_sticky_random_param: f64

Configure the probability for the Sticky Random scheduler to stay in a thread. For value 0.0, we are behaving like Random. For value 1.0, we are behaving like a DFS, where the same thread is always picked as long as it is available in the Run queue. After this thread is exhausted, the next thread will be chosen randomly. For value 0.5, we have a 50/50 chance to pick the same thread.

recordreplay_modes: bool

Internal: An internal flag for indicating to Detcore whether we are in hermit record or hermit replay mode. This is necessary because there are DIFFERENT global invariants in record mode (e.g. files dont exist). If we move to a chroot model and reproduce more, recording less, then this flag should become obsolete.

stop_after_turn: Option<u64>

Internal: debugging option to stop execution after a specific scheduler commit, aka turn number (non-negative integer). This only makes sense if --sequentialize-threads is specified, as the scheduler is otherwise not engaged.

stop_after_iter: Option<u64>

Internal: debugging option to stop execution after a scheduler loop iteration (non-negative integer). This only makes sense if --sequentialize-threads is specified, as the scheduler is otherwise not engaged.

debug_externalize_sockets: bool

Internal: Debugging option to treat all sockets as mysterious external, nondeterministic entities, rather than container-internal and determinstically scheduled.

debug_futex_mode: BlockingMode

Internal: Debugging option to change how futexes are implemented, either precisely modeled by hermit, by polling the kernel with non-blocking futex operations, or treated as external (nondeterministic) operations which unblock at imprecise times.

no_rcb_time: bool

Do not count the retired conditional branches (RCBs) of each thread towards its logical time. Instead, count each checkin with the scheduler as a fixed increment to logical time. Even when this option is set, HW RCB performance counters may still be enabled if a max-timeslice is specified.

detlog_heap: bool

An option to enable logging the hash of heap memory maps for the purpose of determinism checking

detlog_stack: bool

An option to enable logging the hash of stack memory maps for the purpose of determinism checking

THIS HASH COVERS argv AND THE ENVIRONMENT, which the kernel places at the top of the initial process stack. Two runs whose command lines differ by a single character therefore produce different stack hashes from the first sample, even when the command lines are the same LENGTH and every stack address matches. Measured: equal-length-but-different argv diverged the hash 14 records in, while byte-identical argv held it for 5023 records.

Holding a run-directory name to a fixed WIDTH is a sufficient control when only addresses matter, and is NOT sufficient here. Comparing two runs under this flag requires byte-identical argv and environment; otherwise the first divergence you find is your own input.

detlog_regs: bool

Log a hash of the guest REGISTER FILE at guest-logical-control points, for determinism checking. stdout, the INFO log, the stack and the heap are all hashed today; the register file is not, so two backends can differ in register state and every existing check still reports parity.

SAMPLED ONLY AT GUEST-LOGICAL-CONTROL POINTS – see Detcore::detlog_registers. Registers are NOT sampled inside a tool handler: a backend running its handler in-guest executes code the ptrace reference never executes, so a difference there is correct behaviour, not a determinism bug.

detlog_io_buffers: bool

Log a hash of each syscall’s OUTPUT BUFFER, taken at the syscall boundary from the address and length in the syscall’s own arguments.

WHAT IT SEES THAT THE MAPPING HASHES DO NOT. --detlog-heap and --detlog-stack hash a whole named mapping, so their coverage is decided by where the guest happened to ALLOCATE a buffer. Measured, three runs per cell, same netlink exchange with only the receive buffer’s home changed: a [stack] buffer is missed by --detlog-heap, a [heap] buffer is missed by --detlog-stack, and a BSS/static or anonymous-mmap buffer is missed by BOTH even with both enabled. Anonymous mmap is where glibc puts any malloc above the 128 KiB M_MMAP_THRESHOLD. Reading the extent out of the syscall arguments makes the buffer’s home irrelevant.

WHY IT IS NOT REDUNDANT WITH --verify. A syscall whose buffer is a bare pointer in Reverie prints the ADDRESS, not the contents, so a recvmsg returning a stable Ok(1468) whose payload varies produces a character-identical record and --verify reports bitwise_parity: true. 44.1% of the syscalls in a QEMU/Linux boot move bytes through such a buffer.

COST is proportional to bytes actually moved, NOT to syscall count or mapping size: ~0.75 s per GB of guest I/O. A QEMU/Linux boot moves 139.1 MB through these buffers, against the 10.9 TB --detlog-heap hashes over the same run.

NAME IS PROVISIONAL: io-buffers is the owner’s candidate and is not settled.

ON BY DEFAULT. It was opt-in until 2026-08-24, and opt-in made the determinism gate weaker than its name: with the hash absent, the netlink recvmsg above compares equal and --verify reports success. A check that must be requested is not a standard. The opt-out exists for the deliberate case (bulk I/O where the cost matters and content parity is not the question), not as the ordinary setting.

COST OF THE DEFAULT, measured 2026-08-24 on a 316-core x86_64 Linux build host: a typical small test guest pays about ONE MILLISECOND (/bin/true 0.029s -> 0.030s, /bin/ls 0.041s -> 0.041s, 8 runs each). 64 MiB through cat costs +0.07-0.10s in a RELEASE build, which is the ~1.1-1.6 s/GB matching the figure quoted above. The same workload in a DEBUG build costs +3.4s, roughly 50x more, because the hash loop is unoptimized – so a debug-built node moving tens of megabytes is the one place the default is felt.

detlog_regs_cadence: u64

Sampling cadence for --detlog-regs: hash every Nth guest-logical-control point.

COST TIER. 1 (the default) is the FULL tier – every control point hashed – and is what a short test should use. Measured cost at this scale is within run-to-run noise: /bin/true (49 control points), wc -l /etc/passwd (135) and a 5-iteration shell loop (195) were 0.04-0.07s with the flag on and the same with it off. A larger N is the SPOT-CHECK tier for runs where full hashing is too expensive; it trades detection latency for cost, since a divergence is only seen at the next sampled point. Every emitted line records the tier it was produced under, so a cell can state which tier it met instead of leaving it implicit.

sysinfo_uptime_offset: u64

Configure a time offset (in seconds) between a container OS considered booted and a guest is executed This primarily affects ‘sysinfo’ syscall’s ‘uptime’ field reporting

memory: u64

Configure memory available for the container. Takes a number of bytes, or shorthand (e.g. “1GB”). Right now this doesn’t enforce an upper bound, but does affect the amount of memory reported to the guest.

interrupt_at: Vec<(DetPid, u64)>

Configure extra interrupt points based on thread id and rcb counter. Detcore will raise a precise timer for this RCB whenever it detects that current current thread timeslice intercects any of the interrupt points specified

happens_before: Option<HappensBeforeProgram>

Resolved happens-before program: deterministic ordering edges between anchored events (see detcore_model::happens_before). This is populated programmatically by hermit-cli after loading and resolving a --happens-before spec against the guest binary; it is not a direct CLI flag and is not serialized (it is reconstructed from the spec file each run, so #[serde(skip)] avoids requiring serde on Sysno-bearing positions and keeps save-config output stable). The scheduler enforces these edges only when sequentialize_threads is set.

Implementations

impl Config

pub fn has_default_epoch(&self) -> bool

Whether the epoch is the stable library default omitted by Display.

pub fn capture_epoch_from_host_time(&mut self, now: SystemTime)

Replace the stable library/test default with the host wall clock captured by the outer hermit run invocation. The caller owns the single host-clock read boundary; all guest clock and metadata observations consume the resulting concrete epoch.

pub fn minimum_max_timeslice_nanos(&self) -> u64

Smallest PMU-backed maximum representable by one RCB at this clock multiplier.

pub fn validate_invariants(&self)

Check invariants that must hold at every execution boundary without mutating the config.

pub fn validate(&mut self)

Sanity check the flags, and update any wherever flag B is implied by A.

pub fn use_rcb_time(&self) -> bool

Should we use RCB in computing logical time?

The answer is NO either if --no-rcb-time is specified or if HW counters are disabled by setting --max-timeslice=disabled.

pub fn use_nonblocking_sockets(&self) -> bool

Should we convert sockets to SOCK_NONBLOCK?

pub fn should_trace_schedevent(&self) -> bool

Should we call trace_schedevent to trace each SchedEvent? This applies to both record and replay for scheduled events.

pub fn interrupts_for_thread(&self, thread_id: DetPid) -> BTreeSet<u64>

Returns manual interuption points for a given thread

impl Config

pub fn from_env() -> Config

Construct the config using environment variables only, not CLI args.

pub fn rng_seed(&self) -> u64

Returns effective “rng-seed” parameter taking in account “seed” parameter if former isn’t specified

pub fn fuzz_seed(&self) -> u64

Returns the fuzz_seed, as specified by the user or defaulting to the primary seed if unspecified.

pub fn sched_seed(&self) -> u64

Returns effective “sched-seed” parameter taking in account “seed” parameter if former isn’t specified

Trait Implementations

impl Args for Config

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 Config

fn clone(&self) -> Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommandFactory for Config

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 Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Config

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>( __deserializer: __D, ) -> Result<Config, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Config

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

Formats the value using the given formatter.

impl FromArgMatches for Config

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

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Config, 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 Parser for Config

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 Config

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

where __S: Serializer,

Serialize this value into the given Serde serializer.