Enum mz_compute::logging::compute::ComputeEvent

pub enum ComputeEvent {
    Export {
        id: GlobalId,
        dataflow_index: usize,
    },
    ExportDropped {
        id: GlobalId,
    },
    Peek {
        peek: Peek,
        peek_type: PeekType,
        installed: bool,
    },
    Frontier {
        id: GlobalId,
        time: Timestamp,
        diff: i8,
    },
    ImportFrontier {
        import_id: GlobalId,
        export_id: GlobalId,
        time: Timestamp,
        diff: i8,
    },
    ArrangementHeapSize {
        operator: usize,
        delta_size: isize,
    },
    ArrangementHeapCapacity {
        operator: usize,
        delta_capacity: isize,
    },
    ArrangementHeapAllocations {
        operator: usize,
        delta_allocations: isize,
    },
    ArrangementHeapSizeOperator {
        operator: usize,
        address: Rc<[usize]>,
    },
    ArrangementHeapSizeOperatorDrop {
        operator: usize,
    },
    DataflowShutdown {
        dataflow_index: usize,
    },
    ErrorCount {
        export_id: GlobalId,
        diff: i64,
    },
    Hydration {
        export_id: GlobalId,
    },
    LirMapping {
        global_id: GlobalId,
        mapping: Box<[(LirId, LirMetadata)]>,
    },
    DataflowGlobal {
        id: usize,
        global_id: GlobalId,
    },
}

A logged compute event.

Variants

Export

A dataflow export was created.

Fields

id: GlobalId

Identifier of the export.

dataflow_index: usize

Timely worker index of the exporting dataflow.

ExportDropped

A dataflow export was dropped.

Fields

id: GlobalId

Identifier of the export.

Peek

Peek command.

Fields

peek: Peek

The data for the peek itself.

peek_type: PeekType

The relevant type of peek: index or persist.

installed: bool

True if the peek is being installed; false if it’s being removed.

Frontier

Available frontier information for dataflow exports.

Fields

id: GlobalId

time: Timestamp

diff: i8

ImportFrontier

Available frontier information for dataflow imports.

Fields

import_id: GlobalId

export_id: GlobalId

time: Timestamp

diff: i8

ArrangementHeapSize

Arrangement heap size update

Fields

operator: usize

Operator index

delta_size: isize

Delta of the heap size in bytes of the arrangement.

ArrangementHeapCapacity

Arrangement heap size update

Fields

operator: usize

Operator index

delta_capacity: isize

Delta of the heap capacity in bytes of the arrangement.

ArrangementHeapAllocations

Arrangement heap size update

Fields

operator: usize

Operator index

delta_allocations: isize

Delta of distinct heap allocations backing the arrangement.

ArrangementHeapSizeOperator

Arrangement size operator address

Fields

operator: usize

Operator index

address: Rc<[usize]>

The address of the operator.

ArrangementHeapSizeOperatorDrop

Arrangement size operator dropped

Fields

operator: usize

Operator index

DataflowShutdown

All operators of a dataflow have shut down.

Fields

dataflow_index: usize

Timely worker index of the dataflow.

ErrorCount

The number of errors in a dataflow export has changed.

Fields

export_id: GlobalId

Identifier of the export.

diff: i64

The change in error count.

Hydration

A dataflow export was hydrated.

Fields

export_id: GlobalId

LirMapping

An LIR operator was mapped to some particular dataflow operator.

Cf. ComputeLog::LirMaping

Fields

global_id: GlobalId

The GlobalId in which the LIR operator is rendered.

NB a single a dataflow may have many GlobalIds inside it. A separate mapping (using ComputeEvent::DataflowGlobal) tracks the many-to-one relationship between GlobalIds and dataflows.

mapping: Box<[(LirId, LirMetadata)]>

The actual mapping. Represented this way to reduce the size of ComputeEvent.

DataflowGlobal

Fields

id: usize

The identifier of the dataflow.

global_id: GlobalId

A GlobalId that is rendered as part of this dataflow.

Trait Implementations

impl Clone for ComputeEvent

fn clone(&self) -> ComputeEvent

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ComputeEvent

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

Formats the value using the given formatter.

impl PartialEq for ComputeEvent

fn eq(&self, other: &ComputeEvent) -> 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 PartialOrd for ComputeEvent

fn partial_cmp(&self, other: &ComputeEvent) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for ComputeEvent