[NFC][SYCL] Prefer to pass context_impl by raw ptr/ref

sycl/include/sycl/handler.hpp

@@ -3545,7 +3545,9 @@ class __SYCL_EXPORT handler {
         UserRange, KernelFunc};
   }
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   const std::shared_ptr<detail::context_impl> &getContextImplPtr() const;
+#endif
   detail::context_impl &getContextImpl() const;
 
   // Checks if 2D memory operations are supported by the underlying platform.

sycl/include/sycl/interop_handle.hpp

@@ -205,6 +205,12 @@ class interop_handle {
   friend class detail::DispatchHostTask;
   using ReqToMem = std::pair<detail::AccessorImplHost *, ur_mem_handle_t>;
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  // Clean this up (no shared pointers). Not doing it right now because I expect
+  // there will be several iterations of simplifications possible and it would
+  // be hard to track which of them made their way into a minor public release
+  // and which didn't. Let's just clean it up once during ABI breaking window.
+#endif
   interop_handle(std::vector<ReqToMem> MemObjs,
                  const std::shared_ptr<detail::queue_impl> &Queue,
                  const std::shared_ptr<detail::device_impl> &Device,

sycl/source/backend.cpp

@@ -126,7 +126,7 @@ __SYCL_EXPORT queue make_queue(ur_native_handle_t NativeHandle,
   ur_device_handle_t UrDevice =
       Device ? getSyclObjImpl(*Device)->getHandleRef() : nullptr;
   const auto &Adapter = getAdapter(Backend);
-  const auto &ContextImpl = getSyclObjImpl(Context);
+  context_impl &ContextImpl = *getSyclObjImpl(Context);
 
   if (PropList.has_property<ext::intel::property::queue::compute_index>()) {
     throw sycl::exception(
@@ -156,7 +156,7 @@ __SYCL_EXPORT queue make_queue(ur_native_handle_t NativeHandle,
   ur_queue_handle_t UrQueue = nullptr;
 
   Adapter->call<UrApiKind::urQueueCreateWithNativeHandle>(
-      NativeHandle, ContextImpl->getHandleRef(), UrDevice, &NativeProperties,
+      NativeHandle, ContextImpl.getHandleRef(), UrDevice, &NativeProperties,
       &UrQueue);
   // Construct the SYCL queue from UR queue.
   return detail::createSyclObjFromImpl<queue>(

sycl/source/detail/async_alloc.cpp

@@ -67,7 +67,7 @@ void *async_malloc(sycl::handler &h, sycl::usm::alloc kind, size_t size) {
         sycl::make_error_code(sycl::errc::feature_not_supported),
         "Only device backed asynchronous allocations are supported!");
 
-  auto &Adapter = h.getContextImplPtr()->getAdapter();
+  auto &Adapter = h.getContextImpl().getAdapter();
 
   // Get CG event dependencies for this allocation.
   const auto &DepEvents = h.impl->CGData.MEvents;
@@ -117,7 +117,7 @@ __SYCL_EXPORT void *async_malloc(const sycl::queue &q, sycl::usm::alloc kind,
 __SYCL_EXPORT void *async_malloc_from_pool(sycl::handler &h, size_t size,
                                            const memory_pool &pool) {
 
-  auto &Adapter = h.getContextImplPtr()->getAdapter();
+  auto &Adapter = h.getContextImpl().getAdapter();
   auto &memPoolImpl = sycl::detail::getSyclObjImpl(pool);
 
   // Get CG event dependencies for this allocation.

sycl/source/detail/backend_impl.hpp

@@ -15,7 +15,7 @@ inline namespace _V1 {
 namespace detail {
 
 template <class T> backend getImplBackend(const T &Impl) {
-  return Impl->getContextImplPtr()->getBackend();
+  return Impl->getContextImpl().getBackend();
 }
 
 } // namespace detail

sycl/source/detail/bindless_images.cpp

@@ -813,9 +813,9 @@ get_image_memory_support(const image_descriptor &imageDescriptor,
                          const sycl::context &syclContext) {
   std::shared_ptr<sycl::detail::device_impl> DevImpl =
       sycl::detail::getSyclObjImpl(syclDevice);
-  std::shared_ptr<sycl::detail::context_impl> CtxImpl =
-      sycl::detail::getSyclObjImpl(syclContext);
-  const sycl::detail::AdapterPtr &Adapter = CtxImpl->getAdapter();
+  sycl::detail::context_impl &CtxImpl =
+      *sycl::detail::getSyclObjImpl(syclContext);
+  const sycl::detail::AdapterPtr &Adapter = CtxImpl.getAdapter();
 
   ur_image_desc_t urDesc;
   ur_image_format_t urFormat;
@@ -825,15 +825,15 @@ get_image_memory_support(const image_descriptor &imageDescriptor,
   Adapter->call<sycl::errc::runtime,
                 sycl::detail::UrApiKind::
                     urBindlessImagesGetImageMemoryHandleTypeSupportExp>(
-      CtxImpl->getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
+      CtxImpl.getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
       ur_exp_image_mem_type_t::UR_EXP_IMAGE_MEM_TYPE_USM_POINTER,
       &supportsPointerAllocation);
 
   ur_bool_t supportsOpaqueAllocation{0};
   Adapter->call<sycl::errc::runtime,
                 sycl::detail::UrApiKind::
                     urBindlessImagesGetImageMemoryHandleTypeSupportExp>(
-      CtxImpl->getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
+      CtxImpl.getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
       ur_exp_image_mem_type_t::UR_EXP_IMAGE_MEM_TYPE_OPAQUE_HANDLE,
       &supportsOpaqueAllocation);
 
@@ -864,9 +864,9 @@ __SYCL_EXPORT bool is_image_handle_supported<unsampled_image_handle>(
     const sycl::device &syclDevice, const sycl::context &syclContext) {
   std::shared_ptr<sycl::detail::device_impl> DevImpl =
       sycl::detail::getSyclObjImpl(syclDevice);
-  std::shared_ptr<sycl::detail::context_impl> CtxImpl =
-      sycl::detail::getSyclObjImpl(syclContext);
-  const sycl::detail::AdapterPtr &Adapter = CtxImpl->getAdapter();
+  sycl::detail::context_impl &CtxImpl =
+      *sycl::detail::getSyclObjImpl(syclContext);
+  const sycl::detail::AdapterPtr &Adapter = CtxImpl.getAdapter();
 
   ur_image_desc_t urDesc;
   ur_image_format_t urFormat;
@@ -881,7 +881,7 @@ __SYCL_EXPORT bool is_image_handle_supported<unsampled_image_handle>(
   Adapter->call<sycl::errc::runtime,
                 sycl::detail::UrApiKind::
                     urBindlessImagesGetImageUnsampledHandleSupportExp>(
-      CtxImpl->getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
+      CtxImpl.getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
       memHandleType, &supportsUnsampledHandle);
 
   return supportsUnsampledHandle;
@@ -904,9 +904,9 @@ __SYCL_EXPORT bool is_image_handle_supported<sampled_image_handle>(
     const sycl::device &syclDevice, const sycl::context &syclContext) {
   std::shared_ptr<sycl::detail::device_impl> DevImpl =
       sycl::detail::getSyclObjImpl(syclDevice);
-  std::shared_ptr<sycl::detail::context_impl> CtxImpl =
-      sycl::detail::getSyclObjImpl(syclContext);
-  const sycl::detail::AdapterPtr &Adapter = CtxImpl->getAdapter();
+  sycl::detail::context_impl &CtxImpl =
+      *sycl::detail::getSyclObjImpl(syclContext);
+  const sycl::detail::AdapterPtr &Adapter = CtxImpl.getAdapter();
 
   ur_image_desc_t urDesc;
   ur_image_format_t urFormat;
@@ -921,7 +921,7 @@ __SYCL_EXPORT bool is_image_handle_supported<sampled_image_handle>(
   Adapter->call<
       sycl::errc::runtime,
       sycl::detail::UrApiKind::urBindlessImagesGetImageSampledHandleSupportExp>(
-      CtxImpl->getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
+      CtxImpl.getHandleRef(), DevImpl->getHandleRef(), &urDesc, &urFormat,
       memHandleType, &supportsSampledHandle);
 
   return supportsSampledHandle;

sycl/source/detail/cg.hpp

@@ -726,9 +726,9 @@ class CGHostTask : public CG {
   std::vector<ArgDesc> MArgs;
 
   CGHostTask(std::shared_ptr<HostTask> HostTask, detail::queue_impl *Queue,
-             std::shared_ptr<detail::context_impl> Context,
-             std::vector<ArgDesc> Args, CG::StorageInitHelper CGData,
-             CGType Type, detail::code_location loc = {});
+             detail::context_impl *Context, std::vector<ArgDesc> Args,
+             CG::StorageInitHelper CGData, CGType Type,
+             detail::code_location loc = {});
 };
 
 } // namespace detail

sycl/source/detail/device_image_impl.hpp

@@ -570,13 +570,13 @@ class device_image_impl {
 
   ur_native_handle_t getNative() const {
     assert(MProgram);
-    const auto &ContextImplPtr = detail::getSyclObjImpl(MContext);
-    const AdapterPtr &Adapter = ContextImplPtr->getAdapter();
+    context_impl &ContextImpl = *detail::getSyclObjImpl(MContext);
+    const AdapterPtr &Adapter = ContextImpl.getAdapter();
 
     ur_native_handle_t NativeProgram = 0;
     Adapter->call<UrApiKind::urProgramGetNativeHandle>(MProgram,
                                                        &NativeProgram);
-    if (ContextImplPtr->getBackend() == backend::opencl)
+    if (ContextImpl.getBackend() == backend::opencl)
       __SYCL_OCL_CALL(clRetainProgram, ur::cast<cl_program>(NativeProgram));
 
     return NativeProgram;

sycl/source/detail/event_impl.hpp

@@ -29,7 +29,6 @@ class context;
 namespace detail {
 class Adapter;
 class context_impl;
-using ContextImplPtr = std::shared_ptr<sycl::detail::context_impl>;
 class queue_impl;
 class event_impl;
 using EventImplPtr = std::shared_ptr<sycl::detail::event_impl>;
@@ -312,12 +311,6 @@ class event_impl {
 
   bool isDefaultConstructed() const noexcept { return MIsDefaultConstructed; }
 
-  ContextImplPtr getContextImplPtr() {
-    if (MIsDefaultConstructed)
-      initContextIfNeeded();
-    return MContext;
-  }
-
   // Sets a sync point which is used when this event represents an enqueue to a
   // Command Buffer.
   void setSyncPoint(ur_exp_command_buffer_sync_point_t SyncPoint) {
@@ -394,7 +387,7 @@ class event_impl {
   std::atomic<ur_event_handle_t> MEvent = nullptr;
   // Stores submission time of command associated with event
   uint64_t MSubmitTime = 0;
-  ContextImplPtr MContext;
+  std::shared_ptr<context_impl> MContext;
   std::unique_ptr<HostProfilingInfo> MHostProfilingInfo;
   void *MCommand = nullptr;
   std::weak_ptr<queue_impl> MQueue;

sycl/source/detail/global_handler.cpp

@@ -185,7 +185,7 @@ ProgramManager &GlobalHandler::getProgramManager() {
   return PM;
 }
 
-std::unordered_map<platform_impl *, ContextImplPtr> &
+std::unordered_map<platform_impl *, std::shared_ptr<context_impl>> &
 GlobalHandler::getPlatformToDefaultContextCache() {
   // The optimization with static reference is not done because
   // there are public methods of the GlobalHandler

sycl/source/detail/global_handler.hpp

@@ -29,7 +29,6 @@ class XPTIRegistry;
 class ThreadPool;
 struct KernelNameBasedCacheT;
 
-using ContextImplPtr = std::shared_ptr<context_impl>;
 using AdapterPtr = std::shared_ptr<Adapter>;
 
 /// Wrapper class for global data structures with non-trivial destructors.
@@ -65,7 +64,7 @@ class GlobalHandler {
 
   void clearPlatforms();
 
-  std::unordered_map<platform_impl *, ContextImplPtr> &
+  std::unordered_map<platform_impl *, std::shared_ptr<context_impl>> &
   getPlatformToDefaultContextCache();
 
   std::mutex &getPlatformToDefaultContextCacheMutex();
@@ -121,7 +120,8 @@ class GlobalHandler {
   InstWithLock<ProgramManager> MProgramManager;
   InstWithLock<Sync> MSync;
   InstWithLock<std::vector<std::shared_ptr<platform_impl>>> MPlatformCache;
-  InstWithLock<std::unordered_map<platform_impl *, ContextImplPtr>>
+  InstWithLock<
+      std::unordered_map<platform_impl *, std::shared_ptr<context_impl>>>
       MPlatformToDefaultContextCache;
   InstWithLock<std::mutex> MPlatformToDefaultContextCacheMutex;
   InstWithLock<std::mutex> MPlatformMapMutex;

sycl/source/detail/graph_impl.cpp

@@ -907,7 +907,7 @@ exec_graph_impl::enqueueNode(ur_exp_command_buffer_handle_t CommandBuffer,
 
   sycl::detail::EventImplPtr Event =
       sycl::detail::Scheduler::getInstance().addCG(
-          Node->getCGCopy(), MQueueImpl,
+          Node->getCGCopy(), *MQueueImpl,
           /*EventNeeded=*/true, CommandBuffer, Deps);
 
   if (MIsUpdatable) {
@@ -996,7 +996,7 @@ exec_graph_impl::exec_graph_impl(sycl::context Context,
     : MSchedule(), MGraphImpl(GraphImpl), MSyncPoints(),
       MQueueImpl(sycl::detail::queue_impl::create(
           *sycl::detail::getSyclObjImpl(GraphImpl->getDevice()),
-          sycl::detail::getSyclObjImpl(Context), sycl::async_handler{},
+          *sycl::detail::getSyclObjImpl(Context), sycl::async_handler{},
           sycl::property_list{})),
       MDevice(GraphImpl->getDevice()), MContext(Context), MRequirements(),
       MSchedulerDependencies(),
@@ -1084,12 +1084,12 @@ EventImplPtr exec_graph_impl::enqueueHostTaskPartition(
   // dependencies for the current execution.
   std::unique_ptr<sycl::detail::CG> CommandGroup =
       std::make_unique<sycl::detail::CGHostTask>(sycl::detail::CGHostTask(
-          NodeCommandGroup->MHostTask, &Queue, NodeCommandGroup->MContext,
+          NodeCommandGroup->MHostTask, &Queue, NodeCommandGroup->MContext.get(),
           NodeCommandGroup->MArgs, std::move(CGData),
           NodeCommandGroup->getType()));
 
   EventImplPtr SchedulerEvent = sycl::detail::Scheduler::getInstance().addCG(
-      std::move(CommandGroup), Queue.shared_from_this(), EventNeeded);
+      std::move(CommandGroup), Queue, EventNeeded);
 
   if (EventNeeded) {
     return SchedulerEvent;
@@ -1117,7 +1117,7 @@ EventImplPtr exec_graph_impl::enqueuePartitionWithScheduler(
           CommandBuffer, nullptr, std::move(CGData));
 
   EventImplPtr SchedulerEvent = sycl::detail::Scheduler::getInstance().addCG(
-      std::move(CommandGroup), Queue.shared_from_this(), EventNeeded);
+      std::move(CommandGroup), Queue, EventNeeded);
 
   if (EventNeeded) {
     SchedulerEvent->setEventFromSubmittedExecCommandBuffer(true);
@@ -1592,7 +1592,7 @@ void exec_graph_impl::update(
     // other scheduler commands
     auto UpdateEvent =
         sycl::detail::Scheduler::getInstance().addCommandGraphUpdate(
-            this, Nodes, MQueueImpl, std::move(UpdateRequirements),
+            this, Nodes, MQueueImpl.get(), std::move(UpdateRequirements),
             MSchedulerDependencies);
 
     MSchedulerDependencies.push_back(UpdateEvent);

sycl/source/detail/graph_impl.hpp

@@ -289,8 +289,8 @@ class node_impl : public std::enable_shared_from_this<node_impl> {
       return std::make_unique<sycl::detail::CGHostTask>(
           sycl::detail::CGHostTask(
               std::move(HostTaskSPtr), CommandGroupPtr->MQueue.get(),
-              CommandGroupPtr->MContext, std::move(NewArgs), std::move(Data),
-              CommandGroupPtr->getType(), Loc));
+              CommandGroupPtr->MContext.get(), std::move(NewArgs),
+              std::move(Data), CommandGroupPtr->getType(), Loc));
     }
     case sycl::detail::CGType::Barrier:
     case sycl::detail::CGType::BarrierWaitlist:
@@ -980,9 +980,14 @@ class graph_impl : public std::enable_shared_from_this<graph_impl> {
 
   /// Query for the context impl tied to this graph.
   /// @return shared_ptr ref for the context impl associated with graph.
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   const std::shared_ptr<sycl::detail::context_impl> &getContextImplPtr() const {
     return sycl::detail::getSyclObjImpl(MContext);
   }
+#endif
+  sycl::detail::context_impl &getContextImpl() const {
+    return *sycl::detail::getSyclObjImpl(MContext);
+  }
 
   /// Query for the device_impl tied to this graph.
   /// @return device_impl shared ptr reference associated with graph.

sycl/source/detail/handler_impl.hpp

@@ -199,9 +199,9 @@ class handler_impl {
   template <typename Self = handler_impl> context_impl &get_context() {
     Self *self = this;
     if (auto *Queue = self->get_queue_or_null())
-      return *Queue->getContextImplPtr();
+      return Queue->getContextImpl();
     else
-      return *self->get_graph().getContextImplPtr();
+      return self->get_graph().getContextImpl();
   }
 
   /// If we are submitting a graph using ext_oneapi_graph this will be the graph

sycl/source/detail/helpers.cpp

@@ -24,7 +24,6 @@
 
 namespace sycl {
 inline namespace _V1 {
-using ContextImplPtr = std::shared_ptr<sycl::detail::context_impl>;
 namespace detail {
 void waitEvents(std::vector<sycl::event> DepEvents) {
   for (auto SyclEvent : DepEvents) {
@@ -59,10 +58,10 @@ retrieveKernelBinary(queue_impl &Queue, KernelNameStrRefT KernelName,
     if (DeviceImage == DeviceImages.end()) {
       return {nullptr, nullptr};
     }
-    auto ContextImpl = Queue.getContextImplPtr();
+    context_impl &ContextImpl = Queue.getContextImpl();
     ur_program_handle_t Program =
         detail::ProgramManager::getInstance().createURProgram(
-            **DeviceImage, *ContextImpl, {createSyclObjFromImpl<device>(Dev)});
+            **DeviceImage, ContextImpl, {createSyclObjFromImpl<device>(Dev)});
     return {*DeviceImage, Program};
   }
 
@@ -79,11 +78,11 @@ retrieveKernelBinary(queue_impl &Queue, KernelNameStrRefT KernelName,
     DeviceImage = SyclKernelImpl->getDeviceImage()->get_bin_image_ref();
     Program = SyclKernelImpl->getDeviceImage()->get_ur_program_ref();
   } else {
-    auto ContextImpl = Queue.getContextImplPtr();
+    context_impl &ContextImpl = Queue.getContextImpl();
     DeviceImage = &detail::ProgramManager::getInstance().getDeviceImage(
-        KernelName, *ContextImpl, Dev);
+        KernelName, ContextImpl, Dev);
     Program = detail::ProgramManager::getInstance().createURProgram(
-        *DeviceImage, *ContextImpl, {createSyclObjFromImpl<device>(Dev)});
+        *DeviceImage, ContextImpl, {createSyclObjFromImpl<device>(Dev)});
   }
   return {DeviceImage, Program};
 }

sycl/source/detail/kernel_impl.hpp

@@ -232,7 +232,7 @@ class kernel_impl {
   bool isInterop() const { return MIsInterop; }
 
   ur_program_handle_t getProgramRef() const { return MProgram; }
-  ContextImplPtr getContextImplPtr() const { return MContext; }
+  context_impl &getContextImpl() const { return *MContext; }
 
   std::mutex &getNoncacheableEnqueueMutex() const {
     return MNoncacheableEnqueueMutex;

sycl/source/detail/program_manager/program_manager.cpp

@@ -49,8 +49,6 @@ namespace sycl {
 inline namespace _V1 {
 namespace detail {
 
-using ContextImplPtr = std::shared_ptr<sycl::detail::context_impl>;
-
 static constexpr int DbgProgMgr = 0;
 
 static constexpr char UseSpvEnv[]("SYCL_USE_KERNEL_SPV");

sycl/source/detail/program_manager/program_manager.hpp

@@ -72,7 +72,6 @@ bool doesImageTargetMatchDevice(const RTDeviceBinaryImage &Img,
 static constexpr uint32_t inline ITTSpecConstId = 0xFF747469;
 
 class context_impl;
-using ContextImplPtr = std::shared_ptr<context_impl>;
 class device_impl;
 class queue_impl;
 class event_impl;