Struct hvmc::run::Net

pub struct Net<'a> {
    pub tid: usize,
    pub tids: usize,
    pub heap: Heap<'a>,
    pub rdex: Vec<(Ptr, Ptr)>,
    pub locs: Vec<Loc>,
    pub area: Area,
    pub next: usize,
    pub rwts: Rewrites,
}

Fields

tid: usize

tids: usize

heap: Heap<'a>

rdex: Vec<(Ptr, Ptr)>

locs: Vec<Loc>

area: Area

next: usize

rwts: Rewrites

Implementations

impl<'a> Net<'a>

pub fn call_native(&mut self, book: &Book, ptr: Ptr, x: Ptr) -> bool

impl<'a> Net<'a>

pub fn new(data: &'a Data) -> Self

pub fn boot(&mut self, root_id: Val)

pub fn rewrites(&self) -> usize

pub fn alloc(&mut self, size: usize) -> Loc

pub fn get_target(&self, ptr: Ptr) -> Ptr

pub fn set_target(&mut self, ptr: Ptr, val: Ptr)

pub fn swap_target(&self, ptr: Ptr, value: Ptr) -> Ptr

pub fn take_target(&self, ptr: Ptr) -> Ptr

pub fn cas_target( &self, ptr: Ptr, expected: Ptr, value: Ptr ) -> Result<Ptr, Ptr>

pub fn redux(&mut self, a: Ptr, b: Ptr)

pub fn get(&self, a: Trg) -> Ptr

pub fn swap(&self, a: Trg, val: Ptr) -> Ptr

pub fn link(&mut self, a_ptr: Ptr, b_ptr: Ptr)

pub fn atomic_link(&mut self, a_dir: Ptr, b_dir: Ptr)

pub fn half_atomic_link(&mut self, a_dir: Ptr, b_ptr: Ptr)

pub fn linker(&mut self, a_ptr: Ptr, b_ptr: Ptr)

pub fn atomic_linker(&mut self, a_ptr: Ptr, a_dir: Ptr, b_ptr: Ptr)

pub fn atomic_linker_pri(&mut self, a_ptr: Ptr, a_dir: Ptr, b_ptr: Ptr)

pub fn atomic_linker_var(&mut self, a_ptr: Ptr, a_dir: Ptr, b_ptr: Ptr)

pub fn safe_link(&mut self, a: Trg, b: Trg)

pub fn interact(&mut self, book: &Book, a: Ptr, b: Ptr)

pub fn anni(&mut self, a: Ptr, b: Ptr)

pub fn comm(&mut self, a: Ptr, b: Ptr)

pub fn era2(&mut self, a: Ptr)

pub fn era1(&mut self, a: Ptr)

pub fn pass(&mut self, a: Ptr, b: Ptr)

pub fn copy(&mut self, a: Ptr, b: Ptr)

pub fn mtch(&mut self, a: Ptr, b: Ptr)

pub fn op2n(&mut self, a: Ptr, b: Ptr)

pub fn op1n(&mut self, a: Ptr, b: Ptr)

pub fn op(&self, op: Lab, a: Val, b: Val) -> Val

pub fn call(&mut self, book: &Book, ptr: Ptr, trg: Ptr)

pub fn reduce(&mut self, book: &Book, limit: usize) -> usize

pub fn expand(&mut self, book: &Book)

pub fn normal(&mut self, book: &Book)

pub fn fork(&self, tid: usize, tids: usize) -> Self

pub fn parallel_normal(&mut self, book: &Book)