[NFC][SYCL] Use raw context_impl & in program_manager

sycl/source/detail/graph_impl.cpp

@@ -1545,7 +1545,7 @@ void exec_graph_impl::populateURKernelUpdateStructs(
     EliminatedArgMask = SyclKernelImpl->getKernelArgMask();
   } else {
     BundleObjs = sycl::detail::ProgramManager::getInstance().getOrCreateKernel(
-        ContextImpl, DeviceImpl, ExecCG.MKernelName,
+        *ContextImpl, DeviceImpl, ExecCG.MKernelName,
         ExecCG.MKernelNameBasedCachePtr);
     UrKernel = BundleObjs->MKernelHandle;
     EliminatedArgMask = BundleObjs->MKernelArgMask;

sycl/source/detail/helpers.cpp

@@ -62,7 +62,7 @@ retrieveKernelBinary(queue_impl &Queue, KernelNameStrRefT KernelName,
     auto ContextImpl = Queue.getContextImplPtr();
     ur_program_handle_t Program =
         detail::ProgramManager::getInstance().createURProgram(
-            **DeviceImage, ContextImpl, {createSyclObjFromImpl<device>(Dev)});
+            **DeviceImage, *ContextImpl, {createSyclObjFromImpl<device>(Dev)});
     return {*DeviceImage, Program};
   }
 
@@ -82,9 +82,9 @@ retrieveKernelBinary(queue_impl &Queue, KernelNameStrRefT KernelName,
   } else {
     auto ContextImpl = Queue.getContextImplPtr();
     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.cpp

@@ -20,8 +20,8 @@ kernel_impl::kernel_impl(ur_kernel_handle_t Kernel, ContextImplPtr Context,
                          KernelBundleImplPtr KernelBundleImpl,
                          const KernelArgMask *ArgMask)
     : MKernel(Kernel), MContext(Context),
-      MProgram(ProgramManager::getInstance().getUrProgramFromUrKernel(Kernel,
-                                                                      Context)),
+      MProgram(ProgramManager::getInstance().getUrProgramFromUrKernel(
+          Kernel, *Context)),
       MCreatedFromSource(true), MKernelBundleImpl(std::move(KernelBundleImpl)),
       MIsInterop(true), MKernelArgMaskPtr{ArgMask} {
   ur_context_handle_t UrContext = nullptr;

sycl/source/detail/memory_manager.cpp

@@ -1146,7 +1146,7 @@ getOrBuildProgramForDeviceGlobal(queue_impl &Queue,
   auto Context = createSyclObjFromImpl<context>(ContextImpl);
   ProgramManager &PM = ProgramManager::getInstance();
   RTDeviceBinaryImage &Img = PM.getDeviceImage(
-      DeviceGlobalEntry->MImages, ContextImpl, getSyclObjImpl(Device).get());
+      DeviceGlobalEntry->MImages, *ContextImpl, getSyclObjImpl(Device).get());
   device_image_plain DeviceImage =
       PM.getDeviceImageFromBinaryImage(&Img, Context, Device);
   device_image_plain BuiltImage =

sycl/source/detail/program_manager/program_manager.hpp

@@ -135,15 +135,15 @@ class ProgramManager {
   static ProgramManager &getInstance();
 
   RTDeviceBinaryImage &getDeviceImage(KernelNameStrRefT KernelName,
-                                      const ContextImplPtr &ContextImpl,
+                                      context_impl &ContextImpl,
                                       const device_impl *DeviceImpl);
 
   RTDeviceBinaryImage &getDeviceImage(
       const std::unordered_set<RTDeviceBinaryImage *> &ImagesToVerify,
-      const ContextImplPtr &ContextImpl, const device_impl *DeviceImpl);
+      context_impl &ContextImpl, const device_impl *DeviceImpl);
 
   ur_program_handle_t createURProgram(const RTDeviceBinaryImage &Img,
-                                      const ContextImplPtr &ContextImpl,
+                                      context_impl &ContextImpl,
                                       const std::vector<device> &Devices);
   /// Creates a UR program using either a cached device code binary if present
   /// in the persistent cache or from the supplied device image otherwise.
@@ -167,7 +167,7 @@ class ProgramManager {
   std::pair<ur_program_handle_t, bool> getOrCreateURProgram(
       const RTDeviceBinaryImage &Img,
       const std::vector<const RTDeviceBinaryImage *> &AllImages,
-      const ContextImplPtr &ContextImpl, const std::vector<device> &Devices,
+      context_impl &ContextImpl, const std::vector<device> &Devices,
       const std::string &CompileAndLinkOptions, SerializedObj SpecConsts);
   /// Builds or retrieves from cache a program defining the kernel with given
   /// name.
@@ -176,7 +176,7 @@ class ProgramManager {
   /// \param Context the context to build the program with
   /// \param Device the device for which the program is built
   /// \param KernelName the kernel's name
-  ur_program_handle_t getBuiltURProgram(const ContextImplPtr &ContextImpl,
+  ur_program_handle_t getBuiltURProgram(context_impl &ContextImpl,
                                         device_impl &DeviceImpl,
                                         KernelNameStrRefT KernelName,
                                         const NDRDescT &NDRDesc = {});
@@ -193,13 +193,12 @@ class ProgramManager {
   /// the program should be built with.
   ur_program_handle_t
   getBuiltURProgram(const BinImgWithDeps &ImgWithDeps,
-                    const ContextImplPtr &ContextImpl,
-                    const std::vector<device> &Devs,
+                    context_impl &ContextImpl, const std::vector<device> &Devs,
                     const DevImgPlainWithDeps *DevImgWithDeps = nullptr,
                     const SerializedObj &SpecConsts = {});
 
   FastKernelCacheValPtr
-  getOrCreateKernel(const ContextImplPtr &ContextImpl, device_impl &DeviceImpl,
+  getOrCreateKernel(context_impl &ContextImpl, device_impl &DeviceImpl,
                     KernelNameStrRefT KernelName,
                     KernelNameBasedCacheT *KernelNameBasedCachePtr,
                     const NDRDescT &NDRDesc = {});
@@ -214,7 +213,7 @@ class ProgramManager {
       const std::vector<unsigned char> &SpecializationConsts);
 
   ur_program_handle_t getUrProgramFromUrKernel(ur_kernel_handle_t Kernel,
-                                               const ContextImplPtr &Context);
+                                               context_impl &Context);
 
   void addImage(sycl_device_binary RawImg, bool RegisterImgExports = true,
                 RTDeviceBinaryImage **OutImage = nullptr,
@@ -223,7 +222,7 @@ class ProgramManager {
   void removeImages(sycl_device_binaries DeviceImages);
   void debugPrintBinaryImages() const;
   static std::string getProgramBuildLog(const ur_program_handle_t &Program,
-                                        const ContextImplPtr &Context);
+                                        context_impl &Context);
 
   uint32_t getDeviceLibReqMask(const RTDeviceBinaryImage &Img);
 
@@ -394,7 +393,7 @@ class ProgramManager {
 
   using ProgramPtr = std::unique_ptr<std::remove_pointer_t<ur_program_handle_t>,
                                      decltype(&::urProgramRelease)>;
-  ProgramPtr build(ProgramPtr Program, const ContextImplPtr &Context,
+  ProgramPtr build(ProgramPtr Program, context_impl &Context,
                    const std::string &CompileOptions,
                    const std::string &LinkOptions,
                    std::vector<ur_device_handle_t> &Devices,

sycl/source/detail/scheduler/commands.cpp

@@ -2016,7 +2016,7 @@ void instrumentationAddExtraKernelMetadata(
     //       by graph API, when a modifiable graph is finalized.
     FastKernelCacheValPtr FastKernelCacheVal =
         detail::ProgramManager::getInstance().getOrCreateKernel(
-            Queue->getContextImplPtr(), Queue->getDeviceImpl(), KernelName,
+            *Queue->getContextImplPtr(), Queue->getDeviceImpl(), KernelName,
             KernelNameBasedCachePtr);
     EliminatedArgMask = FastKernelCacheVal->MKernelArgMask;
   }
@@ -2552,7 +2552,7 @@ getCGKernelInfo(const CGExecKernel &CommandGroup, ContextImplPtr ContextImpl,
   } else {
     FastKernelCacheValPtr FastKernelCacheVal =
         sycl::detail::ProgramManager::getInstance().getOrCreateKernel(
-            ContextImpl, DeviceImpl, CommandGroup.MKernelName,
+            *ContextImpl, DeviceImpl, CommandGroup.MKernelName,
             CommandGroup.MKernelNameBasedCachePtr);
     UrKernel = FastKernelCacheVal->MKernelHandle;
     EliminatedArgMask = FastKernelCacheVal->MKernelArgMask;
@@ -2715,7 +2715,7 @@ void enqueueImpKernel(
     KernelMutex = SyclKernelImpl->getCacheMutex();
   } else {
     KernelCacheVal = detail::ProgramManager::getInstance().getOrCreateKernel(
-        ContextImpl, DeviceImpl, KernelName, KernelNameBasedCachePtr, NDRDesc);
+        *ContextImpl, DeviceImpl, KernelName, KernelNameBasedCachePtr, NDRDesc);
     Kernel = KernelCacheVal->MKernelHandle;
     KernelMutex = KernelCacheVal->MMutex;
     Program = KernelCacheVal->MProgramHandle;

sycl/unittests/program_manager/Cleanup.cpp

@@ -383,13 +383,13 @@ TEST(ImageRemoval, NativePrograms) {
   const sycl::device Dev = Plt.get_devices()[0];
   sycl::queue Queue{Dev};
   auto Ctx = Queue.get_context();
-  auto ProgramA = PM.getBuiltURProgram(sycl::detail::getSyclObjImpl(Ctx),
+  auto ProgramA = PM.getBuiltURProgram(*sycl::detail::getSyclObjImpl(Ctx),
                                        *sycl::detail::getSyclObjImpl(Dev),
                                        generateRefName("A", "Kernel"));
-  auto ProgramB = PM.getBuiltURProgram(sycl::detail::getSyclObjImpl(Ctx),
+  auto ProgramB = PM.getBuiltURProgram(*sycl::detail::getSyclObjImpl(Ctx),
                                        *sycl::detail::getSyclObjImpl(Dev),
                                        generateRefName("B", "Kernel"));
-  std::ignore = PM.getBuiltURProgram(sycl::detail::getSyclObjImpl(Ctx),
+  std::ignore = PM.getBuiltURProgram(*sycl::detail::getSyclObjImpl(Ctx),
                                      *sycl::detail::getSyclObjImpl(Dev),
                                      generateRefName("C", "Kernel"));
 

sycl/unittests/program_manager/SubDevices.cpp

@@ -120,11 +120,11 @@ TEST(SubDevices, DISABLED_BuildProgramForSubdevices) {
 
   // Build program via getBuiltPIProgram API
   sycl::detail::ProgramManager::getInstance().getBuiltURProgram(
-      sycl::detail::getSyclObjImpl(Ctx), subDev1,
+      *sycl::detail::getSyclObjImpl(Ctx), subDev1,
       sycl::detail::KernelInfo<TestKernel<>>::getName());
   // This call should re-use built binary from the cache. If urProgramBuild is
   // called again, the test will fail as second call of redefinedProgramBuild
   sycl::detail::ProgramManager::getInstance().getBuiltURProgram(
-      sycl::detail::getSyclObjImpl(Ctx), subDev2,
+      *sycl::detail::getSyclObjImpl(Ctx), subDev2,
       sycl::detail::KernelInfo<TestKernel<>>::getName());
 }

sycl/unittests/program_manager/arg_mask/EliminatedArgMask.cpp

@@ -303,7 +303,7 @@ TEST(EliminatedArgMask, ReuseOfHandleValues) {
     const sycl::device Dev = Plt.get_devices()[0];
     sycl::queue Queue{Dev};
     auto Ctx = Queue.get_context();
-    ProgBefore = PM.getBuiltURProgram(sycl::detail::getSyclObjImpl(Ctx),
+    ProgBefore = PM.getBuiltURProgram(*sycl::detail::getSyclObjImpl(Ctx),
                                       *sycl::detail::getSyclObjImpl(Dev), Name);
     auto Mask = PM.getEliminatedKernelArgMask(ProgBefore, Name);
     EXPECT_NE(Mask, nullptr);
@@ -328,7 +328,7 @@ TEST(EliminatedArgMask, ReuseOfHandleValues) {
     const sycl::device Dev = Plt.get_devices()[0];
     sycl::queue Queue{Dev};
     auto Ctx = Queue.get_context();
-    ProgAfter = PM.getBuiltURProgram(sycl::detail::getSyclObjImpl(Ctx),
+    ProgAfter = PM.getBuiltURProgram(*sycl::detail::getSyclObjImpl(Ctx),
                                      *sycl::detail::getSyclObjImpl(Dev), Name);
     auto Mask = PM.getEliminatedKernelArgMask(ProgAfter, Name);
     EXPECT_NE(Mask, nullptr);