revert template specialization

Author: lslusarczyk

sycl/source/detail/config.cpp

@@ -204,10 +204,12 @@ unsigned int parseLevel(const char *ValStr) {
 
 } // namespace
 
-void SYCLConfigTrace::reset() { Level = parseLevel(BaseT::getRawValue()); }
+void SYCLConfig<SYCL_CACHE_TRACE>::reset() {
+  Level = parseLevel(BaseT::getRawValue());
+}
 
-unsigned int SYCLConfigTrace::Level =
-    parseLevel(SYCLConfigTrace::BaseT::getRawValue());
+unsigned int SYCLConfig<SYCL_CACHE_TRACE>::Level =
+    parseLevel(BaseT::getRawValue());
 
 } // namespace detail
 } // namespace _V1

sycl/source/detail/config.hpp

@@ -709,7 +709,7 @@ 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.
-class SYCLConfigTrace {
+template <> class SYCLConfig<SYCL_CACHE_TRACE> {
   using BaseT = SYCLConfigBase<SYCL_CACHE_TRACE>;
   enum TraceBitmask { DiskCache = 1, InMemCache = 2, KernelCompiler = 4 };
 

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 (!SYCLConfigTrace::isTraceInMemCache())
+    if (!SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache())
       return;
 
     int ImageId = CacheKey.first.second;
@@ -368,7 +368,8 @@ class KernelProgramCache {
   // set.
   static void traceKernel(const char *Msg, KernelNameStrRefT KernelName,
                           bool isFastKernelCache = false) {
-    if (__builtin_expect(SYCLConfigTrace::isTraceInMemCache(), false))
+    if (__builtin_expect(SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache(),
+                         false))
       traceKernelImpl(Msg, KernelName, isFastKernelCache);
   }
 
@@ -507,7 +508,8 @@ class KernelProgramCache {
         auto LockedCacheKP = acquireKernelsPerProgramCache();
         // List kernels that are to be removed from the cache, if tracing is
         // enabled.
-        if (__builtin_expect(SYCLConfigTrace::isTraceInMemCache(), false)) {
+        if (__builtin_expect(SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache(),
+                             false)) {
           for (const auto &Kernel : LockedCacheKP.get()[NativePrg])
             traceKernel("Kernel evicted.", Kernel.first);
         }

sycl/source/detail/persistent_device_code_cache.hpp

@@ -222,15 +222,17 @@ class PersistentDeviceCodeCache {
 
   /* Sends message to std:cerr stream when SYCL_CACHE_TRACE environemnt is set*/
   static void trace(const std::string &msg, const std::string &path = "") {
-    if (__builtin_expect(SYCLConfigTrace::isTraceDiskCache(), false)) {
+    if (__builtin_expect(SYCLConfig<SYCL_CACHE_TRACE>::isTraceDiskCache(),
+                         false)) {
       auto outputPath = path;
       std::replace(outputPath.begin(), outputPath.end(), '\\', '/');
       std::cerr << "[Persistent Cache]: " << msg << outputPath << std::endl;
     }
   }
   static void trace_KernelCompiler(const std::string &msg,
                                    const std::string &path = "") {
-    if (__builtin_expect(SYCLConfigTrace::isTraceKernelCompiler(), false)) {
+    if (__builtin_expect(SYCLConfig<SYCL_CACHE_TRACE>::isTraceKernelCompiler(),
+                         false)) {
       auto outputPath = path;
       std::replace(outputPath.begin(), outputPath.end(), '\\', '/');
       std::cerr << "[kernel_compiler Persistent Cache]: " << msg << outputPath

sycl/unittests/config/ConfigTests.cpp

@@ -249,17 +249,20 @@ TEST(ConfigTests, CheckSyclCacheTraceTest) {
   // Lambda to test parsing of SYCL_CACHE_TRACE
   auto TestConfig = [](int expectedValue, int expectedDiskCache,
                        int expectedInMemCache, int expectedKernelCompiler) {
-    EXPECT_EQ(static_cast<unsigned int>(expectedValue), SYCLConfigTrace::get());
+    EXPECT_EQ(static_cast<unsigned int>(expectedValue),
+              SYCLConfig<SYCL_CACHE_TRACE>::get());
 
     EXPECT_EQ(
         expectedDiskCache,
-        static_cast<int>(sycl::detail::SYCLConfigTrace::isTraceDiskCache()));
+        static_cast<int>(
+            sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::isTraceDiskCache()));
     EXPECT_EQ(
         expectedInMemCache,
-        static_cast<int>(sycl::detail::SYCLConfigTrace::isTraceInMemCache()));
+        static_cast<int>(
+            sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::isTraceInMemCache()));
     EXPECT_EQ(expectedKernelCompiler,
-              static_cast<int>(
-                  sycl::detail::SYCLConfigTrace::isTraceKernelCompiler()));
+              static_cast<int>(sycl::detail::SYCLConfig<
+                               SYCL_CACHE_TRACE>::isTraceKernelCompiler()));
   };
 
   // Lambda to set SYCL_CACHE_TRACE
@@ -276,40 +279,40 @@ TEST(ConfigTests, CheckSyclCacheTraceTest) {
   TestConfig(0, 0, 0, 0);
 
   SetSyclCacheTraceEnv("1");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(1, 1, 0, 0);
 
   SetSyclCacheTraceEnv("2");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(2, 0, 1, 0);
 
   SetSyclCacheTraceEnv("3");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(3, 1, 1, 0);
 
   SetSyclCacheTraceEnv("4");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(4, 0, 0, 1);
 
   SetSyclCacheTraceEnv("5");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(5, 1, 0, 1);
 
   SetSyclCacheTraceEnv("6");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(6, 0, 1, 1);
 
   SetSyclCacheTraceEnv("7");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(7, 1, 1, 1);
 
   SetSyclCacheTraceEnv("8");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(1, 1, 0, 0);
 
   // Set random non-null value. It should default to 1.
   SetSyclCacheTraceEnv("random");
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(1, 1, 0, 0);
 
   // When SYCL_CACHE_TRACE is not set, it should default to 0.
@@ -318,7 +321,7 @@ TEST(ConfigTests, CheckSyclCacheTraceTest) {
 #else
   unsetenv("SYCL_CACHE_TRACE");
 #endif
-  sycl::detail::SYCLConfigTrace::reset();
+  sycl::detail::SYCLConfig<SYCL_CACHE_TRACE>::reset();
   TestConfig(0, 0, 0, 0);
 }