Struct AtomicLockStats 

pub struct AtomicLockStats {

    pub contrib_wait_ns: AtomicU64,
    pub contrib_hold_ns: AtomicU64,
    pub node_factors_wait_ns: AtomicU64,
    pub node_factors_hold_ns: AtomicU64,
    pub factor_body_ns: AtomicU64,
    pub task_wall_ns: AtomicU64,
    pub ws_lock_wait_ns: AtomicU64,
    pub n_tasks: AtomicU64,
    pub phase_scaling_ns: AtomicU64,
    pub phase_permute_ns: AtomicU64,
    pub phase_symmetric_pattern_ns: AtomicU64,
    pub phase_tree_setup_ns: AtomicU64,
    pub phase_thread_ws_ns: AtomicU64,
    pub phase_leaves_ns: AtomicU64,
    pub phase_scope_ns: AtomicU64,
    pub phase_collect_ns: AtomicU64,
}

Lock-contention + phase telemetry for the rayon-parallel multifrontal driver. Atomic fields aggregate across worker threads via fetch_add. Driver-phase fields are written once by the calling thread and use atomics only for uniformity (no contention there). Snapshot via snapshot() after the factor returns. See NumericParams::parallel_telemetry.

Fields

contrib_wait_ns: AtomicU64

Cumulative time spent waiting to acquire contrib_blocks.

contrib_hold_ns: AtomicU64

Cumulative time spent holding contrib_blocks (excluding wait).

node_factors_wait_ns: AtomicU64

Cumulative time spent waiting to acquire node_factors_out.

node_factors_hold_ns: AtomicU64

Cumulative time spent holding node_factors_out (excluding wait).

factor_body_ns: AtomicU64

Cumulative time spent inside factor_one_supernode itself, excluding the lock brackets above. Aggregated across workers, so on an 8-thread run this can exceed wall time by ~8×.

task_wall_ns: AtomicU64

Cumulative wall time of the entire scope.spawn(...) closure body across all tasks (includes lock waits, factor_body, and per-task control flow like the snode lookup, fast-exit check, pending-decrement, and recursive spawn). Aggregated across workers. Compute task_wall_agg / T to compare against phase_scope_ns: the gap is rayon idle (worker waiting for an eligible task) or scope spawn/join overhead.

ws_lock_wait_ns: AtomicU64

Cumulative wait time on the per-worker Mutex<FactorWorkspace>. Expected to be near zero (each worker has its own slot); non-zero values mean rayon scheduled two tasks onto the same worker queue before the first finished (an event that would also imply a worker idle elsewhere).

n_tasks: AtomicU64

Number of parallel tasks executed.

phase_scaling_ns: AtomicU64

compute_scaling_with_cache + scaling_pivot_order build.

phase_permute_ns: AtomicU64

permute_csc_values (P·A·Pᵀ rebuild).

phase_symmetric_pattern_ns: AtomicU64

permuted.symmetric_pattern().

phase_tree_setup_ns: AtomicU64

is_root + parents + pending atomic counters + contrib_blocks / node_factors_out mutex setup.

phase_thread_ws_ns: AtomicU64

Per-worker FactorWorkspace provisioning, including local_contribs.resize_with(n_snodes, ...).

phase_leaves_ns: AtomicU64

Leaves collection (single linear pass over supernodes).

phase_scope_ns: AtomicU64

The rayon::scope itself — sums to the parallel hot-loop wall time plus rayon overhead. Compare against factor_body_ns / T to see worker utilization.

phase_collect_ns: AtomicU64

Final epilogue: node_factors_out.into_inner() + the postorder iteration that builds final_nodes and aggregates inertia.

Implementations

impl AtomicLockStats

pub fn snapshot(&self) -> ParallelLockStats

Trait Implementations

impl Debug for AtomicLockStats

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

Formats the value using the given formatter.

impl Default for AtomicLockStats

fn default() -> AtomicLockStats

Returns the “default value” for a type.