Struct ArcRwLock 

pub struct ArcRwLock<T> { /* private fields */ }

Implementations

impl ArcRwLock<DualNode>

pub fn update(&self) -> &Self

when fused, dual node may be outdated; refresh here

pub fn updated_index(&self) -> NodeIndex

pub fn get_ancestor_blossom(&self) -> DualNodePtr

get parent blossom recursively

pub fn get_secondary_ancestor_blossom(&self) -> DualNodePtr

get the parent blossom before the most parent one, useful when expanding a blossom

pub fn get_all_vertices(&self) -> Vec<VertexIndex>

find all vertices that belongs to the dual node, i.e. any vertices inside a blossom

pub fn get_representative_vertex(&self) -> VertexIndex

find a representative vertex

impl ArcRwLock<DualModuleInterface>

pub fn new_empty() -> Self

create an empty interface

pub fn new_load( syndrome_pattern: &SyndromePattern, dual_module_impl: &mut impl DualModuleImpl, ) -> Self

a dual module interface MUST be created given a concrete implementation of the dual module

pub fn load( &self, syndrome_pattern: &SyndromePattern, dual_module_impl: &mut impl DualModuleImpl, )

pub fn clear(&self)

a constant clear function, without dropping anything; this is for consideration of reducing the garbage collection time in the parallel solver, by distributing the clear cost into each thread but not the single main thread.

pub fn flatten_nodes(&self, flattened_nodes: &mut Vec<Option<DualNodePtr>>)

DFS flatten the nodes

pub fn create_defect_node( &self, vertex_idx: VertexIndex, dual_module_impl: &mut impl DualModuleImpl, ) -> DualNodePtr

pub fn check_ptr_belonging(&self, dual_node_ptr: &DualNodePtr) -> bool

check whether a pointer belongs to this node, it will acquire a reader lock on dual_node_ptr

pub fn create_blossom( &self, nodes_circle: Vec<DualNodePtr>, touching_children: Vec<(DualNodeWeak, DualNodeWeak)>, dual_module_impl: &mut impl DualModuleImpl, ) -> DualNodePtr

create a dual node corresponding to a blossom, automatically set the grow state of internal nodes; the nodes circle MUST starts with a growing node and ends with a shrinking node

pub fn expand_blossom( &self, blossom_node_ptr: DualNodePtr, dual_module_impl: &mut impl DualModuleImpl, )

expand a blossom: note that different from Blossom V library, we do not maintain tree structure after a blossom is expanded; this is because we’re growing all trees together, and due to the natural of quantum codes, this operation is not likely to cause bottleneck as long as physical error rate is well below the threshold. All internal nodes will have a DualNodeGrowState::Grow state afterwards.

pub fn set_grow_state( &self, dual_node_ptr: &DualNodePtr, grow_state: DualNodeGrowState, dual_module_impl: &mut impl DualModuleImpl, )

a helper function to update grow state

pub fn grow(&self, length: Weight, dual_module_impl: &mut impl DualModuleImpl)

grow the dual module and update [DualModuleInterface::sum_]

pub fn notify_grown(&self, length: Weight)

if a dual module spontaneously grow some value (e.g. with primal offloading), this function should be called

pub fn grow_iterative( &self, length: Weight, dual_module_impl: &mut impl DualModuleImpl, )

grow a specific length globally but iteratively: will try to keep growing that much

pub fn slow_fuse(&self, left: &Self, right: &Self)

fuse two interfaces by copying the nodes in other into myself

pub fn fuse(&self, left: &Self, right: &Self)

fuse two interfaces by (virtually) copying the nodes in other into myself, with O(1) time complexity

pub fn sanity_check(&self) -> Result<Vec<Option<DualNodePtr>>, String>

do a sanity check of if all the nodes are in consistent state

pub fn sum_dual_variables(&self) -> Weight

impl<SerialModule: DualModuleImpl + Send + Sync> ArcRwLock<DualModuleParallelUnit<SerialModule>>

pub fn new_wrapper( serial_module: SerialModule, unit_index: usize, partition_info: Arc<PartitionInfo>, partition_unit: PartitionUnitPtr, enable_parallel_execution: bool, ) -> Self

create a simple wrapper over a serial dual module

impl<T> ArcRwLock<T>

pub fn downgrade(&self) -> WeakRwLock<T>

impl ArcRwLock<PrimalModuleParallelUnit>

pub fn new_wrapper( serial_module: PrimalModuleSerialPtr, unit_index: usize, partition_info: Arc<PartitionInfo>, ) -> Self

create a simple wrapper over a serial dual module

impl ArcRwLock<PrimalNodeInternal>

pub fn update(&self) -> &Self

when fused, primal node may be outdated; refresh here

impl ArcRwLock<PrimalModuleSerial>

pub fn get_primal_node_internal_ptr_option( &self, dual_node_ptr: &DualNodePtr, ) -> Option<PrimalNodeInternalPtr>

pub fn get_primal_node_internal_ptr( &self, dual_node_ptr: &DualNodePtr, ) -> PrimalNodeInternalPtr

pub fn get_outer_node( &self, primal_node_internal_ptr: PrimalNodeInternalPtr, ) -> PrimalNodeInternalPtr

get the outer node in the most up-to-date cache

pub fn find_lowest_common_ancestor( &self, primal_node_internal_ptr_1: PrimalNodeInternalPtr, primal_node_internal_ptr_2: PrimalNodeInternalPtr, ) -> (PrimalNodeInternalPtr, Vec<PrimalNodeInternalPtr>, Vec<PrimalNodeInternalPtr>)

find the lowest common ancestor (LCA) of two nodes in the alternating tree, return (LCA, path_1, path_2) where path includes leaf but exclude the LCA

pub fn match_subtree<D: DualModuleImpl>( tree_node_internal_ptr: PrimalNodeInternalPtr, interface_ptr: &DualModuleInterfacePtr, dual_module: &mut D, )

for any - node, match the children by matching them with + node

pub fn augment_tree_given_matched<D: DualModuleImpl>( tree_node_internal_ptr: PrimalNodeInternalPtr, match_node_internal_ptr: PrimalNodeInternalPtr, tree_touching_ptr: DualNodeWeak, interface_ptr: &DualModuleInterfacePtr, dual_module: &mut D, )

for any + node, match it with another node will augment the whole tree, breaking out into several matched pairs; tree_grandson_ptr is the grandson of tree_node_internal_ptr that touches match_node_internal_ptr

pub fn augment_tree_given_virtual_vertex<D: DualModuleImpl>( &self, tree_node_internal_ptr: PrimalNodeInternalPtr, virtual_vertex_index: VertexIndex, tree_touching_ptr: DualNodeWeak, interface_ptr: &DualModuleInterfacePtr, dual_module: &mut D, )

for any + node, match it with virtual boundary will augment the whole tree, breaking out into several matched pairs

pub fn flatten_nodes( &self, flattened_nodes: &mut Vec<Option<PrimalNodeInternalPtr>>, )

DFS flatten the nodes

pub fn slow_fuse(&self, left: &Self, right: &Self)

fuse two modules by copying the nodes in other into myself

pub fn fuse(&self, left: &Self, right: &Self)

fuse two modules by (virtually) copying the nodes in other into myself, with O(1) time complexity

pub fn sanity_check(&self) -> Result<Vec<Option<PrimalNodeInternalPtr>>, String>

do a sanity check of it’s tree structure and internal state

pub fn collapse_tree<D: DualModuleImpl>( &self, primal_node_internal_ptr: PrimalNodeInternalPtr, interface_ptr: &DualModuleInterfacePtr, dual_module: &mut D, )

collapse a tree into a single blossom, just like what union-find decoder does. No MWPM guarantee once this is called.

impl ArcRwLock<PrimalNodeInternal>

pub fn flatten_tree(&self, flattened_nodes: &mut Vec<PrimalNodeInternalPtr>)

DFS flatten the children of a tree

Trait Implementations

impl<T> Clone for ArcRwLock<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Deref for ArcRwLock<T>

type Target = RwLock<RawRwLock, T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> PartialEq for ArcRwLock<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> RwLockPtr<T> for ArcRwLock<T>

fn new_ptr(ptr: Arc<RwLock<T>>) -> Self

fn new_value(obj: T) -> Self

fn ptr(&self) -> &Arc<RwLock<T>>

fn ptr_mut(&mut self) -> &mut Arc<RwLock<T>>

fn read_recursive(&self) -> RwLockReadGuard<'_, RawRwLock, ObjType>

fn write(&self) -> RwLockWriteGuard<'_, RawRwLock, ObjType>

fn ptr_eq(&self, other: &Self) -> bool

impl<T> Eq for ArcRwLock<T>