DPC++ Runtime
Runtime libraries for oneAPI DPC++
program_manager.hpp
Go to the documentation of this file.
1 //==------ program_manager.hpp --- SYCL program manager---------------------==//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #pragma once
15 #include <sycl/detail/common.hpp>
17 #include <sycl/detail/export.hpp>
19 #include <sycl/detail/os_util.hpp>
20 #include <sycl/detail/pi.hpp>
21 #include <sycl/detail/util.hpp>
22 #include <sycl/device.hpp>
23 #include <sycl/kernel_bundle.hpp>
24 #include <sycl/stl.hpp>
25 
26 #include <cstdint>
27 #include <map>
28 #include <memory>
29 #include <set>
30 #include <unordered_map>
31 #include <unordered_set>
32 #include <vector>
33 
34 // +++ Entry points referenced by the offload wrapper object {
35 
38 extern "C" __SYCL_EXPORT void __sycl_register_lib(pi_device_binaries desc);
39 
43 extern "C" __SYCL_EXPORT void __sycl_unregister_lib(pi_device_binaries desc);
44 
45 // +++ }
46 
47 namespace sycl {
48 inline namespace _V1 {
49 class context;
50 namespace detail {
51 
52 bool doesDevSupportDeviceRequirements(const device &Dev,
53  const RTDeviceBinaryImage &BinImages);
54 std::optional<sycl::exception>
55 checkDevSupportDeviceRequirements(const device &Dev,
56  const RTDeviceBinaryImage &BinImages);
57 
58 // This value must be the same as in libdevice/device_itt.h.
59 // See sycl/doc/design/ITTAnnotations.md for more info.
60 static constexpr uint32_t inline ITTSpecConstId = 0xFF747469;
61 
62 class context_impl;
63 using ContextImplPtr = std::shared_ptr<context_impl>;
64 class device_impl;
65 using DeviceImplPtr = std::shared_ptr<device_impl>;
66 class program_impl;
67 class queue_impl;
68 class event_impl;
69 // DeviceLibExt is shared between sycl runtime and sycl-post-link tool.
70 // If any update is made here, need to sync with DeviceLibExt definition
71 // in llvm/tools/sycl-post-link/sycl-post-link.cpp
72 enum class DeviceLibExt : std::uint32_t {
83 };
84 
85 // Provides single loading and building OpenCL programs with unique contexts
86 // that is necessary for no interoperability cases with lambda.
88 public:
89  // Returns the single instance of the program manager for the entire
90  // process. Can only be called after staticInit is done.
91  static ProgramManager &getInstance();
92 
93  RTDeviceBinaryImage &getDeviceImage(const std::string &KernelName,
94  const context &Context,
95  const device &Device,
96  bool JITCompilationIsRequired = false);
97 
99  const std::unordered_set<RTDeviceBinaryImage *> &ImagesToVerify,
100  const context &Context, const device &Device,
101  bool JITCompilationIsRequired = false);
102 
104  const context &Context,
105  const device &Device);
124  std::pair<sycl::detail::pi::PiProgram, bool>
125  getOrCreatePIProgram(const RTDeviceBinaryImage &Img, const context &Context,
126  const device &Device,
127  const std::string &CompileAndLinkOptions,
128  SerializedObj SpecConsts);
143  const ContextImplPtr &ContextImpl, const DeviceImplPtr &DeviceImpl,
144  const std::string &KernelName, const program_impl *Prg = nullptr,
145  bool JITCompilationIsRequired = false);
146 
148  getBuiltPIProgram(const context &Context, const device &Device,
149  const std::string &KernelName,
150  const property_list &PropList,
151  bool JITCompilationIsRequired = false);
152 
153  std::tuple<sycl::detail::pi::PiKernel, std::mutex *, const KernelArgMask *,
155  getOrCreateKernel(const ContextImplPtr &ContextImpl,
156  const DeviceImplPtr &DeviceImpl,
157  const std::string &KernelName, const program_impl *Prg);
158 
161  const ContextImplPtr Context);
162 
163  void addImages(pi_device_binaries DeviceImages);
164  void debugPrintBinaryImages() const;
165  static std::string
167  const ContextImplPtr Context);
168 
180  void flushSpecConstants(const program_impl &Prg,
181  pi::PiProgram NativePrg = nullptr,
182  const RTDeviceBinaryImage *Img = nullptr);
183  uint32_t getDeviceLibReqMask(const RTDeviceBinaryImage &Img);
184 
189  const KernelArgMask *
191  const std::string &KernelName);
192 
193  // The function returns the unique SYCL kernel identifier associated with a
194  // kernel name.
195  kernel_id getSYCLKernelID(const std::string &KernelName);
196 
197  // The function returns a vector containing all unique SYCL kernel identifiers
198  // in SYCL device images.
199  std::vector<kernel_id> getAllSYCLKernelIDs();
200 
201  // The function returns the unique SYCL kernel identifier associated with a
202  // built-in kernel name.
203  kernel_id getBuiltInKernelID(const std::string &KernelName);
204 
205  // The function inserts or initializes a device_global entry into the
206  // device_global map.
207  void addOrInitDeviceGlobalEntry(const void *DeviceGlobalPtr,
208  const char *UniqueId);
209 
210  // Returns true if any available image is compatible with the device Dev.
211  bool hasCompatibleImage(const device &Dev);
212 
213  // The function gets a device_global entry identified by the pointer to the
214  // device_global object from the device_global map.
215  DeviceGlobalMapEntry *getDeviceGlobalEntry(const void *DeviceGlobalPtr);
216 
217  // The function gets multiple device_global entries identified by their unique
218  // IDs from the device_global map.
219  std::vector<DeviceGlobalMapEntry *>
220  getDeviceGlobalEntries(const std::vector<std::string> &UniqueIds,
221  bool ExcludeDeviceImageScopeDecorated = false);
222  // The function inserts or initializes a host_pipe entry into the
223  // host_pipe map.
224  void addOrInitHostPipeEntry(const void *HostPipePtr, const char *UniqueId);
225 
226  // The function gets a host_pipe entry identified by the unique ID from
227  // the host_pipe map.
228  HostPipeMapEntry *getHostPipeEntry(const std::string &UniqueId);
229 
230  // The function gets a host_pipe entry identified by the pointer to the
231  // host_pipe object from the host_pipe map.
232  HostPipeMapEntry *getHostPipeEntry(const void *HostPipePtr);
233 
236  const context &Ctx, const device &Dev);
237 
238  // The function returns a vector of SYCL device images that are compiled with
239  // the required state and at least one device from the passed list of devices.
240  std::vector<device_image_plain> getSYCLDeviceImagesWithCompatibleState(
241  const context &Ctx, const std::vector<device> &Devs,
242  bundle_state TargetState, const std::vector<kernel_id> &KernelIDs = {});
243 
244  // Brind images in the passed vector to the required state. Does it inplace
245  void
246  bringSYCLDeviceImagesToState(std::vector<device_image_plain> &DeviceImages,
247  bundle_state TargetState);
248 
249  // The function returns a vector of SYCL device images in required state,
250  // which are compatible with at least one of the device from Devs.
251  std::vector<device_image_plain>
252  getSYCLDeviceImages(const context &Ctx, const std::vector<device> &Devs,
253  bundle_state State);
254 
255  // The function returns a vector of SYCL device images, for which Selector
256  // callable returns true, in required state, which are compatible with at
257  // least one of the device from Devs.
258  std::vector<device_image_plain>
259  getSYCLDeviceImages(const context &Ctx, const std::vector<device> &Devs,
260  const DevImgSelectorImpl &Selector,
261  bundle_state TargetState);
262 
263  // The function returns a vector of SYCL device images which represent at
264  // least one kernel from kernel ids vector in required state, which are
265  // compatible with at least one of the device from Devs.
266  std::vector<device_image_plain>
267  getSYCLDeviceImages(const context &Ctx, const std::vector<device> &Devs,
268  const std::vector<kernel_id> &KernelIDs,
269  bundle_state TargetState);
270 
271  // Produces new device image by convering input device image to the object
272  // state
273  device_image_plain compile(const device_image_plain &DeviceImage,
274  const std::vector<device> &Devs,
275  const property_list &PropList);
276 
277  // Produces set of device images by convering input device images to object
278  // the executable state
279  std::vector<device_image_plain> link(const device_image_plain &DeviceImages,
280  const std::vector<device> &Devs,
281  const property_list &PropList);
282 
283  // Produces new device image by converting input device image to the
284  // executable state
285  device_image_plain build(const device_image_plain &DeviceImage,
286  const std::vector<device> &Devs,
287  const property_list &PropList);
288 
289  std::tuple<sycl::detail::pi::PiKernel, std::mutex *, const KernelArgMask *>
290  getOrCreateKernel(const context &Context, const std::string &KernelName,
291  const property_list &PropList,
293 
294  ProgramManager();
295  ~ProgramManager() = default;
296 
297  bool kernelUsesAssert(const std::string &KernelName) const;
298 
299  std::set<RTDeviceBinaryImage *>
300  getRawDeviceImages(const std::vector<kernel_id> &KernelIDs);
301 
302 private:
303  ProgramManager(ProgramManager const &) = delete;
304  ProgramManager &operator=(ProgramManager const &) = delete;
305 
306  using ProgramPtr =
307  std::unique_ptr<remove_pointer_t<sycl::detail::pi::PiProgram>,
308  decltype(&::piProgramRelease)>;
309  ProgramPtr build(ProgramPtr Program, const ContextImplPtr Context,
310  const std::string &CompileOptions,
311  const std::string &LinkOptions,
312  const sycl::detail::pi::PiDevice &Device,
313  uint32_t DeviceLibReqMask);
315  void dumpImage(const RTDeviceBinaryImage &Img, uint32_t SequenceID = 0) const;
316 
318  void cacheKernelUsesAssertInfo(RTDeviceBinaryImage &Img);
319 
322  using RTDeviceBinaryImageUPtr = std::unique_ptr<RTDeviceBinaryImage>;
323 
328  //
329  std::unordered_map<std::string, kernel_id> m_KernelName2KernelIDs;
330 
331  // Maps KernelIDs to device binary images. There can be more than one image
332  // in case of SPIRV + AOT.
333  // Using shared_ptr to avoid expensive copy of the vector.
335  std::unordered_multimap<kernel_id, RTDeviceBinaryImage *>
336  m_KernelIDs2BinImage;
337 
338  // Maps device binary image to a vector of kernel ids in this image.
339  // Using shared_ptr to avoid expensive copy of the vector.
340  // The vector is initialized in addImages function and is supposed to be
341  // immutable afterwards.
343  std::unordered_map<RTDeviceBinaryImage *,
344  std::shared_ptr<std::vector<kernel_id>>>
345  m_BinImg2KernelIDs;
346 
351  std::mutex m_KernelIDsMutex;
352 
359  std::unordered_multimap<std::string, RTDeviceBinaryImage *> m_ServiceKernels;
360 
362  // from kernel bundles.
364  std::unordered_set<std::string> m_ExportedSymbols;
365 
368  std::unordered_set<RTDeviceBinaryImageUPtr> m_DeviceImages;
369 
372  std::unordered_map<std::string, kernel_id> m_BuiltInKernelIDs;
373 
375  std::mutex m_BuiltInKernelIDsMutex;
376 
377  // Keeps track of pi_program to image correspondence. Needed for:
378  // - knowing which specialization constants are used in the program and
379  // injecting their current values before compiling the SPIR-V; the binary
380  // image object has info about all spec constants used in the module
381  // - finding kernel argument masks for kernels associated with each
382  // pi_program
383  // NOTE: using RTDeviceBinaryImage raw pointers is OK, since they are not
384  // referenced from outside SYCL runtime and RTDeviceBinaryImage object
385  // lifetime matches program manager's one.
386  // NOTE: keys in the map can be invalid (reference count went to zero and
387  // the underlying program disposed of), so the map can't be used in any way
388  // other than binary image lookup with known live PiProgram as the key.
389  // NOTE: access is synchronized via the MNativeProgramsMutex
390  std::unordered_map<pi::PiProgram, const RTDeviceBinaryImage *> NativePrograms;
391 
393  std::mutex MNativeProgramsMutex;
394 
395  using KernelNameToArgMaskMap = std::unordered_map<std::string, KernelArgMask>;
398  std::unordered_map<const RTDeviceBinaryImage *, KernelNameToArgMaskMap>
399  m_EliminatedKernelArgMasks;
400 
402  bool m_UseSpvFile = false;
403  RTDeviceBinaryImageUPtr m_SpvFileImage;
404 
405  std::set<std::string> m_KernelUsesAssert;
406 
407  // Maps between device_global identifiers and associated information.
408  std::unordered_map<std::string, std::unique_ptr<DeviceGlobalMapEntry>>
409  m_DeviceGlobals;
410  std::unordered_map<const void *, DeviceGlobalMapEntry *> m_Ptr2DeviceGlobal;
411 
413  std::mutex m_DeviceGlobalsMutex;
414 
415  // Maps between host_pipe identifiers and associated information.
416  std::unordered_map<std::string, std::unique_ptr<HostPipeMapEntry>>
417  m_HostPipes;
418  std::unordered_map<const void *, HostPipeMapEntry *> m_Ptr2HostPipe;
419 
421  std::mutex m_HostPipesMutex;
422 };
423 } // namespace detail
424 } // namespace _V1
425 } // namespace sycl
sycl::_V1::detail::ProgramManager::flushSpecConstants
void flushSpecConstants(const program_impl &Prg, pi::PiProgram NativePrg=nullptr, const RTDeviceBinaryImage *Img=nullptr)
Resolves given program to a device binary image and requests the program to flush constants the image...
Definition: program_manager.cpp:1470
sycl::_V1::detail::ProgramManager::getHostPipeEntry
HostPipeMapEntry * getHostPipeEntry(const std::string &UniqueId)
Definition: program_manager.cpp:1714
sycl::_V1::property_list
Objects of the property_list class are containers for the SYCL properties.
Definition: property_list.hpp:31
sycl::_V1::detail::ProgramManager::compile
device_image_plain compile(const device_image_plain &DeviceImage, const std::vector< device > &Devs, const property_list &PropList)
Definition: program_manager.cpp:2024
sycl::_V1::detail::ProgramManager::ProgramManager
ProgramManager()
Definition: program_manager.cpp:940
sycl::_V1::detail::ContextImplPtr
std::shared_ptr< sycl::detail::context_impl > ContextImplPtr
Definition: event_impl.hpp:33
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_complex
@ cl_intel_devicelib_complex
sycl::_V1::detail::doesDevSupportDeviceRequirements
bool doesDevSupportDeviceRequirements(const device &Dev, const RTDeviceBinaryImage &Img)
Definition: program_manager.cpp:2375
sycl::_V1::detail::ProgramManager::build
device_image_plain build(const device_image_plain &DeviceImage, const std::vector< device > &Devs, const property_list &PropList)
Definition: program_manager.cpp:2190
stl.hpp
sycl::_V1::detail::ProgramManager::getBuiltInKernelID
kernel_id getBuiltInKernelID(const std::string &KernelName)
Definition: program_manager.cpp:1627
sycl::_V1::detail::ProgramManager::getOrCreateKernel
std::tuple< sycl::detail::pi::PiKernel, std::mutex *, const KernelArgMask *, sycl::detail::pi::PiProgram > getOrCreateKernel(const ContextImplPtr &ContextImpl, const DeviceImplPtr &DeviceImpl, const std::string &KernelName, const program_impl *Prg)
Definition: program_manager.cpp:689
__sycl_unregister_lib
void __sycl_unregister_lib(pi_device_binaries desc)
Executed as a part of current module's (.exe, .dll) static de-initialization.
Definition: program_manager.cpp:2561
sycl::_V1::detail::ProgramManager::getBuiltPIProgram
sycl::detail::pi::PiProgram getBuiltPIProgram(const ContextImplPtr &ContextImpl, const DeviceImplPtr &DeviceImpl, const std::string &KernelName, const program_impl *Prg=nullptr, bool JITCompilationIsRequired=false)
Builds or retrieves from cache a program defining the kernel with given name.
Definition: program_manager.cpp:573
sycl::_V1::detail::ProgramManager::getEliminatedKernelArgMask
const KernelArgMask * getEliminatedKernelArgMask(pi::PiProgram NativePrg, const std::string &KernelName)
Returns the mask for eliminated kernel arguments for the requested kernel within the native program.
Definition: program_manager.cpp:1522
sycl::_V1::detail::ProgramManager::getSYCLDeviceImages
std::vector< device_image_plain > getSYCLDeviceImages(const context &Ctx, const std::vector< device > &Devs, bundle_state State)
Definition: program_manager.cpp:1940
sycl::_V1::detail::checkDevSupportDeviceRequirements
std::optional< sycl::exception > checkDevSupportDeviceRequirements(const device &Dev, const RTDeviceBinaryImage &Img)
Definition: program_manager.cpp:2413
sycl::_V1::detail::DeviceImplPtr
std::shared_ptr< device_impl > DeviceImplPtr
Definition: program_manager.hpp:65
common.hpp
kernel_arg_mask.hpp
device_global_map.hpp
os_util.hpp
sycl::_V1::detail::DeviceGlobalMapEntry
Definition: device_global_map_entry.hpp:52
detail
---— Error handling, matching OpenCL plugin semantics.
Definition: common.hpp:44
pi_device_binaries_struct
This struct is a record of all the device code that may be offloaded.
Definition: pi.h:1056
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_imf
@ cl_intel_devicelib_imf
sycl
Definition: access.hpp:18
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_imf_bf16
@ cl_intel_devicelib_imf_bf16
pi.hpp
sycl::_V1::detail::ProgramManager::addImages
void addImages(pi_device_binaries DeviceImages)
Definition: program_manager.cpp:1281
device_global_map_entry.hpp
_pi_kernel
Definition: pi_cuda.hpp:72
sycl::_V1::detail::ProgramManager::link
std::vector< device_image_plain > link(const device_image_plain &DeviceImages, const std::vector< device > &Devs, const property_list &PropList)
Definition: program_manager.cpp:2088
sycl::_V1::detail::ProgramManager::getDeviceImage
RTDeviceBinaryImage & getDeviceImage(const std::string &KernelName, const context &Context, const device &Device, bool JITCompilationIsRequired=false)
Definition: program_manager.cpp:1021
sycl::_V1::detail::ProgramManager::getInstance
static ProgramManager & getInstance()
Definition: program_manager.cpp:67
export.hpp
sycl::_V1::detail::ProgramManager::getSYCLKernelID
kernel_id getSYCLKernelID(const std::string &KernelName)
Definition: program_manager.cpp:1595
piProgramRelease
pi_result piProgramRelease(pi_program program)
Definition: pi_cuda.cpp:318
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_math
@ cl_intel_devicelib_math
sycl::_V1::detail::event_impl
Definition: event_impl.hpp:39
kernel_bundle.hpp
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_bfloat16
@ cl_intel_devicelib_bfloat16
sycl::_V1::detail::ProgramManager::getDeviceGlobalEntries
std::vector< DeviceGlobalMapEntry * > getDeviceGlobalEntries(const std::vector< std::string > &UniqueIds, bool ExcludeDeviceImageScopeDecorated=false)
Definition: program_manager.cpp:1679
host_pipe_map_entry.hpp
sycl::_V1::detail::ProgramManager::getOrCreatePIProgram
std::pair< sycl::detail::pi::PiProgram, bool > getOrCreatePIProgram(const RTDeviceBinaryImage &Img, const context &Context, const device &Device, const std::string &CompileAndLinkOptions, SerializedObj SpecConsts)
Creates a PI program using either a cached device code binary if present in the persistent cache or f...
Definition: program_manager.cpp:537
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_assert
@ cl_intel_devicelib_assert
sycl::_V1::detail::KernelArgMask
std::vector< bool > KernelArgMask
Definition: kernel_arg_mask.hpp:16
sycl::_V1::detail::ProgramManager::getDeviceLibReqMask
uint32_t getDeviceLibReqMask(const RTDeviceBinaryImage &Img)
Definition: program_manager.cpp:1512
__sycl_register_lib
void __sycl_register_lib(pi_device_binaries desc)
Executed as a part of current module's (.exe, .dll) static initialization.
Definition: program_manager.cpp:2556
sycl::_V1::kernel_id
Objects of the class identify kernel is some kernel_bundle related APIs.
Definition: kernel_bundle.hpp:51
sycl::_V1::detail::ProgramManager::getDeviceImageFromBinaryImage
device_image_plain getDeviceImageFromBinaryImage(RTDeviceBinaryImage *BinImage, const context &Ctx, const device &Dev)
Definition: program_manager.cpp:1728
sycl::_V1::detail::ProgramManager::hasCompatibleImage
bool hasCompatibleImage(const device &Dev)
Definition: program_manager.cpp:1606
sycl::_V1::device
The SYCL device class encapsulates a single SYCL device on which kernels may be executed.
Definition: device.hpp:59
device.hpp
host_pipe_map.hpp
sycl::_V1::detail::device_impl
Definition: device_impl.hpp:35
_pi_program
Definition: pi_cuda.hpp:68
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_imf_fp64
@ cl_intel_devicelib_imf_fp64
sycl::_V1::detail::ProgramManager::addOrInitHostPipeEntry
void addOrInitHostPipeEntry(const void *HostPipePtr, const char *UniqueId)
Definition: program_manager.cpp:1697
sycl::_V1::detail::ProgramManager::kernelUsesAssert
bool kernelUsesAssert(const std::string &KernelName) const
Definition: program_manager.cpp:1277
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_complex_fp64
@ cl_intel_devicelib_complex_fp64
sycl::_V1::detail::ProgramManager::getPiProgramFromPiKernel
sycl::detail::pi::PiProgram getPiProgramFromPiKernel(sycl::detail::pi::PiKernel Kernel, const ContextImplPtr Context)
Definition: program_manager.cpp:755
sycl::_V1::detail::pi::PiKernel
::pi_kernel PiKernel
Definition: pi.hpp:138
sycl::_V1::detail::queue_impl
Definition: queue_impl.hpp:70
sycl::_V1::detail::ProgramManager::getSYCLDeviceImagesWithCompatibleState
std::vector< device_image_plain > getSYCLDeviceImagesWithCompatibleState(const context &Ctx, const std::vector< device > &Devs, bundle_state TargetState, const std::vector< kernel_id > &KernelIDs={})
Definition: program_manager.cpp:1749
sycl::_V1::detail::ProgramManager::createPIProgram
sycl::detail::pi::PiProgram createPIProgram(const RTDeviceBinaryImage &Img, const context &Context, const device &Device)
Definition: program_manager.cpp:268
sycl::_V1::detail::device_image_plain
Definition: kernel_bundle.hpp:83
sycl::_V1::detail::DeviceLibExt
DeviceLibExt
Definition: program_manager.hpp:72
sycl::_V1::detail::ProgramManager::getProgramBuildLog
static std::string getProgramBuildLog(const sycl::detail::pi::PiProgram &Program, const ContextImplPtr Context)
Definition: program_manager.cpp:766
sycl::_V1::detail::HostPipeMapEntry
Definition: host_pipe_map_entry.hpp:19
sycl::_V1::detail::ProgramManager::getDeviceGlobalEntry
DeviceGlobalMapEntry * getDeviceGlobalEntry(const void *DeviceGlobalPtr)
Definition: program_manager.cpp:1672
device_binary_image.hpp
sycl::_V1::detail::ProgramManager::addOrInitDeviceGlobalEntry
void addOrInitDeviceGlobalEntry(const void *DeviceGlobalPtr, const char *UniqueId)
Definition: program_manager.cpp:1640
sycl::_V1::detail::program_impl
Definition: program_impl.hpp:38
sycl::_V1::detail::ProgramManager::~ProgramManager
~ProgramManager()=default
util.hpp
sycl::_V1::detail::ProgramManager::bringSYCLDeviceImagesToState
void bringSYCLDeviceImagesToState(std::vector< device_image_plain > &DeviceImages, bundle_state TargetState)
Definition: program_manager.cpp:1892
sycl::_V1::detail::SerializedObj
std::vector< unsigned char > SerializedObj
Definition: util.hpp:68
sycl::_V1::detail::ProgramManager
Definition: program_manager.hpp:87
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_math_fp64
@ cl_intel_devicelib_math_fp64
sycl::_V1::detail::ProgramManager::debugPrintBinaryImages
void debugPrintBinaryImages() const
Definition: program_manager.cpp:1436
sycl::_V1::bundle_state
bundle_state
Definition: kernel_bundle_enums.hpp:14
sycl::_V1::detail::ProgramManager::getAllSYCLKernelIDs
std::vector< kernel_id > getAllSYCLKernelIDs()
Definition: program_manager.cpp:1616
sycl::_V1::detail::ITTSpecConstId
static constexpr uint32_t ITTSpecConstId
Definition: program_manager.hpp:60
spec_constant_impl.hpp
sycl::_V1::detail::DeviceLibExt::cl_intel_devicelib_cstring
@ cl_intel_devicelib_cstring
sycl::_V1::detail::RTDeviceBinaryImage
Definition: device_binary_image.hpp:82
sycl::_V1::detail::ProgramManager::getRawDeviceImages
std::set< RTDeviceBinaryImage * > getRawDeviceImages(const std::vector< kernel_id > &KernelIDs)
Definition: program_manager.cpp:1660
sycl::_V1::detail::context_impl
Definition: context_impl.hpp:33
_pi_device
Definition: pi_cuda.hpp:48
sycl::_V1::context
The context class represents a SYCL context on which kernel functions may be executed.
Definition: context.hpp:51
sycl::_V1::detail::DevImgSelectorImpl
std::function< bool(const detail::DeviceImageImplPtr &DevImgImpl)> DevImgSelectorImpl
Definition: kernel_bundle.hpp:486