Add OSModule handle

Author: romanovvlad

sycl/include/CL/sycl/handler.hpp

@@ -314,11 +314,7 @@ class __SYCL_EXPORT handler {
   ///
   /// \param Queue is a SYCL queue.
   /// \param IsHost indicates if this handler is created for SYCL host device.
-  handler(shared_ptr_class<detail::queue_impl> Queue, bool IsHost)
-      : MQueue(std::move(Queue)), MIsHost(IsHost) {
-    MSharedPtrStorage.emplace_back(
-        std::make_shared<std::vector<detail::ExtendedMemberT>>());
-  }
+  handler(const shared_ptr_class<detail::queue_impl> &Queue, bool IsHost);
 
   /// Stores copy of Arg passed to the MArgsStorage.
   template <typename T, typename F = typename detail::remove_const_t<

sycl/include/CL/sycl/kernel_bundle.hpp

@@ -321,7 +321,7 @@ namespace detail {
 // public onces
 __SYCL_EXPORT detail::KernelBundleImplPtr
 get_kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
-                       bundle_state State);
+                       bundle_state State, OSModuleHandle M);
 } // namespace detail
 
 /// A kernel bundle in state State which contains all of the kernels in the
@@ -331,8 +331,10 @@ get_kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
 template <bundle_state State>
 kernel_bundle<State> get_kernel_bundle(const context &Ctx,
                                        const std::vector<device> &Devs) {
-  detail::KernelBundleImplPtr Impl =
-      detail::get_kernel_bundle_impl(Ctx, Devs, State);
+  static const int Anchor = 0;
+  detail::KernelBundleImplPtr Impl = detail::get_kernel_bundle_impl(
+      Ctx, Devs, State, detail::OSUtil::getOSModuleHandle(&Anchor));
+
   return detail::createSyclObjFromImpl<kernel_bundle<State>>(Impl);
 }
 
@@ -348,7 +350,7 @@ namespace detail {
 __SYCL_EXPORT detail::KernelBundleImplPtr
 get_kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
                        const std::vector<kernel_id> &KernelIDs,
-                       bundle_state State);
+                       bundle_state State, OSModuleHandle M);
 } // namespace detail
 
 /// \returns a kernel bundle in state State which contains all of the device
@@ -363,8 +365,9 @@ template <bundle_state State>
 kernel_bundle<State>
 get_kernel_bundle(const context &Ctx, const std::vector<device> &Devs,
                   const std::vector<kernel_id> &KernelIDs) {
-  detail::KernelBundleImplPtr Impl =
-      detail::get_kernel_bundle_impl(Ctx, Devs, KernelIDs, State);
+  static const int Anchor = 0;
+  detail::KernelBundleImplPtr Impl = detail::get_kernel_bundle_impl(
+      Ctx, Devs, KernelIDs, State, detail::OSUtil::getOSModuleHandle(&Anchor));
   return detail::createSyclObjFromImpl<kernel_bundle<State>>(Impl);
 }
 
@@ -396,7 +399,8 @@ using DevImgSelectorImpl =
 // public onces
 __SYCL_EXPORT detail::KernelBundleImplPtr
 get_kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
-                       bundle_state State, const DevImgSelectorImpl &Selector);
+                       bundle_state State, const DevImgSelectorImpl &Selector,
+                       OSModuleHandle M);
 } // namespace detail
 
 /// A kernel bundle in state State which contains all of the device images for
@@ -411,9 +415,11 @@ kernel_bundle<State> get_kernel_bundle(const context &Ctx,
             detail::createSyclObjFromImpl<sycl::device_image<State>>(DevImg));
       };
 
-  std::vector<kernel_id> EmptyKernelIDs;
-  detail::KernelBundleImplPtr Impl =
-      detail::get_kernel_bundle_impl(Ctx, Devs, State, SelectorWrapper);
+  static const int Anchor = 0;
+
+  detail::KernelBundleImplPtr Impl = detail::get_kernel_bundle_impl(
+      Ctx, Devs, State, SelectorWrapper,
+      detail::OSUtil::getOSModuleHandle(&Anchor));
 
   return detail::createSyclObjFromImpl<sycl::kernel_bundle<State>>(Impl);
 }
@@ -431,12 +437,12 @@ namespace detail {
 
 __SYCL_EXPORT bool has_kernel_bundle_impl(const context &Ctx,
                                           const std::vector<device> &Devs,
-                                          bundle_state State);
+                                          bundle_state State, OSModuleHandle M);
 
 __SYCL_EXPORT bool
 has_kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
                        const std::vector<kernel_id> &kernelIds,
-                       bundle_state State);
+                       bundle_state State, OSModuleHandle M);
 } // namespace detail
 
 /// \returns true if the following is true:
@@ -451,13 +457,18 @@ has_kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
 /// aspect::online_linker.
 template <bundle_state State>
 bool has_kernel_bundle(const context &Ctx, const std::vector<device> &Devs) {
-  return detail::has_kernel_bundle_impl(Ctx, Devs, State);
+
+  static const int Anchor = 0;
+  return detail::has_kernel_bundle_impl(
+      Ctx, Devs, State, detail::OSUtil::getOSModuleHandle(&Anchor));
 }
 
 template <bundle_state State>
 bool has_kernel_bundle(const context &Ctx, const std::vector<device> &Devs,
                        const std::vector<kernel_id> &KernelIDs) {
-  return detail::has_kernel_bundle_impl(Ctx, Devs, KernelIDs, State);
+  static const int Anchor = 0;
+  return detail::has_kernel_bundle_impl(
+      Ctx, Devs, KernelIDs, State, detail::OSUtil::getOSModuleHandle(&Anchor));
 }
 
 template <bundle_state State> bool has_kernel_bundle(const context &Ctx) {

sycl/source/CMakeLists.txt

@@ -4,7 +4,6 @@
 #cmake_policy(SET CMP0057 NEW)
 #include(AddLLVM)
 
-add_definitions(-g -O0)
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/version.rc.in
   ${CMAKE_CURRENT_BINARY_DIR}/version.rc

sycl/source/detail/device_image_impl.hpp

@@ -13,6 +13,7 @@
 #include <CL/sycl/detail/pi.h>
 #include <CL/sycl/device.hpp>
 #include <CL/sycl/kernel_bundle.hpp>
+#include <detail/context_impl.hpp>
 #include <detail/device_impl.hpp>
 #include <detail/kernel_id_impl.hpp>
 #include <detail/program_manager/program_manager.hpp>
@@ -28,46 +29,18 @@ __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
 
-// Used for sorting vector of kernel_id's
-struct LessByNameComp {
-  bool operator()(const sycl::kernel_id &LHS, const sycl::kernel_id &RHS) {
-    return std::strcmp(LHS.get_name(), RHS.get_name()) < 0;
-  }
-};
-
 // The class is impl counterpart for sycl::device_image
 // It can represent a program in different states, kernel_id's it has and state
 // of specialization constants for it
 class device_image_impl {
 public:
-  device_image_impl(context Context, std::vector<device> Devices,
-                    bundle_state State)
-      : MBinImage(nullptr), MContext(std::move(Context)),
-        MDevices(std::move(Devices)), MState(State) {}
 
   device_image_impl(RTDeviceBinaryImage *BinImage, context Context,
-                    std::vector<device> Devices, bundle_state State)
-      : MBinImage(BinImage), MContext(std::move(Context)),
-        MDevices(std::move(Devices)), MState(State) {
-
-    // Collect kernel names for the image
-    pi_device_binary DevBin =
-        const_cast<pi_device_binary>(&MBinImage->getRawData());
-    for (_pi_offload_entry EntriesIt = DevBin->EntriesBegin;
-         EntriesIt != DevBin->EntriesEnd; ++EntriesIt) {
-
-      std::shared_ptr<detail::kernel_id_impl> KernleIDImpl =
-          std::make_shared<detail::kernel_id_impl>(EntriesIt->name);
-
-      sycl::kernel_id KernelID =
-          detail::createSyclObjFromImpl<sycl::kernel_id>(KernleIDImpl);
-
-      // Insert new element keeping MKernelIDs sorted.
-      auto It = std::lower_bound(MKernelIDs.begin(), MKernelIDs.end(), KernelID,
-                                 LessByNameComp{});
-      MKernelIDs.insert(It, std::move(KernelID));
-    }
-  }
+                    std::vector<device> Devices, bundle_state State,
+                    std::vector<kernel_id> KernelIDs, OSModuleHandle M)
+      : MBinImage(BinImage), MOSModuleHandle(std::move(M)),
+        MContext(std::move(Context)), MDevices(std::move(Devices)),
+        MState(State), MKernelIDs(std::move(KernelIDs)) {}
 
   bool has_kernel(const kernel_id &KernelIDCand) const noexcept {
     return std::binary_search(MKernelIDs.begin(), MKernelIDs.end(),
@@ -171,10 +144,18 @@ class device_image_impl {
     return MSpecConstDescs;
   }
 
-  OSModuleHandle get_OS_module_handle() const noexcept {
+  OSModuleHandle &get_OS_module_handle_ref() noexcept {
     return MOSModuleHandle;
   }
 
+  ~device_image_impl() {
+
+    if (MProgram) {
+      const detail::plugin &Plugin = getSyclObjImpl(MContext)->getPlugin();
+      Plugin.call<PiApiKind::piProgramRelease>(MProgram);
+    }
+  }
+
 private:
   RTDeviceBinaryImage *MBinImage = nullptr;
   OSModuleHandle MOSModuleHandle = 0;

sycl/source/detail/global_handler.cpp

@@ -114,6 +114,17 @@ GlobalHandler::getDeviceFilterList(const std::string &InitValue) {
   return *MDeviceFilterList;
 }
 
+std::mutex &GlobalHandler::getHandlerExtendedMembersMutex() {
+  if (MHandlerExtendedMembersMutex)
+    return *MHandlerExtendedMembersMutex;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MHandlerExtendedMembersMutex)
+    MHandlerExtendedMembersMutex = std::make_unique<std::mutex>();
+
+  return *MHandlerExtendedMembersMutex;
+}
+
 void shutdown() {
   // First, release resources, that may access plugins.
   GlobalHandler::instance().MScheduler.reset(nullptr);

sycl/source/detail/global_handler.hpp

@@ -56,6 +56,7 @@ class GlobalHandler {
   std::mutex &getFilterMutex();
   std::vector<plugin> &getPlugins();
   device_filter_list &getDeviceFilterList(const std::string &InitValue);
+  std::mutex &getHandlerExtendedMembersMutex();
 
 private:
   friend void shutdown();
@@ -76,6 +77,7 @@ class GlobalHandler {
   std::unique_ptr<std::mutex> MFilterMutex;
   std::unique_ptr<std::vector<plugin>> MPlugins;
   std::unique_ptr<device_filter_list> MDeviceFilterList;
+  std::unique_ptr<std::mutex> MHandlerExtendedMembersMutex;
 };
 } // namespace detail
 } // namespace sycl

sycl/source/detail/kernel_bundle_impl.hpp

@@ -39,11 +39,12 @@ template <class T> struct LessByHash {
 class kernel_bundle_impl {
 
 public:
-  kernel_bundle_impl(context Ctx, std::vector<device> Devs, bundle_state State)
+  kernel_bundle_impl(context Ctx, std::vector<device> Devs, bundle_state State,
+                     OSModuleHandle &M)
       : MContext(std::move(Ctx)), MDevices(std::move(Devs)) {
 
     MDeviceImages = detail::ProgramManager::getInstance().getSYCLDeviceImages(
-        MContext, MDevices, State);
+        MContext, MDevices, State, M);
   }
 
   // Matches sycl::build
@@ -110,8 +111,8 @@ class kernel_bundle_impl {
 
   kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
                      const std::vector<kernel_id> &KernelIDs,
-                     bundle_state State)
-      : kernel_bundle_impl(Ctx, Devs, State) {
+                     bundle_state State, OSModuleHandle &M)
+      : kernel_bundle_impl(Ctx, Devs, State, M) {
 
     // Filter out images that have no kernel_ids specified
     auto It = std::remove_if(MDeviceImages.begin(), MDeviceImages.end(),
@@ -126,8 +127,9 @@ class kernel_bundle_impl {
   }
 
   kernel_bundle_impl(const context &Ctx, const std::vector<device> &Devs,
-                     const DevImgSelectorImpl &Selector, bundle_state State)
-      : kernel_bundle_impl(Ctx, Devs, State) {
+                     const DevImgSelectorImpl &Selector, bundle_state State,
+                     OSModuleHandle &M)
+      : kernel_bundle_impl(Ctx, Devs, State, M) {
 
     // Filter out images that are rejected by Selector
     auto It = std::remove_if(MDeviceImages.begin(), MDeviceImages.end(),

sycl/source/detail/kernel_id_impl.hpp

@@ -12,6 +12,13 @@ __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
 
+// Used for sorting vector of kernel_id's
+struct LessByNameComp {
+  bool operator()(const sycl::kernel_id &LHS, const sycl::kernel_id &RHS) {
+    return std::strcmp(LHS.get_name(), RHS.get_name()) < 0;
+  }
+};
+
 // The class is impl counterpart for sycl::kernel_id which represent a kernel
 // identificator
 class kernel_id_impl {