Struct FixedPointBatch 

pub struct FixedPointBatch<'a, F> { /* private fields */ }

Fixed-point batch runner that reuses scratch across analyses.

Implementations

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn ifds_scratch(&self) -> &IfdsSolveScratch

Inspect retained IFDS scratch after one or more batch solves.

pub fn ifds_prepare_scratch(&self) -> &IfdsPrepareScratch

Inspect retained IFDS preparation scratch after one or more prepares.

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn prepare_ifds( &mut self, num_procs: u32, blocks_per_proc: u32, facts_per_proc: u32, intra_edges: &[(u32, u32, u32)], inter_edges: &[(u32, u32, u32, u32)], flow_gen: &[(u32, u32, u32)], flow_kill: &[(u32, u32, u32)], ) -> Result<PreparedIfdsCsr, String>

Prepare IFDS CSR buffers for repeated batch solves.

pub fn ifds( &mut self, num_procs: u32, blocks_per_proc: u32, facts_per_proc: u32, intra_edges: &[(u32, u32, u32)], inter_edges: &[(u32, u32, u32, u32)], flow_gen: &[(u32, u32, u32)], flow_kill: &[(u32, u32, u32)], seed_facts: &[(u32, u32, u32)], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run IFDS reachability while reusing retained batch preparation and solve scratch.

pub fn ifds_into( &mut self, num_procs: u32, blocks_per_proc: u32, facts_per_proc: u32, intra_edges: &[(u32, u32, u32)], inter_edges: &[(u32, u32, u32, u32)], flow_gen: &[(u32, u32, u32)], flow_kill: &[(u32, u32, u32)], seed_facts: &[(u32, u32, u32)], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run IFDS reachability into caller-owned result storage while reusing retained batch preparation and solve scratch.

pub fn ifds_many( &mut self, num_procs: u32, blocks_per_proc: u32, facts_per_proc: u32, intra_edges: &[(u32, u32, u32)], inter_edges: &[(u32, u32, u32, u32)], flow_gen: &[(u32, u32, u32)], flow_kill: &[(u32, u32, u32)], seed_sets: &[&[(u32, u32, u32)]], max_iterations: u32, ) -> Result<Vec<Vec<u32>>, String>

Run several IFDS reachability queries while preparing the IFDS CSR once and reusing retained batch scratch across every seed set.

pub fn ifds_many_into( &mut self, num_procs: u32, blocks_per_proc: u32, facts_per_proc: u32, intra_edges: &[(u32, u32, u32)], inter_edges: &[(u32, u32, u32, u32)], flow_gen: &[(u32, u32, u32)], flow_kill: &[(u32, u32, u32)], seed_sets: &[&[(u32, u32, u32)]], max_iterations: u32, results: &mut Vec<Vec<u32>>, ) -> Result<(), String>

Run several IFDS reachability queries while preparing the IFDS CSR once and writing into caller-owned result rows.

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn ifds_prepared( &mut self, prepared: &PreparedIfdsCsr, seed_facts: &[(u32, u32, u32)], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run IFDS reachability against prepared CSR buffers with retained batch scratch.

pub fn ifds_prepared_into( &mut self, prepared: &PreparedIfdsCsr, seed_facts: &[(u32, u32, u32)], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run IFDS reachability against prepared CSR buffers into caller-owned result storage with retained batch scratch.

pub fn ifds_prepared_many( &mut self, prepared: &PreparedIfdsCsr, seed_sets: &[&[(u32, u32, u32)]], max_iterations: u32, ) -> Result<Vec<Vec<u32>>, String>

Run several IFDS reachability queries against prepared CSR buffers while reusing retained batch scratch across every seed set.

pub fn ifds_prepared_many_into( &mut self, prepared: &PreparedIfdsCsr, seed_sets: &[&[(u32, u32, u32)]], max_iterations: u32, results: &mut Vec<Vec<u32>>, ) -> Result<(), String>

Run several IFDS reachability queries against prepared CSR buffers into caller-owned result rows with retained batch scratch.

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn live( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

pub fn live_into( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run live-variable closure into caller-owned result storage.

pub fn prepare_live( &mut self, graph: CsrGraph<'_>, ) -> Result<FixedPointForwardGraph, String>

Prepare live-variable reversed-control graph buffers for repeated runs.

pub fn prepare_live_into( &mut self, graph: CsrGraph<'_>, prepared: &mut FixedPointForwardGraph, ) -> Result<(), String>

Repack live-variable graph buffers into an existing prepared graph.

pub fn prepare_live_plan( &mut self, graph: CsrGraph<'_>, ) -> Result<FixedPointAnalysisPlan, String>

Prepare live-variable graph buffers and Program for repeated runs.

pub fn prepare_live_plan_into( &mut self, graph: CsrGraph<'_>, plan: &mut FixedPointAnalysisPlan, ) -> Result<(), String>

Repack a live-variable plan in place for a new graph layout.

pub fn live_prepared( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run live-variable closure against prepared reversed-control buffers.

pub fn live_prepared_into( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run live-variable closure against prepared reversed-control buffers into caller-owned result storage.

pub fn live_plan( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run live-variable closure against a prepared graph+Program plan.

pub fn live_plan_into( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run live-variable closure against a prepared graph+Program plan into caller-owned result storage.

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn points_to_subset( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

pub fn points_to_subset_into( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run Andersen subset closure into caller-owned result storage.

pub fn prepare_points_to_subset( &self, graph: CsrGraph<'_>, ) -> Result<FixedPointForwardGraph, String>

Prepare points-to subset graph buffers for repeated batch runs.

pub fn prepare_points_to_subset_into( &self, graph: CsrGraph<'_>, prepared: &mut FixedPointForwardGraph, ) -> Result<(), String>

Repack points-to subset graph buffers into an existing prepared graph.

pub fn prepare_points_to_subset_plan( &self, graph: CsrGraph<'_>, ) -> Result<FixedPointAnalysisPlan, String>

Prepare points-to subset graph buffers and Program for repeated runs.

pub fn prepare_points_to_subset_plan_into( &self, graph: CsrGraph<'_>, plan: &mut FixedPointAnalysisPlan, ) -> Result<(), String>

Repack a points-to subset plan in place for a new graph layout.

pub fn points_to_subset_prepared( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run points-to subset closure against prepared graph buffers.

pub fn points_to_subset_prepared_into( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run points-to subset closure against prepared graph buffers into caller-owned result storage.

pub fn points_to_subset_plan( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run points-to subset closure against a prepared graph+Program plan.

pub fn points_to_subset_plan_into( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run points-to subset closure against a prepared graph+Program plan into caller-owned result storage.

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn reaching( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

pub fn reaching_into( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run reaching-definition closure into caller-owned result storage.

pub fn prepare_reaching( &mut self, graph: CsrGraph<'_>, ) -> Result<FixedPointForwardGraph, String>

Prepare reaching graph buffers for repeated batch runs.

pub fn prepare_reaching_into( &mut self, graph: CsrGraph<'_>, prepared: &mut FixedPointForwardGraph, ) -> Result<(), String>

Repack reaching graph buffers into an existing prepared graph.

pub fn prepare_reaching_plan( &mut self, graph: CsrGraph<'_>, ) -> Result<FixedPointAnalysisPlan, String>

Prepare reaching graph buffers and Program for repeated batch runs.

pub fn prepare_reaching_plan_into( &mut self, graph: CsrGraph<'_>, plan: &mut FixedPointAnalysisPlan, ) -> Result<(), String>

Repack a reaching plan in place for a new graph layout.

pub fn reaching_prepared( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run reaching-definition closure against prepared graph buffers.

pub fn reaching_prepared_into( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run reaching-definition closure against prepared graph buffers into caller-owned result storage.

pub fn reaching_plan( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run reaching-definition closure against a prepared graph+Program plan.

pub fn reaching_plan_into( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run reaching-definition closure against a prepared graph+Program plan into caller-owned result storage.

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn slice( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

pub fn slice_into( &mut self, graph: CsrGraph<'_>, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run backward slice closure into caller-owned result storage.

pub fn prepare_slice( &self, graph: CsrGraph<'_>, ) -> Result<FixedPointForwardGraph, String>

Prepare backward-slice graph buffers for repeated batch runs.

pub fn prepare_slice_into( &self, graph: CsrGraph<'_>, prepared: &mut FixedPointForwardGraph, ) -> Result<(), String>

Repack slice graph buffers into an existing prepared graph.

pub fn prepare_slice_plan( &self, graph: CsrGraph<'_>, ) -> Result<FixedPointAnalysisPlan, String>

Prepare backward-slice graph buffers and Program for repeated runs.

pub fn prepare_slice_plan_into( &self, graph: CsrGraph<'_>, plan: &mut FixedPointAnalysisPlan, ) -> Result<(), String>

Repack a slice plan in place for a new graph layout.

pub fn slice_prepared( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run backward slice closure against prepared graph buffers.

pub fn slice_prepared_into( &mut self, graph: &FixedPointForwardGraph, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run backward slice closure against prepared graph buffers into caller-owned result storage.

pub fn slice_plan( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, ) -> Result<Vec<u32>, String>

Run backward slice closure against a prepared graph+Program plan.

pub fn slice_plan_into( &mut self, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, result: &mut Vec<u32>, ) -> Result<(), String>

Run backward slice closure against a prepared graph+Program plan into caller-owned result storage.

impl<'a, F> FixedPointBatch<'a, F>

where F: Fn(&Program, &[&[u8]], Option<[u32; 3]>, &mut Vec<Vec<u8>>) -> Result<(), String>,

pub fn new(dispatch: &'a F) -> Self

Create a batch runner around a borrowed GPU dispatch adapter.

pub fn scratch(&self) -> &FixedPointScratch

Inspect retained scratch after one or more batch runs.

pub fn frontier_density(&self) -> FrontierDensityTelemetry

Latest host-observed frontier density from the last fixed-point solve.

pub fn recommended_frontier_execution_mode(&self) -> FrontierExecutionMode

Sparse/dense execution family recommended from the last solve’s frontier density.

pub fn execution_plan_for_prepared_graph( &self, graph: &FixedPointForwardGraph, ) -> Result<FixedPointExecutionPlan, String>

Build a scale-aware execution plan for a prepared graph using the last observed frontier density.

pub fn clear(&mut self)

Clear logical scratch contents while preserving capacity.

Trait Implementations

impl<'a, F: Clone> Clone for FixedPointBatch<'a, F>

fn clone(&self) -> FixedPointBatch<'a, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, F: Debug> Debug for FixedPointBatch<'a, F>

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

Formats the value using the given formatter.

impl<'a, F: PartialEq> PartialEq for FixedPointBatch<'a, F>

fn eq(&self, other: &FixedPointBatch<'a, F>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a, F: PartialEq> StructuralPartialEq for FixedPointBatch<'a, F>