Struct SchedulerMultiStream 

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

Represents a multi-stream scheduler that manages task execution across multiple streams.

Fields

logger: Arc<ServerLogger>

Server logger.

Implementations

impl<B: SchedulerStreamBackend> SchedulerMultiStream<B>

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

Creates a new SchedulerMultiStream with the given backend and options.

pub fn stream(&mut self, stream_id: &StreamId) -> &mut B::Stream

Returns a mutable reference to the backend stream for a given stream ID.

pub fn stream_and_failures( &mut self, stream_id: &StreamId, ) -> (&mut B::Stream, &mut ErrorGraph)

The stream at stream_id and the device’s failure store together, for the paths that hand the store to the stream’s memory manager — every reserve, bind and cleanup, since those are where slices shed the failures they carry.

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

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

pub fn streams(&self) -> impl Iterator<Item = &B::Stream>

Read-only iterator over initialized backend streams.

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

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

pub fn register( &mut self, stream_id: StreamId, task: B::Task, args_streams: &[StreamId], )

Registers a task for execution on a specific stream, ensuring stream alignment.

pub fn execute_streams(&mut self, stream_ids: Vec<StreamId>)

Executes tasks from the specified streams based on the scheduling strategy.

Trait Implementations

impl<B: Debug + SchedulerStreamBackend> Debug for SchedulerMultiStream<B>

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

Formats the value using the given formatter.

impl<B: SchedulerStreamBackend> FailureStore for SchedulerMultiStream<B>

type Factory = SchedulerPoolMarker<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.