Struct MultiStream 

pub struct MultiStream<B: EventStreamBackend> {
    pub logger: Arc<ServerLogger>,
    /* private fields */
}

Manages multiple streams with synchronization logic based on shared bindings.

This struct handles the creation and alignment of streams to ensure proper synchronization when bindings (e.g., buffers) are shared across different streams.

Fields

logger: Arc<ServerLogger>

The logger used by the server.

Implementations

impl<B: EventStreamBackend> MultiStream<B>

pub fn backend_mut(&mut self) -> &mut B

Mutable access to the stream-creation backend, e.g. to change the configuration new streams are created with. Already-created streams are unaffected.

pub fn new(logger: Arc<ServerLogger>, backend: B, max_streams: u8) -> Self

Creates an empty multi-stream.

pub fn stream_ids(&self) -> impl Iterator<Item = StreamId> + '_

Synthetic StreamIds, one per initialized stream (see StreamPool::stream_ids).

pub fn gc(&mut self, gc: GcTask<B>)

Enqueue a task to be cleaned.

pub fn try_stream_mut(&mut self, stream_id: &StreamId) -> Option<&mut B::Stream>

The backend stream on stream_id’s slot when that slot was ever initialized, mutably — a lookup that must not create a stream (see StreamPool::try_get_mut).

pub fn resolve<'a>( &mut self, stream_id: StreamId, handles: impl Iterator<Item = &'a BufferBinding>, ) -> ResolvedStreams<'_, B>

Resolves and returns a mutable reference to the stream for the given ID, performing any necessary alignment based on the provided bindings.

This method ensures that the stream is synchronized with any shared bindings from other streams before returning the stream reference.

Trait Implementations

impl<B: Debug + EventStreamBackend> Debug for MultiStream<B>

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

Formats the value using the given formatter.

impl<B: EventStreamBackend> FailureStore for MultiStream<B>

type Factory = EventStreamBackendWrapper<B>

The factory the driver’s StreamPool was built from. Its streams expose the memory the taint is recorded on.

fn split(&mut self) -> (&mut StreamPool<Self::Factory>, &mut Failures)

The pool and the store, split-borrowed: nearly every operation here reaches the allocations through the pool while mutating the store.

fn parts(&self) -> (&StreamPool<Self::Factory>, &Failures)

split for the read-only questions.

fn ensure_written<'a>( &self, handles: impl Iterator<Item = &'a BufferBinding>, ) -> Result<(), ServerError>

Fails when the buffers handles name carry a failure, with the errors of the work that was supposed to write them.

fn read_failure<'a>( &self, reads: impl Iterator<Item = &'a BufferBinding>, ) -> Option<ReadFailure>

The failure claiming bytes any of reads names, with its error — the check a launch makes before it runs.

fn taint<'a>( &mut self, error: ServerError, written: impl Iterator<Item = &'a BufferBinding>, )

Taint every allocation in written with error: the work that was going to write those buffers did not run, so a read of any of them fails on this failure until something writes them again.

fn written<'a>(&mut self, written: impl Iterator<Item = &'a BufferBinding>)

Release the failure on every allocation in written: work that writes them has been enqueued, so a read of one is no longer reading bytes nothing wrote.

fn propagate( &mut self, found: &ReadFailure, kernel: KernelId, written: Vec<BufferBinding>, )

A skipped launch’s outputs take the failure that stopped it: nothing wrote them, exactly as if the launch had failed, and the claim names the root cause rather than minting a new one. The skip is recorded on the failure, so a read of anything downstream can name the path back to the root.

fn write_set(&mut self) -> Vec<BufferBinding>

An empty write set, pooled here so a launch allocates nothing for it. exit_write hands it back.

fn enter_write(&mut self, written: &[BufferBinding]) -> Option<FailureId>

Enter a write scope over written: taint every buffer the work is going to write with a provisional failure, minted here because the real one does not exist yet.

fn exit_write( &mut self, provisional: Option<FailureId>, written: Vec<BufferBinding>, error: Option<&ServerError>, )

Settle the scope entered over written: release the provisional failure when the work was enqueued, and swap the real error in for it when the work was not. The taint is the whole answer — a read of one of these buffers fails on it, whoever asks — and the error is logged here, the backstop for the failure nobody ever reads. The staged vector goes back to the pool either way.