Struct timely::dataflow::scopes::child::Child

pub struct Child<'a, G, T> where
    G: ScopeParent,
    T: Timestamp + Refines<G::Timestamp>,  {
    pub subgraph: &'a RefCell<SubgraphBuilder<G::Timestamp, T>>,
    pub parent: G,
    pub logging: Option<Logger>,
}

A Child wraps a Subgraph and a parent G: Scope. It manages the addition of Operates to a subgraph, and the connection of edges between them.

Fields

subgraph: &'a RefCell<SubgraphBuilder<G::Timestamp, T>>

The subgraph under assembly.

parent: G

A copy of the child's parent scope.

logging: Option<Logger>

The log writer for this scope.

Methods

impl<'a, G, T> Child<'a, G, T> where
    G: ScopeParent,
    T: Timestamp + Refines<G::Timestamp>, 

pub fn index(&self) -> usize

This worker's unique identifier.

Ranges from 0 to self.peers() - 1.

pub fn peers(&self) -> usize

The total number of workers in the computation.

Trait Implementations

impl<'a, G, T> AsWorker for Child<'a, G, T> where
    G: ScopeParent,
    T: Timestamp + Refines<G::Timestamp>, 

fn index(&self) -> usize

Index of the worker among its peers.

fn peers(&self) -> usize

Number of peer workers.

fn allocate<D: Data>(
    &mut self,
    identifier: usize,
    address: &[usize]
) -> (Vec<Box<dyn Push<Message<D>>>>, Box<dyn Pull<Message<D>>>)

Allocates a new channel from a supplied identifier and address.

fn pipeline<D: 'static>(
    &mut self,
    identifier: usize,
    address: &[usize]
) -> (ThreadPusher<Message<D>>, ThreadPuller<Message<D>>)

Constructs a pipeline channel from the worker to itself.

fn new_identifier(&mut self) -> usize

Allocates a new worker-unique identifier.

fn log_register(&self) -> RefMut<Registry<WorkerIdentifier>>

Provides access to named logging streams.

fn logging(&self) -> Option<TimelyLogger>

Provides access to the timely logging stream.

impl<'a, G, T> ScopeParent for Child<'a, G, T> where
    G: ScopeParent,
    T: Timestamp + Refines<G::Timestamp>, 

type Timestamp = T

The timestamp associated with data in this scope.

impl<'a, G, T> Scope for Child<'a, G, T> where
    G: ScopeParent,
    T: Timestamp + Refines<G::Timestamp>, 

fn name(&self) -> String

A useful name describing the scope.

fn addr(&self) -> Vec<usize>

A sequence of scope identifiers describing the path from the worker root to this scope.

fn add_edge(&self, source: Source, target: Target)

Connects a source of data with a target of the data. This only links the two for the purposes of tracking progress, rather than effect any data movement itself.

fn add_operator_with_indices(
    &mut self,
    operator: Box<dyn Operate<Self::Timestamp>>,
    local: usize,
    global: usize
)

Adds a child Operate to the builder's scope using supplied indices.

fn allocate_operator_index(&mut self) -> usize

Allocates a new scope-local operator index.

fn scoped<T2, R, F>(&mut self, name: &str, func: F) -> R where
    T2: Timestamp + Refines<T>,
    F: FnOnce(&mut Child<Self, T2>) -> R, 

Creates a dataflow subgraph.

fn add_operator(&mut self, operator: Box<dyn Operate<Self::Timestamp>>) -> usize

Adds a child Operate to the builder's scope. Returns the new child's index.

fn add_operator_with_index(
    &mut self,
    operator: Box<dyn Operate<Self::Timestamp>>,
    index: usize
)

Adds a child Operate to the builder's scope using a supplied index.

fn iterative<T, R, F>(&mut self, func: F) -> R where
    T: Timestamp,
    F: FnOnce(&mut Child<Self, Product<Self::Timestamp, T>>) -> R, 

Creates a iterative dataflow subgraph.

fn region<R, F>(&mut self, func: F) -> R where
    F: FnOnce(&mut Child<Self, Self::Timestamp>) -> R, 

Creates a dataflow region with the same timestamp.

impl<'a, G, T> Scheduler for Child<'a, G, T> where
    G: ScopeParent,
    T: Timestamp + Refines<G::Timestamp>, 

fn activations(&self) -> Rc<RefCell<Activations>>

Provides a shared handle to the activation scheduler.

fn activator_for(&self, path: &[usize]) -> Activator

Constructs an Activator tied to the specified operator address.

fn sync_activator_for(&self, path: &[usize]) -> SyncActivator

Constructs a SyncActivator tied to the specified operator address.

impl<'a, G, T> Clone for Child<'a, G, T> where
    G: ScopeParent,
    T: Timestamp + Refines<G::Timestamp>, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.