DPC++ Runtime
Runtime libraries for oneAPI DPC++
sycl::_V1::detail::Scheduler Class Reference

DPC++ graph scheduler class. More...

#include <detail/scheduler/scheduler.hpp>

Collaboration diagram for sycl::_V1::detail::Scheduler:

Classes

class  GraphBuilder
 Graph builder class. More...
 
struct  GraphBuildResult
 
class  GraphProcessor
 Graph Processor provides interfaces for enqueueing commands and their dependencies to the underlying runtime. More...
 

Public Member Functions

EventImplPtr addCG (std::unique_ptr< detail::CG > CommandGroup, const QueueImplPtr &Queue, bool EventNeeded, sycl::detail::pi::PiExtCommandBuffer CommandBuffer=nullptr, const std::vector< sycl::detail::pi::PiExtSyncPoint > &Dependencies={})
 Registers a command group, and adds it to the dependency graph. More...
 
EventImplPtr addCopyBack (Requirement *Req)
 Registers a command group, that copies most recent memory to the memory pointed by the requirement. More...
 
void waitForEvent (const EventImplPtr &Event, bool *Success=nullptr)
 Waits for the event. More...
 
bool removeMemoryObject (detail::SYCLMemObjI *MemObj, bool StrictLock=true)
 Removes buffer from the graph. More...
 
EventImplPtr addHostAccessor (Requirement *Req)
 Adds nodes to the graph, that update the requirement with the pointer to the host memory. More...
 
void releaseHostAccessor (Requirement *Req)
 Unblocks operations with the memory object. More...
 
void deferMemObjRelease (const std::shared_ptr< detail::SYCLMemObjI > &MemObj)
 
void startFusion (QueueImplPtr Queue)
 
void cleanUpCmdFusion (sycl::detail::queue_impl *Queue)
 
void cancelFusion (QueueImplPtr Queue)
 
EventImplPtr completeFusion (QueueImplPtr Queue, const property_list &)
 
bool isInFusionMode (QueueIdT Queue)
 
void releaseResources (BlockingT Blocking=BlockingT::BLOCKING)
 
bool isDeferredMemObjectsEmpty ()
 
void enqueueCommandForCG (EventImplPtr NewEvent, std::vector< Command * > &AuxilaryCmds, BlockingT Blocking=NON_BLOCKING)
 
EventImplPtr addCommandGraphUpdate (ext::oneapi::experimental::detail::exec_graph_impl *Graph, std::vector< std::shared_ptr< ext::oneapi::experimental::detail::node_impl >> Nodes, const QueueImplPtr &Queue, std::vector< Requirement * > Requirements, std::vector< detail::EventImplPtr > &Events)
 Adds a command buffer update operation to the execution graph. More...
 

Static Public Member Functions

static SchedulergetInstance ()
 
static bool isInstanceAlive ()
 
static MemObjRecordgetMemObjRecord (const Requirement *const Req)
 
static bool areEventsSafeForSchedulerBypass (const std::vector< sycl::event > &DepEvents, ContextImplPtr Context)
 
static bool areEventsSafeForSchedulerBypass (const std::vector< EventImplPtr > &DepEvents, ContextImplPtr Context)
 

Protected Types

using RWLockT = std::shared_timed_mutex
 
using ReadLockT = std::shared_lock< RWLockT >
 
using WriteLockT = std::unique_lock< RWLockT >
 

Protected Member Functions

WriteLockT acquireWriteLock ()
 Provides exclusive access to std::shared_timed_mutex object with deadlock avoidance. More...
 
WriteLockT acquireFusionWriteLock ()
 Provides exclusive access to std::shared_timed_mutex object with deadlock avoidance to the Fusion map. More...
 
ReadLockT acquireReadLock ()
 Provides shared access to std::shared_timed_mutex object with deadlock avoidance. More...
 
ReadLockT acquireFusionReadLock ()
 Provides shared access to std::shared_timed_mutex object with deadlock avoidance to the Fusion map. More...
 
void cleanupCommands (const std::vector< Command * > &Cmds)
 
void NotifyHostTaskCompletion (Command *Cmd)
 
void cleanupDeferredMemObjects (BlockingT Blocking)
 
void takeAuxiliaryResources (const EventImplPtr &Dst, const EventImplPtr &Src)
 Assign Src's auxiliary resources to Dst. More...
 
void registerAuxiliaryResources (EventImplPtr &Event, std::vector< std::shared_ptr< const void >> Resources)
 
void cleanupAuxiliaryResources (BlockingT Blocking)
 
void waitForRecordToFinish (MemObjRecord *Record, ReadLockT &GraphReadLock)
 This function waits on all of the graph leaves which somehow use the memory object which is represented by Record. More...
 
bool checkLeavesCompletion (MemObjRecord *Record)
 

Static Protected Member Functions

static void enqueueLeavesOfReqUnlocked (const Requirement *const Req, ReadLockT &GraphReadLock, std::vector< Command * > &ToCleanUp)
 
static void enqueueUnblockedCommands (const std::vector< EventImplPtr > &CmdsToEnqueue, ReadLockT &GraphReadLock, std::vector< Command * > &ToCleanUp)
 

Protected Attributes

GraphBuilder MGraphBuilder
 
RWLockT MGraphLock
 
RWLockT MFusionMapLock
 
std::vector< Command * > MDeferredCleanupCommands
 
std::mutex MDeferredCleanupMutex
 
std::vector< std::shared_ptr< SYCLMemObjI > > MDeferredMemObjRelease
 
std::mutex MDeferredMemReleaseMutex
 
std::unordered_map< EventImplPtr, std::vector< std::shared_ptr< const void > > > MAuxiliaryResources
 
std::mutex MAuxiliaryResourcesMutex
 

Friends

class Command
 
class DispatchHostTask
 
class queue_impl
 
class event_impl
 
class ::MockScheduler
 

Detailed Description

DPC++ graph scheduler class.

Scheduler Overview

The Scheduler is a part of DPC++ RT which ensures correct execution of command groups. To achieve this Scheduler manages acyclic dependency graph (which can have independent sub-graphs) that consists of several types of nodes that represent specific commands:

  1. Allocate memory. The command represents memory allocation operation. There can be multiple allocations for a single SYCL memory object.
  2. Release memory. The command represents memory release operation.
  3. Execute command group. The command represents Command Group (kernel) execution operation.
  4. Copy memory. The command represents memory copy operation between two memory allocations of a single memory object.

As the main input Scheduler takes a command group and returns an event representing it, so it can be waited on later. When a new command group comes, Scheduler adds one or more nodes to the graph depending on the command groups' requirements. For example, if a new command group is submitted to the SYCL context which has the latest data for all the requirements, Scheduler adds a new "Execute command group" command making it dependent on all commands affecting new command group's requirements. But if one of the requirements has no up-to-date instance in the context which the command group is submitted to, Scheduler additionally inserts copy memory command (together with allocate memory command if needed).

A simple graph looks like:

dot_inline_dotgraph_5.png

Where nodes represent commands and edges represent dependencies between them. There are three commands connected by arrows which mean that before executing second command group the first one must be executed. Also before executing the first command group memory allocation must be performed.

At some point Scheduler enqueues commands to the underlying devices. To do this, Scheduler performs topological sort to get the order in which commands should be enqueued. For example, the following graph (D depends on B and C, B and C depends on A) will be enqueued in the following order:

EventA = Enqueue(A, /*Deps=*/{});
EventB = Enqueue(B, /*Deps=*/{EventA});
EventC = Enqueue(C, /*Deps=*/{EventA});
EventD = Enqueue(D, /*Deps=*/{EventB, EventC});
dot_inline_dotgraph_6.png

Implementation details

The Scheduler is split up into two parts: graph builder and graph processor.

To build dependencies, Scheduler needs to memorize memory objects and commands that modify them.

To detect that two command groups access the same memory object and create a dependency between them, Scheduler needs to store information about the memory object.

Thread safety

To ensure thread safe execution of methods, Scheduler provides access to the graph that's guarded by a read-write mutex (analog of shared mutex from C++17).

A read-write mutex allows concurrent access to read-only operations, while write operations require exclusive access.

All the methods of GraphBuilder lock the mutex in write mode because these methods can modify the graph. Methods of GraphProcessor lock the mutex in read mode as they are not modifying the graph.

Error handling

There are two sources of errors that needs to be handled in Scheduler:

  1. errors that happen during command enqueue process
  2. the error that happend during command execution.

If an error occurs during command enqueue process, the Command::enqueue method returns the faulty command. Scheduler then reschedules the command and all dependent commands (if any).

An error with command processing can happen in underlying runtime, in this case Scheduler is notified asynchronously (using callback mechanism) what triggers rescheduling.

Definition at line 366 of file scheduler.hpp.

Member Typedef Documentation

◆ ReadLockT

using sycl::_V1::detail::Scheduler::ReadLockT = std::shared_lock<RWLockT>
protected

Definition at line 498 of file scheduler.hpp.

◆ RWLockT

using sycl::_V1::detail::Scheduler::RWLockT = std::shared_timed_mutex
protected

Definition at line 497 of file scheduler.hpp.

◆ WriteLockT

using sycl::_V1::detail::Scheduler::WriteLockT = std::unique_lock<RWLockT>
protected

Definition at line 499 of file scheduler.hpp.

Member Function Documentation

◆ acquireFusionReadLock()

ReadLockT sycl::_V1::detail::Scheduler::acquireFusionReadLock ( )
inlineprotected

Provides shared access to std::shared_timed_mutex object with deadlock avoidance to the Fusion map.

Definition at line 545 of file scheduler.hpp.

References MFusionMapLock.

Referenced by isInFusionMode().

◆ acquireFusionWriteLock()

WriteLockT sycl::_V1::detail::Scheduler::acquireFusionWriteLock ( )
inlineprotected

Provides exclusive access to std::shared_timed_mutex object with deadlock avoidance to the Fusion map.

Definition at line 522 of file scheduler.hpp.

References MFusionMapLock.

Referenced by cancelFusion(), cleanUpCmdFusion(), completeFusion(), and startFusion().

◆ acquireReadLock()

ReadLockT sycl::_V1::detail::Scheduler::acquireReadLock ( )
inlineprotected

Provides shared access to std::shared_timed_mutex object with deadlock avoidance.

Definition at line 541 of file scheduler.hpp.

References MGraphLock.

Referenced by addCommandGraphUpdate(), addCopyBack(), addHostAccessor(), enqueueCommandForCG(), NotifyHostTaskCompletion(), releaseHostAccessor(), and waitForEvent().

◆ acquireWriteLock()

WriteLockT sycl::_V1::detail::Scheduler::acquireWriteLock ( )
inlineprotected

Provides exclusive access to std::shared_timed_mutex object with deadlock avoidance.

Definition at line 503 of file scheduler.hpp.

References MGraphLock.

Referenced by addCG(), addCommandGraphUpdate(), addCopyBack(), addHostAccessor(), cancelFusion(), completeFusion(), removeMemoryObject(), and startFusion().

◆ addCG()

EventImplPtr sycl::_V1::detail::Scheduler::addCG ( std::unique_ptr< detail::CG CommandGroup,
const QueueImplPtr Queue,
bool  EventNeeded,
sycl::detail::pi::PiExtCommandBuffer  CommandBuffer = nullptr,
const std::vector< sycl::detail::pi::PiExtSyncPoint > &  Dependencies = {} 
)

Registers a command group, and adds it to the dependency graph.

It's called by SYCL's queue.submit.

Parameters
CommandGroupis a unique_ptr to a command group to be added.
QueueQueue that is registering the command-group.
EventNeededSpecifies whether an event is explicitly required.
CommandBufferOptional command buffer to enqueue to instead of directly to the queue.
DependenciesOptional list of dependency sync points when enqueuing to a command buffer.
Returns
an event object to wait on for command group completion.

Definition at line 95 of file scheduler.cpp.

References acquireWriteLock(), sycl::_V1::detail::Scheduler::GraphBuilder::addCG(), sycl::_V1::detail::Scheduler::GraphBuilder::addCGUpdateHost(), sycl::_V1::detail::CodeplayHostTask, enqueueCommandForCG(), sycl::_V1::detail::Command::getEvent(), MGraphBuilder, registerAuxiliaryResources(), and sycl::_V1::detail::UpdateHost.

◆ addCommandGraphUpdate()

EventImplPtr sycl::_V1::detail::Scheduler::addCommandGraphUpdate ( ext::oneapi::experimental::detail::exec_graph_impl Graph,
std::vector< std::shared_ptr< ext::oneapi::experimental::detail::node_impl >>  Nodes,
const QueueImplPtr Queue,
std::vector< Requirement * >  Requirements,
std::vector< detail::EventImplPtr > &  Events 
)

Adds a command buffer update operation to the execution graph.

This is required when buffers/accessors are updated to ensure that the memory has been allocated when updating.

Parameters
GraphThe executable graph to be updated.
NodesThe list of Nodes which are to be updated in the graph.
RequirementsList of accessor requirements for this update.
EventsList of events that this update operation depends on

Definition at line 649 of file scheduler.cpp.

References acquireReadLock(), acquireWriteLock(), sycl::_V1::detail::Scheduler::GraphBuilder::addCommandGraphUpdate(), cleanupCommands(), sycl::_V1::detail::Scheduler::GraphProcessor::enqueueCommand(), sycl::_V1::detail::Command::getEvent(), sycl::_V1::make_error_code(), MGraphBuilder, sycl::_V1::detail::EnqueueResultT::MResult, sycl::_V1::runtime, and sycl::_V1::detail::EnqueueResultT::SyclEnqueueFailed.

◆ addCopyBack()

EventImplPtr sycl::_V1::detail::Scheduler::addCopyBack ( Requirement Req)

Registers a command group, that copies most recent memory to the memory pointed by the requirement.

Parameters
Reqis a requirement that points to the memory where data is needed.
Returns
an event object to wait on for copy finish.

Definition at line 204 of file scheduler.cpp.

References acquireReadLock(), acquireWriteLock(), sycl::_V1::detail::Scheduler::GraphBuilder::addCopyBack(), cleanupCommands(), sycl::_V1::detail::Scheduler::GraphProcessor::enqueueCommand(), sycl::_V1::detail::Command::getEvent(), sycl::_V1::make_error_code(), MGraphBuilder, sycl::_V1::detail::EnqueueResultT::MResult, sycl::_V1::runtime, and sycl::_V1::detail::EnqueueResultT::SyclEnqueueFailed.

Referenced by sycl::_V1::detail::SYCLMemObjT::updateHostMemory().

◆ addHostAccessor()

EventImplPtr sycl::_V1::detail::Scheduler::addHostAccessor ( Requirement Req)

Adds nodes to the graph, that update the requirement with the pointer to the host memory.

Assumes the host pointer contains the latest data. New operations with the same memory object that have side effects are blocked until releaseHostAccessor(Requirement *Req) is callled.

Parameters
Reqis the requirement to be updated.
Returns
an event which indicates when these nodes are completed and host accessor is ready for use.

Definition at line 290 of file scheduler.cpp.

References acquireReadLock(), acquireWriteLock(), sycl::_V1::detail::Scheduler::GraphBuilder::addHostAccessor(), cleanupCommands(), sycl::_V1::detail::Scheduler::GraphProcessor::enqueueCommand(), sycl::_V1::detail::Command::getEvent(), sycl::_V1::make_error_code(), MGraphBuilder, sycl::_V1::detail::EnqueueResultT::MResult, sycl::_V1::runtime, and sycl::_V1::detail::EnqueueResultT::SyclEnqueueFailed.

Referenced by sycl::_V1::detail::addHostAccessorAndWait().

◆ areEventsSafeForSchedulerBypass() [1/2]

bool sycl::_V1::detail::Scheduler::areEventsSafeForSchedulerBypass ( const std::vector< EventImplPtr > &  DepEvents,
ContextImplPtr  Context 
)
static

Definition at line 725 of file scheduler.cpp.

References all_of().

◆ areEventsSafeForSchedulerBypass() [2/2]

bool sycl::_V1::detail::Scheduler::areEventsSafeForSchedulerBypass ( const std::vector< sycl::event > &  DepEvents,
ContextImplPtr  Context 
)
static

Definition at line 715 of file scheduler.cpp.

References all_of().

Referenced by sycl::_V1::detail::queue_impl::submitMemOpHelper().

◆ cancelFusion()

◆ checkLeavesCompletion()

◆ cleanupAuxiliaryResources()

void sycl::_V1::detail::Scheduler::cleanupAuxiliaryResources ( BlockingT  Blocking)
protected

◆ cleanUpCmdFusion()

void sycl::_V1::detail::Scheduler::cleanUpCmdFusion ( sycl::detail::queue_impl *  Queue)

◆ cleanupCommands()

◆ cleanupDeferredMemObjects()

◆ completeFusion()

◆ deferMemObjRelease()

void sycl::_V1::detail::Scheduler::deferMemObjRelease ( const std::shared_ptr< detail::SYCLMemObjI > &  MemObj)

◆ enqueueCommandForCG()

◆ enqueueLeavesOfReqUnlocked()

◆ enqueueUnblockedCommands()

void sycl::_V1::detail::Scheduler::enqueueUnblockedCommands ( const std::vector< EventImplPtr > &  CmdsToEnqueue,
ReadLockT GraphReadLock,
std::vector< Command * > &  ToCleanUp 
)
staticprotected

◆ getInstance()

◆ getMemObjRecord()

◆ isDeferredMemObjectsEmpty()

bool sycl::_V1::detail::Scheduler::isDeferredMemObjectsEmpty ( )
inline

Definition at line 484 of file scheduler.cpp.

References MDeferredMemObjRelease, and MDeferredMemReleaseMutex.

Referenced by cleanupDeferredMemObjects(), and releaseResources().

◆ isInFusionMode()

◆ isInstanceAlive()

bool sycl::_V1::detail::Scheduler::isInstanceAlive ( )
static
Returns
true if an instance of the scheduler object exists.

Definition at line 248 of file scheduler.cpp.

References sycl::_V1::detail::GlobalHandler::instance(), and sycl::_V1::detail::GlobalHandler::isSchedulerAlive().

Referenced by sycl::_V1::detail::queue_impl::cleanup_fusion_cmd().

◆ NotifyHostTaskCompletion()

◆ registerAuxiliaryResources()

void sycl::_V1::detail::Scheduler::registerAuxiliaryResources ( EventImplPtr Event,
std::vector< std::shared_ptr< const void >>  Resources 
)
protected

◆ releaseHostAccessor()

void sycl::_V1::detail::Scheduler::releaseHostAccessor ( Requirement Req)

Unblocks operations with the memory object.

Parameters
Reqis a requirement that points to the memory object being unblocked.

Definition at line 329 of file scheduler.cpp.

References acquireReadLock(), cleanupCommands(), enqueueLeavesOfReqUnlocked(), sycl::_V1::detail::AccessorImplHost::MBlockedCmd, sycl::_V1::detail::Command::MEnqueueStatus, and sycl::_V1::detail::EnqueueResultT::SyclEnqueueReady.

Referenced by sycl::_V1::detail::AccessorImplHost::~AccessorImplHost().

◆ releaseResources()

void sycl::_V1::detail::Scheduler::releaseResources ( BlockingT  Blocking = BlockingT::BLOCKING)

◆ removeMemoryObject()

bool sycl::_V1::detail::Scheduler::removeMemoryObject ( detail::SYCLMemObjI MemObj,
bool  StrictLock = true 
)

Removes buffer from the graph.

The lifetime of memory object descriptor begins when the first command group that uses the memory object is submitted and ends when "removeMemoryObject(...)" method is called which means there will be no command group that uses the memory object. When removeMemoryObject is called Scheduler will enqueue and wait on all release commands associated with the memory object, which effectively guarantees that all commands accessing the memory object are complete and then the resources allocated for the memory object are freed. Then all the commands affecting the memory object are removed.

This member function is used by buffer and image.

Parameters
MemObjis a memory object that points to the buffer being removed.
StrictLockWA, is a flag used to identify if strict read and write lock are allowed or not. Default value is always applied in buffer_impl destructor. StrictLock == false is introduced for cleanupDeferredMemObjects to avoid blocking mem object release that may lead to dead lock.
Returns
WA, true if all release action completed and we could delete memory object, false otherwise, most possible reason to receive false - fail to obtain write lock.

Definition at line 262 of file scheduler.cpp.

References acquireWriteLock(), sycl::_V1::detail::Scheduler::GraphBuilder::cleanupCommandsForRecord(), sycl::_V1::detail::Scheduler::GraphBuilder::decrementLeafCountersForRecord(), sycl::_V1::detail::Scheduler::GraphBuilder::getMemObjRecord(), MGraphBuilder, MGraphLock, sycl::_V1::detail::Scheduler::GraphBuilder::removeRecordForMemObj(), and waitForRecordToFinish().

Referenced by cleanupDeferredMemObjects(), and sycl::_V1::detail::SYCLMemObjT::updateHostMemory().

◆ startFusion()

◆ takeAuxiliaryResources()

void sycl::_V1::detail::Scheduler::takeAuxiliaryResources ( const EventImplPtr Dst,
const EventImplPtr Src 
)
protected

Assign Src's auxiliary resources to Dst.

Definition at line 549 of file scheduler.cpp.

References MAuxiliaryResources, MAuxiliaryResourcesMutex, and sycl::_V1::detail::registerAuxiliaryResourcesNoLock().

◆ waitForEvent()

void sycl::_V1::detail::Scheduler::waitForEvent ( const EventImplPtr Event,
bool *  Success = nullptr 
)

Waits for the event.

This operation is blocking. For eager execution mode this method invokes corresponding function of device API.

Parameters
Eventis a pointer to event to wait on.
Successis an optional parameter that, when set to a non-null pointer, indicates that failure is a valid outcome for this wait (e.g., in case of a non-blocking read from a pipe), and the value it's pointing to is then set according to the outcome.

Definition at line 252 of file scheduler.cpp.

References acquireReadLock(), cleanupCommands(), and sycl::_V1::detail::Scheduler::GraphProcessor::waitForEvent().

Referenced by sycl::_V1::detail::event_impl::wait().

◆ waitForRecordToFinish()

void sycl::_V1::detail::Scheduler::waitForRecordToFinish ( MemObjRecord Record,
ReadLockT GraphReadLock 
)
protected

This function waits on all of the graph leaves which somehow use the memory object which is represented by Record.

The function is called upon destruction of memory buffer.

Parameters
Recordmemory record to await graph leaves of to finish
GraphReadLocklocked graph read lock

GraphReadLock will be unlocked/locked as needed. Upon return from the function, GraphReadLock will be left in locked state.

Definition at line 45 of file scheduler.cpp.

References sycl::_V1::detail::Scheduler::GraphProcessor::enqueueCommand(), sycl::_V1::detail::Command::getEvent(), sycl::_V1::detail::AllocaCommandBase::getReleaseCmd(), sycl::_V1::make_error_code(), sycl::_V1::detail::MemObjRecord::MAllocaCommands, sycl::_V1::detail::MemObjRecord::MReadLeaves, sycl::_V1::detail::EnqueueResultT::MResult, sycl::_V1::detail::MemObjRecord::MWriteLeaves, sycl::_V1::detail::Command::resolveReleaseDependencies(), sycl::_V1::runtime, sycl::_V1::detail::EnqueueResultT::SyclEnqueueFailed, and sycl::_V1::detail::Scheduler::GraphProcessor::waitForEvent().

Referenced by removeMemoryObject().

Friends And Related Function Documentation

◆ ::MockScheduler

friend class ::MockScheduler
friend

Definition at line 964 of file scheduler.hpp.

◆ Command

friend class Command
friend

Definition at line 960 of file scheduler.hpp.

◆ DispatchHostTask

friend class DispatchHostTask
friend

Definition at line 961 of file scheduler.hpp.

◆ event_impl

friend class event_impl
friend

Definition at line 963 of file scheduler.hpp.

◆ queue_impl

friend class queue_impl
friend

Definition at line 962 of file scheduler.hpp.

Member Data Documentation

◆ MAuxiliaryResources

std::unordered_map<EventImplPtr, std::vector<std::shared_ptr<const void> > > sycl::_V1::detail::Scheduler::MAuxiliaryResources
protected

◆ MAuxiliaryResourcesMutex

std::mutex sycl::_V1::detail::Scheduler::MAuxiliaryResourcesMutex
protected

◆ MDeferredCleanupCommands

std::vector<Command *> sycl::_V1::detail::Scheduler::MDeferredCleanupCommands
protected

Definition at line 950 of file scheduler.hpp.

Referenced by cleanupCommands().

◆ MDeferredCleanupMutex

std::mutex sycl::_V1::detail::Scheduler::MDeferredCleanupMutex
protected

Definition at line 951 of file scheduler.hpp.

Referenced by cleanupCommands().

◆ MDeferredMemObjRelease

std::vector<std::shared_ptr<SYCLMemObjI> > sycl::_V1::detail::Scheduler::MDeferredMemObjRelease
protected

◆ MDeferredMemReleaseMutex

std::mutex sycl::_V1::detail::Scheduler::MDeferredMemReleaseMutex
protected

◆ MFusionMapLock

RWLockT sycl::_V1::detail::Scheduler::MFusionMapLock
protected

Definition at line 948 of file scheduler.hpp.

Referenced by acquireFusionReadLock(), and acquireFusionWriteLock().

◆ MGraphBuilder

◆ MGraphLock

RWLockT sycl::_V1::detail::Scheduler::MGraphLock
protected

The documentation for this class was generated from the following files: