Struct FixedPointResidentPlan 

pub struct FixedPointResidentPlan { /* private fields */ }

Resident graph resources paired with a backend-compiled pipeline.

Implementations

impl FixedPointResidentPlan

pub fn new( backend: &dyn VyreBackend, graph: &FixedPointForwardGraph, pipeline: Arc<dyn CompiledPipeline>, ) -> Result<Self, BackendError>

Upload graph buffers and bind them to a compiled pipeline.

pub fn free_with_frontier( self, backend: &dyn VyreBackend, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<(), BackendError>

Free resident graph and reusable frontier resources owned around this plan.

pub fn free(self, backend: &dyn VyreBackend) -> Result<(), BackendError>

Free resident graph resources owned by this plan.

Methods from Deref<Target = PlanBuilder<FixedPointResidentGraph>>

pub fn node_count(&self) -> u32

Number of graph nodes in the resident dispatch domain.

pub fn edge_count(&self) -> u32

Number of graph edges in the resident dispatch domain.

pub fn resident_resource_count(&self) -> usize

Number of resident invariant graph resources.

pub fn reaching_resident_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, ) -> Result<Vec<u32>, String>

Run reaching-definition closure with resident graph and frontier buffers.

pub fn reaching_resident_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run reaching-definition closure with resident graph/frontier buffers into caller-owned result storage.

pub fn reaching_reusing_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run reaching-definition closure while reusing resident frontier buffers.

pub fn reaching_reusing_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run reaching-definition closure while reusing resident frontier buffers and caller-owned result storage.

pub fn live_resident_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, ) -> Result<Vec<u32>, String>

Run live-variable closure with resident graph and frontier buffers.

pub fn live_resident_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run live-variable closure with resident graph/frontier buffers into caller-owned result storage.

pub fn live_reusing_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run live-variable closure while reusing resident frontier buffers.

pub fn live_reusing_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run live-variable closure while reusing resident frontier buffers and caller-owned result storage.

pub fn points_to_subset_resident_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, ) -> Result<Vec<u32>, String>

Run points-to subset closure with resident graph and frontier buffers.

pub fn points_to_subset_resident_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run points-to subset closure with resident graph/frontier buffers into caller-owned result storage.

pub fn points_to_subset_reusing_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run points-to subset closure while reusing resident frontier buffers.

pub fn points_to_subset_reusing_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run points-to subset closure while reusing resident frontier buffers and caller-owned result storage.

pub fn slice_resident_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, ) -> Result<Vec<u32>, String>

Run backward-slice closure with resident graph and frontier buffers.

pub fn slice_resident_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run backward-slice closure with resident graph/frontier buffers into caller-owned result storage.

pub fn slice_reusing_frontier( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run backward-slice closure while reusing resident frontier buffers.

pub fn slice_reusing_frontier_into( &self, backend: &dyn VyreBackend, seed_bits: &[u32], max_iterations: u32, config: &DispatchConfig, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run backward-slice closure while reusing resident frontier buffers and caller-owned result storage.

pub fn reaching_reusing_frontier_sequence_window( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run reaching-definition closure through backend resident sequence replay.

pub fn reaching_reusing_frontier_sequence_window_into( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run reaching-definition closure through backend resident sequence replay into caller-owned result storage.

pub fn live_reusing_frontier_sequence_window( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run live-variable closure through backend resident sequence replay.

pub fn live_reusing_frontier_sequence_window_into( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run live-variable closure through backend resident sequence replay into caller-owned result storage.

pub fn points_to_subset_reusing_frontier_sequence_window( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run points-to subset closure through backend resident sequence replay.

pub fn points_to_subset_reusing_frontier_sequence_window_into( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run points-to subset closure through backend resident sequence replay into caller-owned result storage.

pub fn slice_reusing_frontier_sequence_window( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, ) -> Result<Vec<u32>, String>

Run backward-slice closure through backend resident sequence replay.

pub fn slice_reusing_frontier_sequence_window_into( &self, backend: &dyn VyreBackend, plan: &FixedPointAnalysisPlan, seed_bits: &[u32], max_iterations: u32, scratch: &mut FixedPointScratch, resident_frontier: &mut FixedPointResidentFrontierScratch, result: &mut Vec<u32>, ) -> Result<(), String>

Run backward-slice closure through backend resident sequence replay into caller-owned result storage.

Trait Implementations

impl Clone for FixedPointResidentPlan

fn clone(&self) -> FixedPointResidentPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FixedPointResidentPlan

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

Formats the value using the given formatter.

impl Deref for FixedPointResidentPlan

type Target = PlanBuilder<FixedPointResidentGraph>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl PartialEq for FixedPointResidentPlan

fn eq(&self, other: &FixedPointResidentPlan) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FixedPointResidentPlan