[SYCL][NFC] Make context_impl::getAdapter() and platform_impl::getAdapter() return by reference (#19314)

It's a part of larger refactoring effort to pass adapter via reference
instead of pointer everywhere in the codebase.

Follow-up of:
#19186
#19184
#19187
#19202
#19299
#19312
#19313

Author: uditagarwal97

sycl/source/detail/async_alloc.cpp

@@ -68,7 +68,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.getContextImpl().getAdapter();
+  detail::adapter_impl &Adapter = h.getContextImpl().getAdapter();
 
   // Get CG event dependencies for this allocation.
   const auto &DepEvents = h.impl->CGData.MEvents;
@@ -84,8 +84,8 @@ void *async_malloc(sycl::handler &h, sycl::usm::alloc kind, size_t size) {
     alloc = Graph->getMemPool().malloc(size, kind, DepNodes);
   } else {
     ur_queue_handle_t Q = h.impl->get_queue().getHandleRef();
-    Adapter->call<sycl::errc::runtime,
-                  sycl::detail::UrApiKind::urEnqueueUSMDeviceAllocExp>(
+    Adapter.call<sycl::errc::runtime,
+                 sycl::detail::UrApiKind::urEnqueueUSMDeviceAllocExp>(
         Q, (ur_usm_pool_handle_t)0, size, nullptr, UREvents.size(),
         UREvents.data(), &alloc, &Event);
   }
@@ -118,7 +118,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.getContextImpl().getAdapter();
+  detail::adapter_impl &Adapter = h.getContextImpl().getAdapter();
   detail::memory_pool_impl &memPoolImpl = *detail::getSyclObjImpl(pool);
 
   // Get CG event dependencies for this allocation.
@@ -138,8 +138,8 @@ __SYCL_EXPORT void *async_malloc_from_pool(sycl::handler &h, size_t size,
                                        detail::getSyclObjImpl(pool).get());
   } else {
     ur_queue_handle_t Q = h.impl->get_queue().getHandleRef();
-    Adapter->call<sycl::errc::runtime,
-                  sycl::detail::UrApiKind::urEnqueueUSMDeviceAllocExp>(
+    Adapter.call<sycl::errc::runtime,
+                 sycl::detail::UrApiKind::urEnqueueUSMDeviceAllocExp>(
         Q, memPoolImpl.get_handle(), size, nullptr, UREvents.size(),
         UREvents.data(), &alloc, &Event);
   }

sycl/source/detail/buffer_impl.cpp

@@ -83,14 +83,13 @@ buffer_impl::getNativeVector(backend BackendName) const {
     if (Platform.getBackend() != BackendName)
       continue;
 
-    auto Adapter = Platform.getAdapter();
-
+    adapter_impl &Adapter = Platform.getAdapter();
     ur_native_handle_t Handle = 0;
     // When doing buffer interop we don't know what device the memory should be
     // resident on, so pass nullptr for Device param. Buffer interop may not be
     // supported by all backends.
-    Adapter->call<UrApiKind::urMemGetNativeHandle>(NativeMem, /*Dev*/ nullptr,
-                                                   &Handle);
+    Adapter.call<UrApiKind::urMemGetNativeHandle>(NativeMem, /*Dev*/ nullptr,
+                                                  &Handle);
     Handles.push_back(Handle);
 
     if (Platform.getBackend() == backend::opencl) {

sycl/source/detail/context_impl.cpp

@@ -54,7 +54,7 @@ context_impl::context_impl(const std::vector<sycl::device> Devices,
     DeviceIds.push_back(getSyclObjImpl(D)->getHandleRef());
   }
 
-  getAdapter()->call<UrApiKind::urContextCreate>(
+  getAdapter().call<UrApiKind::urContextCreate>(
       DeviceIds.size(), DeviceIds.data(), nullptr, &MContext);
 
   MKernelProgramCache.setContextPtr(this);
@@ -102,25 +102,25 @@ context_impl::context_impl(ur_context_handle_t UrContext,
   // TODO: Move this backend-specific retain of the context to SYCL-2020 style
   //       make_context<backend::opencl> interop, when that is created.
   if (getBackend() == sycl::backend::opencl) {
-    getAdapter()->call<UrApiKind::urContextRetain>(MContext);
+    getAdapter().call<UrApiKind::urContextRetain>(MContext);
   }
   MKernelProgramCache.setContextPtr(this);
 }
 
 cl_context context_impl::get() const {
   // TODO catch an exception and put it to list of asynchronous exceptions
-  getAdapter()->call<UrApiKind::urContextRetain>(MContext);
+  getAdapter().call<UrApiKind::urContextRetain>(MContext);
   ur_native_handle_t nativeHandle = 0;
-  getAdapter()->call<UrApiKind::urContextGetNativeHandle>(MContext,
-                                                          &nativeHandle);
+  getAdapter().call<UrApiKind::urContextGetNativeHandle>(MContext,
+                                                         &nativeHandle);
   return ur::cast<cl_context>(nativeHandle);
 }
 
 context_impl::~context_impl() {
   try {
     // Free all events associated with the initialization of device globals.
     for (auto &DeviceGlobalInitializer : MDeviceGlobalInitializers)
-      DeviceGlobalInitializer.second.ClearEvents(getAdapter());
+      DeviceGlobalInitializer.second.ClearEvents(&getAdapter());
     // Free all device_global USM allocations associated with this context.
     for (const void *DeviceGlobal : MAssociatedDeviceGlobals) {
       DeviceGlobalMapEntry *DGEntry =
@@ -130,10 +130,10 @@ context_impl::~context_impl() {
     }
     for (auto LibProg : MCachedLibPrograms) {
       assert(LibProg.second && "Null program must not be kept in the cache");
-      getAdapter()->call<UrApiKind::urProgramRelease>(LibProg.second);
+      getAdapter().call<UrApiKind::urProgramRelease>(LibProg.second);
     }
     // TODO catch an exception and put it to list of asynchronous exceptions
-    getAdapter()->call_nocheck<UrApiKind::urContextRelease>(MContext);
+    getAdapter().call_nocheck<UrApiKind::urContextRelease>(MContext);
   } catch (std::exception &e) {
     __SYCL_REPORT_EXCEPTION_TO_STREAM("exception in ~context_impl", e);
   }
@@ -146,7 +146,7 @@ const async_handler &context_impl::get_async_handler() const {
 template <>
 uint32_t context_impl::get_info<info::context::reference_count>() const {
   return get_context_info<info::context::reference_count>(this->getHandleRef(),
-                                                          this->getAdapter());
+                                                          &this->getAdapter());
 }
 template <> platform context_impl::get_info<info::context::platform>() const {
   return createSyclObjFromImpl<platform>(*MPlatform);
@@ -292,9 +292,9 @@ context_impl::findMatchingDeviceImpl(ur_device_handle_t &DeviceUR) const {
 }
 
 ur_native_handle_t context_impl::getNative() const {
-  const auto &Adapter = getAdapter();
+  detail::adapter_impl &Adapter = getAdapter();
   ur_native_handle_t Handle;
-  Adapter->call<UrApiKind::urContextGetNativeHandle>(getHandleRef(), &Handle);
+  Adapter.call<UrApiKind::urContextGetNativeHandle>(getHandleRef(), &Handle);
   if (getBackend() == backend::opencl) {
     __SYCL_OCL_CALL(clRetainContext, ur::cast<cl_context>(Handle));
   }
@@ -345,7 +345,7 @@ std::vector<ur_event_handle_t> context_impl::initializeDeviceGlobals(
   if (!MDeviceGlobalNotInitializedCnt.load(std::memory_order_acquire))
     return {};
 
-  const AdapterPtr &Adapter = getAdapter();
+  detail::adapter_impl &Adapter = getAdapter();
   device_impl &DeviceImpl = QueueImpl.getDeviceImpl();
   std::lock_guard<std::mutex> NativeProgramLock(MDeviceGlobalInitializersMutex);
   auto ImgIt = MDeviceGlobalInitializers.find(
@@ -365,11 +365,11 @@ std::vector<ur_event_handle_t> context_impl::initializeDeviceGlobals(
           InitEventsRef.begin(), InitEventsRef.end(),
           [&Adapter](const ur_event_handle_t &Event) {
             return get_event_info<info::event::command_execution_status>(
-                       Event, *Adapter) == info::event_command_status::complete;
+                       Event, Adapter) == info::event_command_status::complete;
           });
       // Release the removed events.
       for (auto EventIt = NewEnd; EventIt != InitEventsRef.end(); ++EventIt)
-        Adapter->call<UrApiKind::urEventRelease>(*EventIt);
+        Adapter.call<UrApiKind::urEventRelease>(*EventIt);
       // Remove them from the collection.
       InitEventsRef.erase(NewEnd, InitEventsRef.end());
       // If there are no more events, we can mark it as fully initialized.
@@ -431,14 +431,14 @@ std::vector<ur_event_handle_t> context_impl::initializeDeviceGlobals(
       // are cleaned up separately from cleaning up the device global USM memory
       // this must retain the event.
       {
-        if (OwnedUrEvent ZIEvent = DeviceGlobalUSM.getInitEvent(*Adapter))
+        if (OwnedUrEvent ZIEvent = DeviceGlobalUSM.getInitEvent(Adapter))
           InitEventsRef.push_back(ZIEvent.TransferOwnership());
       }
       // Write the pointer to the device global and store the event in the
       // initialize events list.
       ur_event_handle_t InitEvent;
       void *const &USMPtr = DeviceGlobalUSM.getPtr();
-      Adapter->call<UrApiKind::urEnqueueDeviceGlobalVariableWrite>(
+      Adapter.call<UrApiKind::urEnqueueDeviceGlobalVariableWrite>(
           QueueImpl.getHandleRef(), NativePrg,
           DeviceGlobalEntry->MUniqueId.c_str(), false, sizeof(void *), 0,
           &USMPtr, 0, nullptr, &InitEvent);
@@ -577,7 +577,7 @@ context_impl::get_default_memory_pool(const context &Context,
 
   detail::device_impl &DevImpl = *detail::getSyclObjImpl(Device);
   ur_device_handle_t DeviceHandle = DevImpl.getHandleRef();
-  const sycl::detail::AdapterPtr &Adapter = this->getAdapter();
+  detail::adapter_impl &Adapter = this->getAdapter();
 
   // Check dev is already in our list of device pool pairs.
   if (auto it = std::find_if(MMemPoolImplPtrs.begin(), MMemPoolImplPtrs.end(),
@@ -590,8 +590,8 @@ context_impl::get_default_memory_pool(const context &Context,
 
   // The memory_pool_impl does not exist for this device yet.
   ur_usm_pool_handle_t PoolHandle;
-  Adapter->call<sycl::errc::runtime,
-                sycl::detail::UrApiKind::urUSMPoolGetDefaultDevicePoolExp>(
+  Adapter.call<sycl::errc::runtime,
+               sycl::detail::UrApiKind::urUSMPoolGetDefaultDevicePoolExp>(
       this->getHandleRef(), DeviceHandle, &PoolHandle);
 
   auto MemPoolImplPtr = std::make_shared<

sycl/source/detail/context_impl.hpp

@@ -94,7 +94,7 @@ class context_impl : public std::enable_shared_from_this<context_impl> {
   const async_handler &get_async_handler() const;
 
   /// \return the Adapter associated with the platform of this context.
-  const AdapterPtr &getAdapter() const { return MPlatform->getAdapter(); }
+  adapter_impl &getAdapter() const { return MPlatform->getAdapter(); }
 
   /// \return the PlatformImpl associated with this context.
   platform_impl &getPlatformImpl() const { return *MPlatform; }
@@ -367,7 +367,7 @@ void GetCapabilitiesIntersectionSet(const std::vector<sycl::device> &Devices,
 // convenient to be able to reference them without extra `detail::`.
 inline auto get_ur_handles(sycl::detail::context_impl &Ctx) {
   ur_context_handle_t urCtx = Ctx.getHandleRef();
-  return std::tuple{urCtx, Ctx.getAdapter()};
+  return std::tuple{urCtx, &Ctx.getAdapter()};
 }
 inline auto get_ur_handles(const sycl::context &syclContext) {
   return get_ur_handles(*sycl::detail::getSyclObjImpl(syclContext));
@@ -382,7 +382,7 @@ inline auto get_ur_handles(const sycl::device &syclDevice,
 inline auto get_ur_handles(const sycl::device &syclDevice) {
   auto &implDevice = *sycl::detail::getSyclObjImpl(syclDevice);
   ur_device_handle_t urDevice = implDevice.getHandleRef();
-  return std::tuple{urDevice, implDevice.getAdapter()};
+  return std::tuple{urDevice, &implDevice.getAdapter()};
 }
 
 } // namespace _V1

sycl/source/detail/device_global_map_entry.cpp

@@ -160,7 +160,7 @@ void DeviceGlobalMapEntry::removeAssociatedResources(
       DeviceGlobalUSMMem &USMMem = USMPtrIt->second;
       detail::usm::freeInternal(USMMem.MPtr, CtxImpl);
       if (USMMem.MInitEvent.has_value())
-        CtxImpl->getAdapter()->call<UrApiKind::urEventRelease>(
+        CtxImpl->getAdapter().call<UrApiKind::urEventRelease>(
             *USMMem.MInitEvent);
 #ifndef NDEBUG
       // For debugging we set the event and memory to some recognizable values
@@ -185,8 +185,7 @@ void DeviceGlobalMapEntry::cleanup() {
     DeviceGlobalUSMMem &USMMem = USMPtrIt.second;
     detail::usm::freeInternal(USMMem.MPtr, CtxImpl);
     if (USMMem.MInitEvent.has_value())
-      CtxImpl->getAdapter()->call<UrApiKind::urEventRelease>(
-          *USMMem.MInitEvent);
+      CtxImpl->getAdapter().call<UrApiKind::urEventRelease>(*USMMem.MInitEvent);
 #ifndef NDEBUG
     // For debugging we set the event and memory to some recognizable values
     // to allow us to check that this cleanup happens before erasure.

sycl/source/detail/device_image_impl.cpp

@@ -42,10 +42,10 @@ std::shared_ptr<kernel_impl> device_image_impl::tryGetExtensionKernel(
   }
 
   ur_program_handle_t UrProgram = get_ur_program_ref();
-  const AdapterPtr &Adapter = getSyclObjImpl(Context)->getAdapter();
+  detail::adapter_impl &Adapter = getSyclObjImpl(Context)->getAdapter();
   ur_kernel_handle_t UrKernel = nullptr;
-  Adapter->call<UrApiKind::urKernelCreate>(UrProgram, AdjustedName.c_str(),
-                                           &UrKernel);
+  Adapter.call<UrApiKind::urKernelCreate>(UrProgram, AdjustedName.c_str(),
+                                          &UrKernel);
   // Kernel created by urKernelCreate is implicitly retained.
 
   const KernelArgMask *ArgMask = nullptr;

sycl/source/detail/device_image_impl.hpp

@@ -570,7 +570,7 @@ class device_image_impl
   ur_mem_handle_t &get_spec_const_buffer_ref() noexcept {
     std::lock_guard<std::mutex> Lock{MSpecConstAccessMtx};
     if (nullptr == MSpecConstsBuffer && !MSpecConstsBlob.empty()) {
-      const AdapterPtr &Adapter = getSyclObjImpl(MContext)->getAdapter();
+      adapter_impl &Adapter = getSyclObjImpl(MContext)->getAdapter();
       //  Uses UR_MEM_FLAGS_HOST_PTR_COPY instead of UR_MEM_FLAGS_HOST_PTR_USE
       //  since post-enqueue cleanup might trigger destruction of
       //  device_image_impl and, as a result, destruction of MSpecConstsBlob
@@ -602,11 +602,10 @@ class device_image_impl
   ur_native_handle_t getNative() const {
     assert(MProgram);
     context_impl &ContextImpl = *detail::getSyclObjImpl(MContext);
-    const AdapterPtr &Adapter = ContextImpl.getAdapter();
+    adapter_impl &Adapter = ContextImpl.getAdapter();
 
     ur_native_handle_t NativeProgram = 0;
-    Adapter->call<UrApiKind::urProgramGetNativeHandle>(MProgram,
-                                                       &NativeProgram);
+    Adapter.call<UrApiKind::urProgramGetNativeHandle>(MProgram, &NativeProgram);
     if (ContextImpl.getBackend() == backend::opencl)
       __SYCL_OCL_CALL(clRetainProgram, ur::cast<cl_program>(NativeProgram));
 
@@ -616,12 +615,12 @@ class device_image_impl
   ~device_image_impl() {
     try {
       if (MProgram) {
-        const AdapterPtr &Adapter = getSyclObjImpl(MContext)->getAdapter();
-        Adapter->call<UrApiKind::urProgramRelease>(MProgram);
+        adapter_impl &Adapter = getSyclObjImpl(MContext)->getAdapter();
+        Adapter.call<UrApiKind::urProgramRelease>(MProgram);
       }
       if (MSpecConstsBuffer) {
         std::lock_guard<std::mutex> Lock{MSpecConstAccessMtx};
-        const AdapterPtr &Adapter = getSyclObjImpl(MContext)->getAdapter();
+        adapter_impl &Adapter = getSyclObjImpl(MContext)->getAdapter();
         memReleaseHelper(Adapter, MSpecConstsBuffer);
       }
     } catch (std::exception &e) {
@@ -751,23 +750,23 @@ class device_image_impl
           Devices, BuildOptions, *SourceStrPtr, UrProgram);
     }
 
-    const AdapterPtr &Adapter = ContextImpl.getAdapter();
+    adapter_impl &Adapter = ContextImpl.getAdapter();
 
     if (!FetchedFromCache)
       UrProgram = createProgramFromSource(Devices, BuildOptions, LogPtr);
 
     std::string XsFlags = extractXsFlags(BuildOptions, MRTCBinInfo->MLanguage);
-    auto Res = Adapter->call_nocheck<UrApiKind::urProgramBuildExp>(
+    auto Res = Adapter.call_nocheck<UrApiKind::urProgramBuildExp>(
         UrProgram, DeviceVec.size(), DeviceVec.data(), XsFlags.c_str());
     if (Res == UR_RESULT_ERROR_UNSUPPORTED_FEATURE) {
-      Res = Adapter->call_nocheck<UrApiKind::urProgramBuild>(
+      Res = Adapter.call_nocheck<UrApiKind::urProgramBuild>(
           ContextImpl.getHandleRef(), UrProgram, XsFlags.c_str());
     }
-    Adapter->checkUrResult<errc::build>(Res);
+    Adapter.checkUrResult<errc::build>(Res);
 
     // Get the number of kernels in the program.
     size_t NumKernels;
-    Adapter->call<UrApiKind::urProgramGetInfo>(
+    Adapter.call<UrApiKind::urProgramGetInfo>(
         UrProgram, UR_PROGRAM_INFO_NUM_KERNELS, sizeof(size_t), &NumKernels,
         nullptr);
 
@@ -882,7 +881,7 @@ class device_image_impl
       const std::vector<sycl::detail::string_view> &BuildOptions,
       const std::string &SourceStr, ur_program_handle_t &UrProgram) const {
     sycl::detail::context_impl &ContextImpl = *getSyclObjImpl(MContext);
-    const AdapterPtr &Adapter = ContextImpl.getAdapter();
+    adapter_impl &Adapter = ContextImpl.getAdapter();
 
     std::string UserArgs = syclex::detail::userArgsAsString(BuildOptions);
 
@@ -910,7 +909,7 @@ class device_image_impl
     Properties.count = 0;
     Properties.pMetadatas = nullptr;
 
-    Adapter->call<UrApiKind::urProgramCreateWithBinary>(
+    Adapter.call<UrApiKind::urProgramCreateWithBinary>(
         ContextImpl.getHandleRef(), DeviceHandles.size(), DeviceHandles.data(),
         Lengths.data(), Binaries.data(), &Properties, &UrProgram);
 
@@ -1205,7 +1204,7 @@ class device_image_impl
                           const std::vector<sycl::detail::string_view> &Options,
                           std::string *LogPtr) const {
     sycl::detail::context_impl &ContextImpl = *getSyclObjImpl(MContext);
-    const AdapterPtr &Adapter = ContextImpl.getAdapter();
+    adapter_impl &Adapter = ContextImpl.getAdapter();
     const auto spirv = [&]() -> std::vector<uint8_t> {
       switch (MRTCBinInfo->MLanguage) {
       case syclex::source_language::opencl: {
@@ -1216,7 +1215,7 @@ class device_image_impl
         std::transform(Devices.begin(), Devices.end(), IPVersionVec.begin(),
                        [&](const sycl::device &SyclDev) {
                          uint32_t ipVersion = 0;
-                         Adapter->call<UrApiKind::urDeviceGetInfo>(
+                         Adapter.call<UrApiKind::urDeviceGetInfo>(
                              getSyclObjImpl(SyclDev)->getHandleRef(),
                              UR_DEVICE_INFO_IP_VERSION, sizeof(uint32_t),
                              &ipVersion, nullptr);
@@ -1242,9 +1241,9 @@ class device_image_impl
     }();
 
     ur_program_handle_t UrProgram = nullptr;
-    Adapter->call<UrApiKind::urProgramCreateWithIL>(ContextImpl.getHandleRef(),
-                                                    spirv.data(), spirv.size(),
-                                                    nullptr, &UrProgram);
+    Adapter.call<UrApiKind::urProgramCreateWithIL>(ContextImpl.getHandleRef(),
+                                                   spirv.data(), spirv.size(),
+                                                   nullptr, &UrProgram);
     // program created by urProgramCreateWithIL is implicitly retained.
     if (UrProgram == nullptr)
       throw sycl::exception(
@@ -1255,16 +1254,16 @@ class device_image_impl
   }
 
   static std::vector<std::string>
-  getKernelNamesFromURProgram(const AdapterPtr &Adapter,
+  getKernelNamesFromURProgram(adapter_impl &Adapter,
                               ur_program_handle_t UrProgram) {
     // Get the kernel names.
     size_t KernelNamesSize;
-    Adapter->call<UrApiKind::urProgramGetInfo>(
+    Adapter.call<UrApiKind::urProgramGetInfo>(
         UrProgram, UR_PROGRAM_INFO_KERNEL_NAMES, 0, nullptr, &KernelNamesSize);
 
     // semi-colon delimited list of kernel names.
     std::string KernelNamesStr(KernelNamesSize, ' ');
-    Adapter->call<UrApiKind::urProgramGetInfo>(
+    Adapter.call<UrApiKind::urProgramGetInfo>(
         UrProgram, UR_PROGRAM_INFO_KERNEL_NAMES, KernelNamesStr.size(),
         &KernelNamesStr[0], nullptr);
     return detail::split_string(KernelNamesStr, ';');