optimize enqueueImpKernel

Author: lslusarczyk

sycl/source/detail/config.cpp

@@ -180,6 +180,35 @@ const std::array<std::pair<std::string, backend>, 8> &getSyclBeMap() {
        {"*", backend::all}}};
   return SyclBeMap;
 }
+namespace {
+
+unsigned int parseLevel(const char *ValStr) {
+  unsigned int intVal = 0;
+
+  if (ValStr) {
+    try {
+      intVal = std::stoul(ValStr);
+    } catch (...) {
+      // If the value is not null and not a number, it is considered
+      // to enable disk cache tracing. This is the legacy behavior.
+      intVal = 1;
+    }
+  }
+
+  // Legacy behavior.
+  if (intVal > 7)
+    intVal = 1;
+
+  return intVal;
+};
+
+}
+
+void SYCLConfigTrace::reset() {
+  Level = parseLevel(BaseT::getRawValue());
+}
+
+unsigned int SYCLConfigTrace::Level = parseLevel(SYCLConfigTrace::BaseT::getRawValue());
 
 } // namespace detail
 } // namespace _V1

sycl/source/detail/config.hpp

@@ -709,54 +709,28 @@ template <> class SYCLConfig<SYCL_JIT_AMDGCN_PTX_TARGET_FEATURES> {
 // tracing of the corresponding caches. If the input value is not null and
 // not a valid number, the disk cache tracing will be enabled (depreciated
 // behavior). The default value is 0 and no tracing is enabled.
-template <> class SYCLConfig<SYCL_CACHE_TRACE> {
+class SYCLConfigTrace {
   using BaseT = SYCLConfigBase<SYCL_CACHE_TRACE>;
   enum TraceBitmask { DiskCache = 1, InMemCache = 2, KernelCompiler = 4 };
 
 public:
-  static unsigned int get() { return getCachedValue(); }
-  static void reset() { (void)getCachedValue(true); }
+  static unsigned int get() { return Level; }
+  static void reset();
   static bool isTraceDiskCache() {
-    return getCachedValue() & TraceBitmask::DiskCache;
+    return Level & DiskCache;
   }
   static bool isTraceInMemCache() {
-    return getCachedValue() & TraceBitmask::InMemCache;
+    return Level & InMemCache;
   }
   static bool isTraceKernelCompiler() {
-    return getCachedValue() & TraceBitmask::KernelCompiler;
+    return Level & KernelCompiler;
   }
 
 private:
-  static unsigned int getCachedValue(bool ResetCache = false) {
-    const auto Parser = []() {
-      const char *ValStr = BaseT::getRawValue();
-      int intVal = 0;
-
-      if (ValStr) {
-        try {
-          intVal = std::stoi(ValStr);
-        } catch (...) {
-          // If the value is not null and not a number, it is considered
-          // to enable disk cache tracing. This is the legacy behavior.
-          intVal = 1;
-        }
-      }
-
-      // Legacy behavior.
-      if (intVal > 7)
-        intVal = 1;
-
-      return intVal;
-    };
-
-    static unsigned int Level = Parser();
-    if (ResetCache)
-      Level = Parser();
-
-    return Level;
-  }
+    static unsigned int Level;
 };
 
+
 // SYCL_IN_MEM_CACHE_EVICTION_THRESHOLD accepts an integer that specifies
 // the maximum size of the in-memory Program cache.
 // Cache eviction is performed when the cache size exceeds the threshold.

sycl/source/detail/context_impl.cpp

@@ -263,22 +263,6 @@ context_impl::get_backend_info<info::device::backend_version>() const {
 }
 #endif
 
-ur_context_handle_t &context_impl::getHandleRef() { return MContext; }
-const ur_context_handle_t &context_impl::getHandleRef() const {
-  return MContext;
-}
-
-KernelProgramCache &context_impl::getKernelProgramCache() const {
-  return MKernelProgramCache;
-}
-
-bool context_impl::hasDevice(const detail::device_impl &Device) const {
-  for (device_impl *D : MDevices)
-    if (D == &Device)
-      return true;
-  return false;
-}
-
 device_impl *
 context_impl::findMatchingDeviceImpl(ur_device_handle_t &DeviceUR) const {
   for (device_impl *D : MDevices)

sycl/source/detail/context_impl.hpp

@@ -116,7 +116,7 @@ class context_impl : public std::enable_shared_from_this<context_impl> {
   /// reference will be invalid if context_impl was destroyed.
   ///
   /// \return an instance of raw UR context handle.
-  ur_context_handle_t &getHandleRef();
+  ur_context_handle_t &getHandleRef() { return MContext; }
 
   /// Gets the underlying context object (if any) without reference count
   /// modification.
@@ -126,7 +126,9 @@ class context_impl : public std::enable_shared_from_this<context_impl> {
   /// reference will be invalid if context_impl was destroyed.
   ///
   /// \return an instance of raw UR context handle.
-  const ur_context_handle_t &getHandleRef() const;
+  const ur_context_handle_t &getHandleRef() const {
+    return MContext;
+  }
 
   devices_range getDevices() const { return MDevices; }
 
@@ -151,10 +153,17 @@ class context_impl : public std::enable_shared_from_this<context_impl> {
     return {MCachedLibPrograms, MCachedLibProgramsMutex};
   }
 
-  KernelProgramCache &getKernelProgramCache() const;
+  KernelProgramCache &getKernelProgramCache() const {
+    return MKernelProgramCache;
+  }
 
   /// Returns true if and only if context contains the given device.
-  bool hasDevice(const detail::device_impl &Device) const;
+  bool hasDevice(const detail::device_impl &Device) const {
+    for (device_impl *D : MDevices)
+      if (D == &Device)
+        return true;
+    return false;
+  }
 
   /// Returns true if and only if the device can be used within this context.
   /// For OpenCL this is currently equivalent to hasDevice, for other backends

sycl/source/detail/device_kernel_info.cpp

@@ -74,27 +74,6 @@ void DeviceKernelInfo::setCompileTimeInfoIfNeeded(
   assert(Info == *this);
 }
 
-FastKernelSubcacheT &DeviceKernelInfo::getKernelSubcache() {
-  assertInitialized();
-  return MFastKernelSubcache;
-}
-bool DeviceKernelInfo::usesAssert() {
-  assertInitialized();
-  return MUsesAssert;
-}
-const std::optional<int> &DeviceKernelInfo::getImplicitLocalArgPos() {
-  assertInitialized();
-  return MImplicitLocalArgPos;
-}
-
-bool DeviceKernelInfo::isCompileTimeInfoSet() const { return KernelSize != 0; }
-
-void DeviceKernelInfo::assertInitialized() {
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-  assert(MInitialized.load() && "Data needs to be initialized before use");
-#endif
-}
-
 } // namespace detail
 } // namespace _V1
 } // namespace sycl

sycl/source/detail/device_kernel_info.hpp

@@ -107,13 +107,28 @@ class DeviceKernelInfo : public CompileTimeKernelInfoTy {
 #endif
   void setCompileTimeInfoIfNeeded(const CompileTimeKernelInfoTy &Info);
 
-  FastKernelSubcacheT &getKernelSubcache();
-  bool usesAssert();
-  const std::optional<int> &getImplicitLocalArgPos();
+  FastKernelSubcacheT &getKernelSubcache() {
+    assertInitialized();
+    return MFastKernelSubcache;
+  }
+
+  bool usesAssert() const {
+    assertInitialized();
+    return MUsesAssert;
+  }
+
+  const std::optional<int> &getImplicitLocalArgPos() {
+    assertInitialized();
+    return MImplicitLocalArgPos;
+  }
 
 private:
-  void assertInitialized();
-  bool isCompileTimeInfoSet() const;
+    void assertInitialized() const {
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+      assert(MInitialized.load() && "Data needs to be initialized before use");
+#endif
+    }
+  bool isCompileTimeInfoSet() const { return KernelSize != 0; }
 
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   std::atomic<bool> MInitialized = false;

sycl/source/detail/global_handler.cpp

@@ -105,20 +105,7 @@ void GlobalHandler::TraceEventXPTI(const char *Message) {
 #endif
 }
 
-GlobalHandler *&GlobalHandler::getInstancePtr() {
-  static GlobalHandler *RTGlobalObjHandler = new GlobalHandler();
-  return RTGlobalObjHandler;
-}
-
-GlobalHandler &GlobalHandler::instance() {
-  GlobalHandler *RTGlobalObjHandler = GlobalHandler::getInstancePtr();
-  assert(RTGlobalObjHandler && "Handler must not be deallocated earlier");
-  return *RTGlobalObjHandler;
-}
-
-bool GlobalHandler::isInstanceAlive() {
-  return GlobalHandler::getInstancePtr();
-}
+GlobalHandler *GlobalHandler::RTGlobalObjHandler = new GlobalHandler();
 
 template <typename T, typename... Types>
 T &GlobalHandler::getOrCreate(InstWithLock<T> &IWL, Types &&...Args) {

sycl/source/detail/global_handler.hpp

@@ -48,14 +48,20 @@ class DeviceKernelInfo;
 /// construction or destruction is generated anyway.
 class GlobalHandler {
 public:
-  /// \return a reference to a GlobalHandler singleton instance. Memory for
-  /// storing objects is allocated on first call. The reference is valid as long
+
+    static bool isInstanceAlive() {
+      return RTGlobalObjHandler != nullptr;
+    }
+  /// \return a reference to a GlobalHandler singleton instance. The reference is valid as long
   /// as runtime library is loaded (i.e. untill `DllMain` or
   /// `__attribute__((destructor))` is called).
-  static GlobalHandler &instance();
+  static GlobalHandler &instance() {
+    return *RTGlobalObjHandler;
+  }
 
-  /// \return true if the instance has not been deallocated yet.
-  static bool isInstanceAlive();
+  static GlobalHandler *&getInstancePtr() {
+    return RTGlobalObjHandler;
+  }
 
   GlobalHandler(const GlobalHandler &) = delete;
   GlobalHandler(GlobalHandler &&) = delete;
@@ -95,20 +101,19 @@ class GlobalHandler {
   // For testing purposes only
   void attachScheduler(Scheduler *Scheduler);
 
+    // Constructor and destructor are declared out-of-line to allow incomplete
+    // types as template arguments to unique_ptr.
+    GlobalHandler();
+    ~GlobalHandler();
+
 private:
   bool OkToDefer = true;
 
   friend void shutdown_early(bool);
   friend void shutdown_late();
   friend class ObjectUsageCounter;
-  static GlobalHandler *&getInstancePtr();
   static SpinLock MSyclGlobalHandlerProtector;
 
-  // Constructor and destructor are declared out-of-line to allow incomplete
-  // types as template arguments to unique_ptr.
-  GlobalHandler();
-  ~GlobalHandler();
-
   template <typename T> struct InstWithLock {
     std::unique_ptr<T> Inst;
     SpinLock Lock;
@@ -135,7 +140,10 @@ class GlobalHandler {
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   InstWithLock<std::deque<DeviceKernelInfo>> MDeviceKernelInfoStorage;
 #endif
+
+    static GlobalHandler *RTGlobalObjHandler;
 };
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl

sycl/source/detail/kernel_program_cache.cpp

@@ -12,6 +12,18 @@
 namespace sycl {
 inline namespace _V1 {
 namespace detail {
+
+void KernelProgramCache::traceKernelImpl(const char * Msg,
+                                 KernelNameStrRefT KernelName,
+                                 bool IsFastKernelCache) {
+  std::string Identifier =
+      "[IsFastCache: " + std::to_string(IsFastKernelCache) +
+      "][Key:{Name = " + KernelName.data() + "}]: ";
+
+  std::cerr << "[In-Memory Cache][Thread Id:" << std::this_thread::get_id()
+            << "][Kernel Cache]" << Identifier << Msg << std::endl;
+}
+
 adapter_impl &KernelProgramCache::getAdapter() {
   return MParentContext.getAdapter();
 }

sycl/source/detail/kernel_program_cache.hpp

@@ -331,7 +331,7 @@ class KernelProgramCache {
   template <typename MsgType>
   static inline void traceProgram(const MsgType &Msg,
                                   const ProgramCacheKeyT &CacheKey) {
-    if (!SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache())
+    if (!SYCLConfigTrace::isTraceInMemCache())
       return;
 
     int ImageId = CacheKey.first.second;
@@ -361,23 +361,18 @@ class KernelProgramCache {
               << "][Program Cache]" << Identifier << Msg << std::endl;
   }
 
-  // Sends message to std:cerr stream when SYCL_CACHE_TRACE environemnt is
-  // set.
-  template <typename MsgType>
-  static inline void traceKernel(const MsgType &Msg,
+  static void traceKernelImpl(const char * Msg,
                                  KernelNameStrRefT KernelName,
-                                 bool IsFastKernelCache = false) {
-    if (!SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache())
-      return;
+                                 bool IsFastKernelCache);
 
-    std::string Identifier =
-        "[IsFastCache: " + std::to_string(IsFastKernelCache) +
-        "][Key:{Name = " + KernelName.data() + "}]: ";
-
-    std::cerr << "[In-Memory Cache][Thread Id:" << std::this_thread::get_id()
-              << "][Kernel Cache]" << Identifier << Msg << std::endl;
+    // Sends message to std:cerr stream when SYCL_CACHE_TRACE environemnt is
+    // set.
+  static void traceKernel(const char * Msg, KernelNameStrRefT KernelName, bool isFastKernelCache = false) {
+    if (__builtin_expect(SYCLConfigTrace::isTraceInMemCache(), false))
+      traceKernelImpl(Msg, KernelName, isFastKernelCache);
   }
 
+
   Locked<ProgramCache> acquireCachedPrograms() {
     return {MCachedPrograms, MProgramCacheMutex};
   }
@@ -513,7 +508,7 @@ class KernelProgramCache {
         auto LockedCacheKP = acquireKernelsPerProgramCache();
         // List kernels that are to be removed from the cache, if tracing is
         // enabled.
-        if (SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache()) {
+        if (SYCLConfigTrace::isTraceInMemCache()) {
           for (const auto &Kernel : LockedCacheKP.get()[NativePrg])
             traceKernel("Kernel evicted.", Kernel.first);
         }