Struct Workspace 

pub struct Workspace {

    pub tmp1: Vec<S>,
    pub tmp2: Vec<S>,
    pub pipelined_w: Vec<S>,
    pub pipelined_wtmp: Vec<S>,
    pub pipelined_payload: Vec<R>,
    pub bridge: BridgeScratch,
    pub bridge_tmp: Vec<S>,
    pub q_s: Vec<Vec<S>>,
    pub z_s: Vec<Vec<S>>,
    pub h_s: Vec<Vec<S>>,
    pub q: Vec<Vec<S>>,
    pub z: Vec<Vec<S>>,
    pub h: Vec<Vec<S>>,
    pub v_mem: Vec<S>,
    pub z_mem: Vec<S>,
    pub h_mem: Vec<S>,
    pub givens_col_scratch: Vec<S>,
    pub cs: Vec<R>,
    pub sn: Vec<S>,
    pub g: Vec<S>,
    pub blk_scratch: Vec<S>,
    pub blk_payload: Vec<R>,
    pub block_buf: Option<BlockVec>,
    pub tsqr: Option<TsqrWorkspace>,
    pub gmres_sstep: Option<GmresSStepWorkspace>,
    pub gmres_recycle: RecyclingSpace,
    pub reduction: ReductOptions,
    pub reduction_engine: Option<Arc<dyn ReductionEngine>>,
    pub send_arena: BufferPool<u8>,
    pub recv_arena: BufferPool<u8>,
    pub packet_arena: BufferPool<u8>,
    /* private fields */
}

Fields

tmp1: Vec<S>

tmp2: Vec<S>

pipelined_w: Vec<S>

pipelined_wtmp: Vec<S>

pipelined_payload: Vec<R>

bridge: BridgeScratch

bridge_tmp: Vec<S>

q_s: Vec<Vec<S>>

z_s: Vec<Vec<S>>

h_s: Vec<Vec<S>>

q: Vec<Vec<S>>

z: Vec<Vec<S>>

h: Vec<Vec<S>>

v_mem: Vec<S>

z_mem: Vec<S>

h_mem: Vec<S>

givens_col_scratch: Vec<S>

cs: Vec<R>

sn: Vec<S>

g: Vec<S>

blk_scratch: Vec<S>

blk_payload: Vec<R>

block_buf: Option<BlockVec>

tsqr: Option<TsqrWorkspace>

gmres_sstep: Option<GmresSStepWorkspace>

gmres_recycle: RecyclingSpace

reduction: ReductOptions

reduction_engine: Option<Arc<dyn ReductionEngine>>

send_arena: BufferPool<u8>

recv_arena: BufferPool<u8>

packet_arena: BufferPool<u8>

Implementations

impl Workspace

pub fn new(n: usize) -> Self

Examples found in repository

examples/complex_matrix_market_demo.rs (line 2503)

    fn run_once(
        problem: &Problem,
        spec: &RunSpec,
        bench_cfg: &BenchmarkConfig,
    ) -> Result<ResultRow, KError> {
        let b_unscaled = &problem.rhs;
        let (row_scaling, op_scaled): (Option<Vec<R>>, Arc<dyn KLinOp<Scalar = S>>) =
            if bench_cfg.row_scale {
                let d = compute_row_scaling(problem.csr_for_pc.as_ref(), bench_cfg.row_scale_tiny);
                (
                    Some(d.clone()),
                    Arc::new(RowScaledOp {
                        base: problem.op.clone(),
                        d,
                    }),
                )
            } else {
                (None, problem.op.clone())
            };
        let pc_csr: Arc<SparseCsrMatrix<S>> = if bench_cfg.row_scale {
            let row_scale = row_scaling.as_ref().ok_or_else(|| {
                KError::InvalidInput("row scaling requested but factors were not computed".into())
            })?;
            Arc::new(scale_csr_rows(problem.csr_for_pc.as_ref(), row_scale))
        } else {
            problem.csr_for_pc.clone()
        };
        let global_pc_csr: Arc<SparseCsrMatrix<S>> = if bench_cfg.row_scale {
            let row_scale = row_scaling.as_ref().ok_or_else(|| {
                KError::InvalidInput("row scaling requested but factors were not computed".into())
            })?;
            Arc::new(scale_csr_rows(problem.global_csr.as_ref(), row_scale))
        } else {
            problem.global_csr.clone()
        };
        let b_scaled: Vec<S> = if let Some(d) = &row_scaling {
            b_unscaled
                .iter()
                .zip(d.iter())
                .map(|(bi, di)| *bi * S::from_real(*di))
                .collect()
        } else {
            b_unscaled.clone()
        };
        let b = &b_scaled;
        let effective_pc_side = normalized_fgmres_side(spec.pc_side);
        let csr_pc_diag = csr_for_pc_diagnostics(
            pc_csr.as_ref(),
            problem.local_rows_nnz,
            problem.zero_global_rows_local,
        );
        let setup_start = Instant::now();
        let mut pc = setup_preconditioner_for_run_once(
            problem,
            spec,
            bench_cfg,
            &pc_csr,
            &global_pc_csr,
            &csr_pc_diag,
        )?;
        let setup_secs = setup_start.elapsed().as_secs_f64();
        for _ in 0..bench_cfg.warmup_runs {
            let mut x = vec![S::zero(); problem.local_n];
            let mut workspace = Workspace::new(problem.local_n);
            let _ = solve_with_selected_ksp(
                spec,
                bench_cfg,
                problem,
                op_scaled.as_ref(),
                pc.as_mut().map(PcHandle::as_kpc_mut),
                b,
                &mut x,
                effective_pc_side,
                None,
                Some(&mut workspace),
            )?;
        }

        let mut solve_times = Vec::with_capacity(bench_cfg.measured_runs);
        let mut x_last = vec![S::zero(); problem.local_n];
        let mut final_stats = None;
        let mut residual_history_last = RunResidualHistory::default();
        for _ in 0..bench_cfg.measured_runs {
            let mut x = vec![S::zero(); problem.local_n];
            problem.comm.barrier();
            let start = Instant::now();
            let mut workspace = Workspace::new(problem.local_n);
            let mut run_history = RunResidualHistory::default();
            let mut monitors: Vec<Box<MonitorCallback<R>>> = Vec::new();
            if bench_cfg.residual_history {
                monitors.push(Box::new(|it, res, _| {
                    let _ = (it, res);
                    MonitorAction::Continue
                }));
            }
            let history_ref = std::sync::Arc::new(std::sync::Mutex::new(Vec::<(usize, R)>::new()));
            if bench_cfg.residual_history {
                let history_ref_c = history_ref.clone();
                monitors.clear();
                monitors.push(Box::new(move |it, res, _| {
                    if let Ok(mut h) = history_ref_c.lock() {
                        h.push((it, res));
                    }
                    MonitorAction::Continue
                }));
            }
            let stats = solve_with_selected_ksp(
                spec,
                bench_cfg,
                problem,
                op_scaled.as_ref(),
                pc.as_mut().map(PcHandle::as_kpc_mut),
                b,
                &mut x,
                effective_pc_side,
                if monitors.is_empty() {
                    None
                } else {
                    Some(&monitors)
                },
                Some(&mut workspace),
            )?;
            if bench_cfg.residual_history {
                if let Ok(h) = history_ref.lock() {
                    run_history.entries = h
                        .iter()
                        .map(|(it, res)| ResidualHistoryEntry {
                            iter: *it,
                            recurrence_residual: *res,
                            true_residual: None,
                            checkpoint: false,
                        })
                        .collect();
                }
                residual_history_last = run_history;
            }
            problem.comm.barrier();
            let solve_secs = start.elapsed().as_secs_f64();
            solve_times.push(solve_secs);
            x_last = x;
            final_stats = Some(stats);
        }
        let stats = final_stats
            .ok_or_else(|| KError::InvalidInput("no measured solve run executed".into()))?;
        // Row scaling changes only equations (D_r A x = D_r b), so x is unchanged.
        // Keep an explicit "map-back" step so optional future column scaling can hook here.
        let x_unscaled = x_last;
        let min_solve_secs = solve_times.iter().copied().fold(f64::INFINITY, f64::min);
        let median_solve_secs = median(&mut solve_times);

        let reductions = stats.counters.num_global_reductions;
        let overlapped_reduction_waits = stats.counters.overlap_global_reductions;
        let model_predicted_reductions = stats
            .reduction_model
            .as_ref()
            .map(|model| model.estimate_total(stats.iterations));
        let (explicit_true_residual, explicit_true_residual_rel) =
            if bench_cfg.run_mode == RunMode::Correctness {
                let mut ax = vec![S::zero(); b.len()];
                let mut scratch = BridgeScratch::default();
                problem.op.matvec_s(&x_unscaled, &mut ax, &mut scratch);
                for (ri, bi) in ax.iter_mut().zip(b_unscaled.iter().copied()) {
                    *ri = bi - *ri;
                }
                let r2_local = ax.iter().map(|v| v.abs2()).sum::<f64>();
                let true_res = problem.comm.all_reduce_f64(r2_local).sqrt();
                let rhs_norm2_local = b_unscaled.iter().map(|v| v.abs2()).sum::<f64>();
                let rhs_norm = problem.comm.all_reduce_f64(rhs_norm2_local).sqrt();
                let rel_true = true_res / rhs_norm.max(f64::MIN_POSITIVE);
                (Some(true_res), Some(rel_true))
            } else {
                (None, None)
            };
        if bench_cfg.residual_history && bench_cfg.measured_runs > 0 && problem.comm.rank() == 0 {
            let mut checkpoint_count = 0usize;
            // mark restart boundaries based on effective restart interval and policy
            let restart = stats.effective_restart.unwrap_or(spec.restart).max(1);
            for e in &mut residual_history_last.entries {
                if e.iter > 0 && e.iter % restart == 0 {
                    e.checkpoint = true;
                    if matches!(
                        spec.residual_check_policy,
                        ResidualCheckPolicy::RestartOnly
                            | ResidualCheckPolicy::OnConvergence
                            | ResidualCheckPolicy::EveryIteration
                            | ResidualCheckPolicy::Debug
                    ) {
                        e.true_residual = explicit_true_residual;
                    }
                    checkpoint_count += 1;
                }
            }
            println!(
                "[history][rank0] {}: {} points, {} restart checkpoints",
                format!(
                    "{} [row-scale={}]",
                    spec.method_label(),
                    if bench_cfg.row_scale { "on" } else { "off" }
                ),
                residual_history_last.entries.len(),
                checkpoint_count
            );
            if let Some(path) = &bench_cfg.residual_history_file {
                dump_residual_history(path, &residual_history_last)?;
                println!("[history][rank0] wrote {}", path.display());
            }
        }

        let x_error_rel = if bench_cfg.run_mode == RunMode::Correctness
            && problem.rhs_source == RhsSource::GeneratedAOnes
            && problem.solution_reference.valid_for_x_error()
        {
            let err2_local = x_unscaled
                .iter()
                .map(|xi| (*xi - S::one()).abs2())
                .sum::<f64>();
            let one2_local = x_unscaled.iter().map(|_| S::one().abs2()).sum::<f64>();
            let err = problem.comm.all_reduce_f64(err2_local).sqrt();
            let one_norm = problem.comm.all_reduce_f64(one2_local).sqrt();
            Some(err / one_norm.max(f64::MIN_POSITIVE))
        } else {
            None
        };
        let global_reference_check = if bench_cfg.run_mode == RunMode::Correctness {
            Some(global_reference_residual(problem, &x_unscaled, b_unscaled)?)
        } else {
            None
        };
        let verdict_tol = correctness_verdict_tolerance(bench_cfg);
        let dist_ok = explicit_true_residual_rel.map(|rel| rel <= verdict_tol);
        let global_ok = global_reference_check
            .as_ref()
            .map(|check| check.true_residual_rel <= verdict_tol);
        let x_ok = if bench_cfg.run_mode == RunMode::Correctness
            && problem.rhs_source == RhsSource::GeneratedAOnes
            && problem.solution_reference.valid_for_x_error()
        {
            global_reference_check
                .as_ref()
                .and_then(|check| check.x_error_rel)
                .map(|rel| rel <= verdict_tol)
        } else {
            None
        };
        let dof_per_sec = if matches!(
            problem.backend,
            CsrBackend::Serial | CsrBackend::Distributed
        ) && median_solve_secs > 0.0
        {
            Some(problem.global_n as f64 / median_solve_secs)
        } else {
            None
        };

        Ok(ResultRow {
            operator_storage: operator_storage_label(problem),
            execution_backend: execution_backend_label(problem),
            pc_domain: pc_domain_label(spec.pc, problem),
            pc_apply: pc_apply_label(spec.pc, problem),
            method: format!(
                "{} [row-scale={}]",
                spec.method_label(),
                if bench_cfg.row_scale { "on" } else { "off" }
            ),
            requested_policy: spec.requested_policy_label(),
            effective_policy: format!(
                "ksp={}, variant={}, restart={}, residual-check={}",
                spec.ksp.label(),
                stats
                    .effective_variant
                    .as_deref()
                    .unwrap_or(variant_label(spec.variant)),
                stats.effective_restart.unwrap_or(spec.restart),
                stats
                    .effective_residual_check_policy
                    .as_deref()
                    .unwrap_or(residual_check_policy_label(spec.residual_check_policy))
            ) + if bench_cfg.run_mode == RunMode::Correctness
                && bench_cfg.mark_replicated_check
            {
                " [replicated-check=enabled]"
            } else {
                ""
            },
            setup_secs,
            median_solve_secs,
            min_solve_secs,
            iterations: stats.iterations,
            reductions,
            overlapped_reduction_waits,
            model_predicted_reductions,
            restart_count: stats.fgmres_counters.as_ref().map(|c| c.restart_count),
            inner_iterations_last_cycle: stats
                .fgmres_counters
                .as_ref()
                .map(|c| c.inner_iterations_last_cycle),
            pipeline_fallbacks: stats.fgmres_counters.as_ref().map(|c| c.pipeline_fallbacks),
            reported_residual: stats.final_residual,
            explicit_true_residual,
            explicit_true_residual_rel,
            x_error_rel,
            global_true_residual: global_reference_check
                .as_ref()
                .map(|check| check.true_residual),
            global_true_residual_rel: global_reference_check
                .as_ref()
                .map(|check| check.true_residual_rel),
            global_x_error_rel: global_reference_check.and_then(|check| check.x_error_rel),
            dist_ok,
            global_ok,
            x_ok,
            reason: stats.reason,
            dof_per_sec,
        })
    }

pub fn ensure_comm_bytes(&mut self, max_send: usize, max_recv: usize)

Ensure communication buffers have enough bytes for upcoming operations.

pub fn ensure_block(&mut self, n: usize, p: usize)

Ensure the reusable block vector has capacity n x p.

pub fn ensure_tsqr(&mut self, w_max: usize)

Ensure the TSQR workspace supports panels up to width w_max.

pub fn ensure_sstep(&mut self, n: usize, s: usize, m: usize)

pub fn sstep_mut(&mut self) -> Option<&mut GmresSStepWorkspace>

pub fn n(&self) -> usize

pub fn local_work_estimate(&self) -> usize

Lightweight estimate of local work used by adaptive execution policy.

pub fn m(&self) -> usize

pub fn has_z(&self) -> bool

pub fn ld_h(&self) -> usize

pub fn acquire_gmres(&mut self, spec: GmresSpec)

Ensure capacity for a (F)GMRES run. Idempotent and allocation-friendly.

pub fn clear_gmres_restart_state(&mut self)

Clear per-restart GMRES/FGMRES state while preserving allocation capacity.

pub fn clear_gmres_global_scratch(&mut self)

Clear solve-global scratch vectors used by GMRES/FGMRES without releasing memory.

pub fn set_reduction_options(&mut self, opt: ReductOptions)

pub fn set_reduction_engine(&mut self, engine: Arc<dyn ReductionEngine>)

pub fn clear_reduction_engine(&mut self)

pub fn reduction_engine(&self) -> Option<&Arc<dyn ReductionEngine>>

pub fn set_reduction_mode(&mut self, mode: ReproMode)

pub fn reduction_options(&self) -> &ReductOptions

pub fn v_col(&mut self, j: usize) -> &mut [S]

pub fn z_col(&mut self, j: usize) -> &mut [S]

pub fn h_at(&self, i: usize, j: usize) -> S

pub fn h_at_mut(&mut self, i: usize, j: usize) -> &mut S

pub fn v_cols2(&mut self, a: usize, b: usize) -> (&mut [S], &mut [S])

pub fn z_cols2(&mut self, a: usize, b: usize) -> (&mut [S], &mut [S])

pub fn v_and_z_mut(&mut self, j: usize) -> (&[S], &mut [S])

pub fn tmp1_and_z_mut(&mut self, j: usize) -> (&[S], &mut [S])

pub fn tmp2_and_z_mut(&mut self, j: usize) -> (&[S], &mut [S])

pub fn z_and_tmp2_mut(&mut self, j: usize) -> (&[S], &mut [S])

pub fn copy_tmp2_into_vcol(&mut self, j: usize)

pub fn copy_tmp1_into_vcol(&mut self, j: usize)

pub fn copy_vcol_into_zcol(&mut self, j: usize)

pub fn copy_vcol_into_tmp1(&mut self, j: usize)

pub fn apply_prev_givens_to_col(&mut self, j: usize, upto: usize)

pub fn apply_final_givens_and_update_g(&mut self, j: usize)

pub fn finish_pipelined_arnoldi( &mut self, k: usize, n: usize, red: &dyn ReductionEngine, policy: ReorthPolicy, tol: R, glob: Vec<R>, ) -> Result<usize, KError>

Available on crate feature complex only.

pub fn finalize_pipelined_arnoldi( &mut self, pipe: PipeReduct, k: usize, n: usize, red: &dyn ReductionEngine, policy: ReorthPolicy, tol: R, ) -> Result<usize, KError>

Available on crate feature complex only.

pub fn launch_pipelined_arnoldi_reduction( &mut self, k: usize, n: usize, red: &dyn ReductionEngine, ) -> Result<PipeReduct, KError>

Available on crate feature complex only.

pub fn pipelined_arnoldi_step( &mut self, k: usize, n: usize, red: &dyn ReductionEngine, policy: ReorthPolicy, tol: R, ) -> Result<PipeReduct, KError>

Available on crate feature complex only.

pub fn pipelined_payload_len_for_k(k: usize) -> usize

Available on crate feature complex only.

Trait Implementations

impl Clone for Workspace

fn clone(&self) -> Workspace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Workspace

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

Formats the value using the given formatter.

impl Default for Workspace

fn default() -> Workspace

Returns the “default value” for a type.