Struct DualModuleParallelUnit 

pub struct DualModuleParallelUnit<SerialModule: DualModuleImpl + Send + Sync> {

    pub unit_index: usize,
    pub partition_info: Arc<PartitionInfo>,
    pub partition_unit: PartitionUnitPtr,
    pub is_active: bool,
    pub whole_range: VertexRange,
    pub owning_range: VertexRange,
    pub extra_descendant_mirrored_vertices: HashSet<VertexIndex>,
    pub serial_module: SerialModule,
    pub children: Option<(DualModuleParallelUnitWeak<SerialModule>, DualModuleParallelUnitWeak<SerialModule>)>,
    pub parent: Option<DualModuleParallelUnitWeak<SerialModule>>,
    pub elevated_dual_nodes: PtrWeakHashSet<DualNodeWeak>,
    pub empty_sync_request: Vec<SyncRequest>,
    pub enable_parallel_execution: bool,
    pub has_active_node: bool,
}

Fields

unit_index: usize

the index

partition_info: Arc<PartitionInfo>

partition information generated by the config

partition_unit: PartitionUnitPtr

information shared with serial module

is_active: bool

whether it’s active or not; some units are “placeholder” units that are not active until they actually fuse their children

whole_range: VertexRange

the vertex range of this parallel unit consists of all the owning_range of its descendants

owning_range: VertexRange

the vertices owned by this unit, note that owning_range is a subset of whole_range

extra_descendant_mirrored_vertices: HashSet<VertexIndex>

the vertices that are mirrored outside of whole_range, in order to propagate a vertex’s sync event to every unit that mirrors it

serial_module: SerialModule

the owned serial dual module

children: Option<(DualModuleParallelUnitWeak<SerialModule>, DualModuleParallelUnitWeak<SerialModule>)>

left and right children dual modules

parent: Option<DualModuleParallelUnitWeak<SerialModule>>

parent dual module

elevated_dual_nodes: PtrWeakHashSet<DualNodeWeak>

elevated dual nodes: whose descendent not on the representative path of a dual node

empty_sync_request: Vec<SyncRequest>

an empty sync requests queue just to implement the trait

enable_parallel_execution: bool

run things in thread pool

has_active_node: bool

whether any descendant unit has active dual node

Implementations

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

pub fn static_fuse(&mut self)

statically fuse the children of this unit

pub fn fuse( &mut self, parent_interface: &DualModuleInterfacePtr, children_interfaces: (&DualModuleInterfacePtr, &DualModuleInterfacePtr), )

fuse the children of this unit and also fuse the interfaces of them

pub fn iterative_bias_dual_node_index(&mut self, bias: NodeIndex)

pub fn is_vertex_in_descendant(&self, vertex_index: VertexIndex) -> bool

if any descendant unit mirror or own the vertex

pub fn elevated_dual_nodes_contains_any(&self, nodes: &[DualNodePtr]) -> bool

check if elevated_dual_nodes contains any dual node in the list

Trait Implementations

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

We cannot implement async function because a RwLockWriteGuard implements !Send

fn new_empty(_initializer: &SolverInitializer) -> Self

clear all growth and existing dual nodes

fn clear(&mut self)

clear all growth and existing dual nodes

fn add_dual_node(&mut self, dual_node_ptr: &DualNodePtr)

add a new dual node from dual module root

fn remove_blossom(&mut self, dual_node_ptr: DualNodePtr)

remove a blossom, note that this dual node ptr is already expanded from the root: normally you only need to remove this blossom; when force flag is set, remove blossom even if its dual variable is not 0: this action cannot be undone

fn set_grow_state( &mut self, dual_node_ptr: &DualNodePtr, grow_state: DualNodeGrowState, )

update grow state

fn compute_maximum_update_length_dual_node( &mut self, dual_node_ptr: &DualNodePtr, is_grow: bool, simultaneous_update: bool, ) -> MaxUpdateLength

An optional function that helps to break down the implementation of DualModuleImpl::compute_maximum_update_length check the maximum length to grow (shrink) specific dual node, if length is 0, give the reason of why it cannot further grow (shrink). if is_grow is false, return length <= 0, in any case |length| is maximized so that at least one edge becomes fully grown or fully not-grown. if simultaneous_update is true, also check for the peer node according to DualNode::grow_state.

fn compute_maximum_update_length(&mut self) -> GroupMaxUpdateLength

check the maximum length to grow (shrink) for all nodes, return a list of conflicting reason and a single number indicating the maximum length to grow: this number will be 0 if any conflicting reason presents

fn grow_dual_node(&mut self, dual_node_ptr: &DualNodePtr, length: Weight)

An optional function that can manipulate individual dual node, not necessarily supported by all implementations

fn grow(&mut self, length: Weight)

grow a specific length globally, length must be positive. note that reversing the process is possible, but not recommended: to do that, reverse the state of each dual node, Grow->Shrink, Shrink->Grow

fn load_edge_modifier(&mut self, edge_modifier: &[(EdgeIndex, Weight)])

optional support for edge modifier. for example, erasure errors temporarily set some edges to 0 weight. When it clears, those edges must be reverted back to the original weight

fn prepare_nodes_shrink( &mut self, nodes_circle: &[DualNodePtr], ) -> &mut Vec<SyncRequest>

prepare a list of nodes as shrinking state; useful in creating a blossom

fn prepare_all(&mut self) -> &mut Vec<SyncRequest>

prepare the growing or shrinking state of all nodes and return a list of sync requests in case of mirrored vertices are changed

fn execute_sync_event(&mut self, sync_event: &SyncRequest)

execute a synchronize event by updating the state of a vertex and also update the internal dual node accordingly

fn add_defect_node(&mut self, dual_node_ptr: &DualNodePtr)

helper function to specifically add a syndrome node

fn add_blossom(&mut self, dual_node_ptr: &DualNodePtr)

helper function to specifically add a blossom node

fn load_erasures(&mut self, erasures: &[EdgeIndex])

an erasure error means this edge is totally uncertain: p=0.5, so new weight = ln((1-p)/p) = 0

fn load_dynamic_weights(&mut self, dynamic_weights: &[(EdgeIndex, Weight)])

fn generate_profiler_report(&self) -> Value

performance profiler report

fn new_partitioned( _partitioned_initializer: &PartitionedSolverInitializer, ) -> Self

where Self: Sized,

create a partitioned dual module (hosting only a subgraph and subset of dual nodes) to be used in the parallel dual module

fn contains_dual_node(&self, _dual_node_ptr: &DualNodePtr) -> bool

judge whether the current module hosts the dual node

fn contains_dual_nodes_any(&self, dual_node_ptrs: &[DualNodePtr]) -> bool

judge whether the current module hosts any of these dual node

fn contains_vertex(&self, _vertex_index: VertexIndex) -> bool

judge whether the current module hosts a vertex

fn bias_dual_node_index(&mut self, _bias: NodeIndex)

bias the global dual node indices

impl<SerialModule: DualModuleImpl + FusionVisualizer + Send + Sync> FusionVisualizer for DualModuleParallelUnit<SerialModule>

fn snapshot(&self, abbrev: bool) -> Value

take a snapshot, set abbrev to true to save space