Add tracing for in-memory cache

Author: uditagarwal97

sycl/source/detail/kernel_program_cache.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "sycl/exception.hpp"
+#include <detail/config.hpp>
 #include <detail/kernel_arg_mask.hpp>
 #include <detail/platform_impl.hpp>
 #include <sycl/detail/common.hpp>
@@ -19,8 +20,10 @@
 
 #include <atomic>
 #include <condition_variable>
+#include <iomanip>
 #include <mutex>
 #include <set>
+#include <thread>
 #include <type_traits>
 
 #include <boost/unordered/unordered_flat_map.hpp>
@@ -176,6 +179,48 @@ class KernelProgramCache {
 
   void setContextPtr(const ContextPtr &AContext) { MParentContext = AContext; }
 
+  /* Sends message to std:cerr stream when SYCL_CACHE_TRACE environemnt is
+   * set.*/
+  static void traceProgram(const std::string &Msg,
+                           const ProgramCacheKeyT &CacheKey) {
+    static const bool traceEnabled =
+        SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache();
+    if (traceEnabled) {
+
+      int ImageId = CacheKey.first.second;
+      std::stringstream DeviceList;
+      for (const auto &Device : CacheKey.second)
+        DeviceList << "0x" << std::setbase(16)
+                   << reinterpret_cast<uintptr_t>(Device) << ",";
+
+      std::string Identifier = "[Key:{imageId = " + std::to_string(ImageId) +
+                               ",urDevice = " + DeviceList.str() + "]}: ";
+
+      // Get TID of current thread.
+      thread_local std::thread::id this_id = std::this_thread::get_id();
+      std::cerr << "[In-Memory Cache][Thread Id:" << this_id
+                << "][Program Cache]" << Identifier << Msg << std::endl;
+    }
+  }
+
+  /* Sends message to std:cerr stream when SYCL_CACHE_TRACE environemnt is
+   * set.*/
+  static void traceKernel(const std::string &Msg, const std::string &KernelName,
+                          bool IsKernelFastCache = false) {
+    static const bool traceEnabled =
+        SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache();
+    if (traceEnabled) {
+      std::string Identifier =
+          "[IsFastCache: " + std::to_string(IsKernelFastCache)
+                           + "][Key:{Name = " + KernelName + "]}: ";
+
+      // Get TID of current thread.
+      thread_local std::thread::id this_id = std::this_thread::get_id();
+      std::cerr << "[In-Memory Cache][Thread Id:" << this_id
+                << "][Kernel Cache]" << Identifier << Msg << std::endl;
+    }
+  }
+
   Locked<ProgramCache> acquireCachedPrograms() {
     return {MCachedPrograms, MProgramCacheMutex};
   }
@@ -195,7 +240,10 @@ class KernelProgramCache {
       CommonProgramKeyT CommonKey =
           std::make_pair(CacheKey.first.second, CacheKey.second);
       ProgCache.KeyMap.emplace(CommonKey, CacheKey);
+      traceProgram("Program inserted.", CacheKey);
     }
+    else
+      traceProgram("Program fetched.", CacheKey);
     return std::make_pair(It->second, DidInsert);
   }
 
@@ -217,7 +265,10 @@ class KernelProgramCache {
       CommonProgramKeyT CommonKey =
           std::make_pair(CacheKey.first.second, CacheKey.second);
       ProgCache.KeyMap.emplace(CommonKey, CacheKey);
+      traceProgram("Program inserted.", CacheKey);
     }
+    else
+      traceProgram("Program fetched.", CacheKey);
     return DidInsert;
   }
 
@@ -227,8 +278,12 @@ class KernelProgramCache {
     auto LockedCache = acquireKernelsPerProgramCache();
     auto &Cache = LockedCache.get()[Program];
     auto [It, DidInsert] = Cache.try_emplace(KernelName, nullptr);
-    if (DidInsert)
+    if (DidInsert) {
       It->second = std::make_shared<KernelBuildResult>(getAdapter());
+      traceKernel("Kernel inserted.", KernelName);
+    }
+    else
+      traceKernel("Kernel fetched", KernelName);
     return std::make_pair(It->second, DidInsert);
   }
 
@@ -237,6 +292,7 @@ class KernelProgramCache {
     std::unique_lock<std::mutex> Lock(MKernelFastCacheMutex);
     auto It = MKernelFastCache.find(CacheKey);
     if (It != MKernelFastCache.end()) {
+      traceKernel("Kernel fetched", std::get<3>(CacheKey), true);
       return It->second;
     }
     return std::make_tuple(nullptr, nullptr, nullptr, nullptr);
@@ -247,6 +303,7 @@ class KernelProgramCache {
     std::unique_lock<std::mutex> Lock(MKernelFastCacheMutex);
     // if no insertion took place, thus some other thread has already inserted
     // smth in the cache
+    traceKernel("Kernel inserted.", std::get<3>(CacheKey), true);
     MKernelFastCache.emplace(CacheKey, CacheVal);
   }