[SYCL] Cache kernel assert usage (#18538)

Cache whether a kernel uses assertions or not to avoid a set lookup.

Author: sergey-semenov

sycl/source/detail/handler_impl.hpp

@@ -210,7 +210,7 @@ class handler_impl {
   bool MKernelHasSpecialCaptures = true;
 
   // A pointer to a kernel name based cache retrieved on the application side.
-  KernelNameBasedCacheT *MKernelNameBasedCachePtr;
+  KernelNameBasedCacheT *MKernelNameBasedCachePtr = nullptr;
 };
 
 } // namespace detail

sycl/source/detail/kernel_name_based_cache_t.hpp

@@ -12,6 +12,7 @@
 #include <sycl/detail/ur.hpp>
 
 #include <mutex>
+#include <optional>
 
 #include <boost/unordered/unordered_flat_map.hpp>
 
@@ -36,6 +37,7 @@ struct FastKernelSubcacheT {
 
 struct KernelNameBasedCacheT {
   FastKernelSubcacheT FastKernelSubcache;
+  std::optional<bool> UsesAssert;
 };
 
 } // namespace detail

sycl/source/detail/program_manager/program_manager.hpp

@@ -12,6 +12,7 @@
 #include <detail/device_global_map_entry.hpp>
 #include <detail/host_pipe_map_entry.hpp>
 #include <detail/kernel_arg_mask.hpp>
+#include <detail/kernel_name_based_cache_t.hpp>
 #include <detail/spec_constant_impl.hpp>
 #include <sycl/detail/cg_types.hpp>
 #include <sycl/detail/common.hpp>
@@ -359,8 +360,16 @@ class ProgramManager {
   ~ProgramManager() = default;
 
   template <typename NameT>
-  bool kernelUsesAssert(const NameT &KernelName) const {
-    return m_KernelUsesAssert.find(KernelName) != m_KernelUsesAssert.end();
+  bool kernelUsesAssert(const NameT &KernelName,
+                        KernelNameBasedCacheT *KernelNameBasedCachePtr) const {
+    if (!KernelNameBasedCachePtr)
+      return m_KernelUsesAssert.find(KernelName) != m_KernelUsesAssert.end();
+
+    std::optional<bool> &UsesAssert = KernelNameBasedCachePtr->UsesAssert;
+    if (!UsesAssert.has_value())
+      UsesAssert =
+          m_KernelUsesAssert.find(KernelName) != m_KernelUsesAssert.end();
+    return UsesAssert.value();
   }
 
   SanitizerType kernelUsesSanitizer() const { return m_SanitizerFoundInImage; }

sycl/source/detail/queue_impl.hpp

@@ -872,7 +872,8 @@ class queue_impl : public std::enable_shared_from_this<queue_impl> {
       KernelUsesAssert =
           (!Handler.MKernel || Handler.MKernel->hasSYCLMetadata()) &&
           ProgramManager::getInstance().kernelUsesAssert(
-              Handler.MKernelName.data());
+              Handler.MKernelName.data(),
+              Handler.impl->MKernelNameBasedCachePtr);
 
     auto &PostProcess = *PostProcessorFunc;
     PostProcess(IsKernel, KernelUsesAssert, Event);

sycl/source/detail/scheduler/commands.cpp

@@ -3276,7 +3276,8 @@ ur_result_t ExecCGCommand::enqueueImpQueue() {
       // Kernel only uses assert if it's non interop one
       bool KernelUsesAssert =
           (!SyclKernel || SyclKernel->hasSYCLMetadata()) &&
-          ProgramManager::getInstance().kernelUsesAssert(KernelName);
+          ProgramManager::getInstance().kernelUsesAssert(
+              KernelName, ExecKernel->MKernelNameBasedCachePtr);
       if (KernelUsesAssert) {
         EventImpl = MEvent.get();
       }

sycl/source/handler.cpp

@@ -550,7 +550,7 @@ event handler::finalize() {
         bool KernelUsesAssert =
             !(MKernel && MKernel->isInterop()) &&
             detail::ProgramManager::getInstance().kernelUsesAssert(
-                MKernelName.data());
+                MKernelName.data(), impl->MKernelNameBasedCachePtr);
         DiscardEvent = !KernelUsesAssert;
       }