Struct DBSPHandle 

pub struct DBSPHandle { /* private fields */ }

A handle to control the execution of a circuit in a multithreaded runtime.

Implementations

impl DBSPHandle

pub fn runtime(&self) -> &Runtime

pub fn transaction(&mut self) -> Result<(), DbspError>

Start and instantly commit a transaction, waiting for the commit to complete.

pub fn start_transaction(&mut self) -> Result<(), DbspError>

Start a transaction.

A transaction consists of a sequence of steps that evaluate a set of inputs for a single logical clock tick.

Transaction lifecycle:

                             is_commit_complete() = true
   ┌────────────────────────────────────────────────────────────────────────────────────┐
   ▼                                                                                    │
┌───────┐      start_transaction()      ┌───────────┐ start_commit_transaction()  ┌─────┴────┐
│ idle  ├──────────────────────────────►│in progress├────────────────────────────►│committing│
└───────┘                               └────────┬──┘                             └─────────┬┘
                                          ▲      │                                    ▲     │
                                          └──────┘                                    └─────┘
                                           step()                                      step()

The value of the circuit’s logical clock remains unchanged during the transaction. The clock advances between transactions.

pub fn step(&mut self) -> Result<bool, DbspError>

Evaluate the circuit for a single step.

In the in progress state of the transaction, this method always returns false.

In the committing state, this method returns true when the commit is complete and the circuit has produced all outputs for the inputs received during the transaction.

pub fn start_commit_transaction(&mut self) -> Result<(), DbspError>

Start committing the current transaction by forcing all operators to process their inputs to completion.

The caller must invoke step repeatedly until the commit is complete.

pub fn commit_transaction(&mut self) -> Result<(), DbspError>

Convenience method that calls start_commit_transaction and then repeatedly calls step until the commit is complete.

pub fn commit_progress(&mut self) -> Result<WorkersCommitProgress, DbspError>

Estimated commit progress.

pub fn set_replay_step_size(&mut self, step_size: usize)

pub fn get_replay_step_size(&self) -> usize

pub fn bootstrap_in_progress(&self) -> bool

The circuit has been resumed from a checkpoint and is currently bootstrapping the modified part of the circuit.

pub fn bootstrap_info(&self) -> &Option<BootstrapInfo>

In the bootstrap mode, returns information about operators involved in bootstrapping.

pub fn runtime_elapsed(&self) -> Duration

Returns the time elapsed while the circuit is executing a step, multiplied by the number of foreground and background threads.

pub fn fingerprint(&self) -> Option<u64>

Fingerprint of this circuit.

We only keep the fingerprint if the circuit has storage, since it’s to make sure that the running circuit matches whatever we stored.

pub fn checkpoint(&mut self) -> CheckpointBuilder<'_>

Allows creating a new checkpoint by taking a consistent snapshot of the state in dbsp.

pub fn list_checkpoints(&mut self) -> Result<Vec<CheckpointMetadata>, DbspError>

List all currently available checkpoints.

pub fn gc_checkpoint(&mut self) -> Result<Option<CheckpointMetadata>, DbspError>

Remove the oldest checkpoint from the list.

Returns

• Metadata of the removed checkpoint, if one was removed.
• None otherwise.

pub fn enable_cpu_profiler(&mut self) -> Result<(), DbspError>

Enable CPU profiler.

Enable recording of CPU usage info. When CPU profiling is enabled, Self::dump_profile outputs CPU usage info along with memory usage and other circuit metadata. CPU profiling introduces small runtime overhead.

pub fn dump_profile<P: AsRef<Path>>( &mut self, dir_path: P, ) -> Result<PathBuf, DbspError>

Dump profiling information to the specified directory.

Creates dir_path if it doesn’t exist. For each worker thread, creates dir_path/<timestamp>/<worker>.dot file containing worker profile in the graphviz format. If CPU profiling was enabled (see Self::enable_cpu_profiler), the profile will contain both CPU and memory usage information; otherwise only memory usage details are reported.

pub fn graph_profile(&mut self) -> Result<GraphProfile, DbspError>

Returns an array of worker profiles in graphviz .dot format. Each array element corresponds to the profile of the corresponding worker. If CPU profiling was enabled (see Self::enable_cpu_profiler), the profile will contain both CPU and memory usage information; otherwise only memory usage details are reported.

pub fn retrieve_profile(&mut self) -> Result<DbspProfile, DbspError>

pub fn lir(&mut self) -> Result<LirCircuit, DbspError>

pub fn kill(self) -> ThreadResult<()>

Terminate the execution of the circuit, exiting all worker threads.

If one or more of the worker threads panics, returns the argument the panic! macro was called with (see std::thread::Result).

This is the preferred way of killing a circuit. Simply dropping the handle will have the same effect, but without reporting the error status.

pub fn set_balancer_hint( &mut self, global_node_id: &GlobalNodeId, hint: BalancerHint, ) -> Result<(), DbspError>

pub fn set_balancer_hints( &mut self, hints: Vec<(GlobalNodeId, BalancerHint)>, ) -> Result<Vec<Result<(), DbspError>>, DbspError>

pub fn get_current_balancer_policy( &mut self, ) -> Result<BTreeMap<GlobalNodeId, PartitioningPolicy>, DbspError>

Trait Implementations

impl Debug for DBSPHandle

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

Formats the value using the given formatter.

impl Drop for DBSPHandle

fn drop(&mut self)

Executes the destructor for this type.