Struct EventFence 

pub struct EventFence<A: EventApi> { /* private fields */ }

An event recorded on a stream and handed out, so a caller can wait for that stream’s work from outside the server.

The server sits behind a mutex or a channel, so a synchronize that blocked while holding it would stall every other logical stream too. Recording an event costs the host nothing: the server records one and returns, and whoever holds the fence waits on its own time.

Named for the trait it is not: memory_management::drop_queue::Fence is the contract, and this is the implementation of it that a device event gives you. Backends alias it back to Fence for their own call sites. Named in prose rather than linked because that trait is multi_threading-only while this type is not — the fence itself is two driver calls and wants no threads.

Its event is created and destroyed outright rather than recycled through the pool an EventProfiler keeps: a fence is raised from StreamBackend::flush, which is handed a stream and nothing else, so there is no pool in reach without threading one through that trait. Pool these too once something else needs the same argument.

Implementations

impl<A: EventApi> EventFence<A>

pub fn new(stream: A::Stream) -> Self

Record a fence at the current position of stream.

Panics

A fence that never recorded cannot be waited on, and every caller takes one by value expecting to be able to. There is no useful weaker answer than failing here.

pub fn wait_sync(self) -> Result<(), ServerError>

Block until the device has reached this fence, so everything enqueued on its stream beforehand is done.

Errors

The fault the wait reveals, when the stream itself failed.

pub fn wait_async(self, stream: A::Stream)

Make stream wait for this fence on the device, so work queued on it afterwards runs behind the fenced stream’s. Does not block the host.

Panics

A refused dependency would let stream run ahead of work it must follow, which is a wrong answer rather than a slow one.

Trait Implementations

impl<A: EventApi> Debug for EventFence<A>

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

Formats the value using the given formatter.

impl<A: EventApi> Fence for EventFence<A>

Available on multi_threading only.

The drop queue is where a fence pays off — a freed host buffer waits on one rather than on the server — and it is multi_threading-only, so the impl is too. Everything above it is the same fence either way.

fn wait(self) -> Result<(), ServerError>

Block the current thread until the device signals this fence.

fn sync(self)

wait, ignoring a fault.