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.

For a fence the driver refused to create or record, its stream is synchronized on the spot. Only when that fails too does the fence hold the error.

Implementations

impl<A: EventApi> EventFence<A>

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

Record a fence at the current position of stream.

When the driver refuses the event, stream is synchronized instead, which keeps every guarantee a fence gives.

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

Returns a ServerError if the driver refused to create or record the fence, or if the device was already faulty.

pub fn wait_async(self, stream: A::Stream) -> Result<(), ServerError>

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, unless the driver refuses the dependency: the host then waits for the fence itself, which orders the work just the same.

Errors

Returns a ServerError when the fenced stream’s work failed.

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) -> bool

wait.