diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 7e86a024a094b..15d7e50a876ec 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -10977,6 +10977,7 @@ def err_sycl_kernel_incorrectly_named : Error<
   "kernel %select{name is missing"
   "|needs to have a globally-visible name"
   "|name is invalid. Unscoped enum requires fixed underlying type"
+  "|name cannot be a type in the \"std\" namespace"
   "}0">;
 def err_sycl_kernel_not_function_object
     : Error<"kernel parameter must be a lambda or function object">;
diff --git a/clang/lib/Sema/SemaSYCL.cpp b/clang/lib/Sema/SemaSYCL.cpp
index a207c91cef3c1..6c632b022af88 100644
--- a/clang/lib/Sema/SemaSYCL.cpp
+++ b/clang/lib/Sema/SemaSYCL.cpp
@@ -2755,6 +2755,13 @@ void SYCLIntegrationHeader::emitFwdDecl(raw_ostream &O, const Decl *D,
       }
       break;
     }
+
+    if (NS->isStdNamespace()) {
+      Diag.Report(KernelLocation, diag::err_sycl_kernel_incorrectly_named)
+          << /* name cannot be a type in the std namespace */ 3;
+      return;
+    }
+
     ++NamespaceCnt;
     const StringRef NSInlinePrefix = NS->isInline() ? "inline " : "";
     NSStr.insert(
@@ -2837,8 +2844,13 @@ void SYCLIntegrationHeader::emitForwardClassDecls(
     ;
   const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
 
-  if (!RD)
+  if (!RD) {
+    if (T->isNullPtrType())
+      Diag.Report(KernelLocation, diag::err_sycl_kernel_incorrectly_named)
+          << /* name cannot be a type in the std namespace */ 3;
+
     return;
+  }
 
   // see if this is a template specialization ...
   if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
diff --git a/clang/test/CodeGenSYCL/stdtypes_kernel_type.cpp b/clang/test/CodeGenSYCL/stdtypes_kernel_type.cpp
new file mode 100644
index 0000000000000..1509a78741292
--- /dev/null
+++ b/clang/test/CodeGenSYCL/stdtypes_kernel_type.cpp
@@ -0,0 +1,63 @@
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsycl-int-header=%t.h -DCHECK_ERROR -verify %s
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -triple spir64-unknown-unknown-sycldevice -fsycl-int-header=%t.h %s
+// RUN: FileCheck -input-file=%t.h %s
+//
+// CHECK: #include <CL/sycl/detail/defines.hpp>
+// CHECK-NEXT: #include <CL/sycl/detail/kernel_desc.hpp>
+//
+// CHECK: static constexpr
+// CHECK-NEXT: const char* const kernel_names[] = {
+// CHECK-NEXT:   "_ZTSm",
+// CHECK-NEXT:   "_ZTSl"
+// CHECK-NEXT: };
+//
+// CHECK: static constexpr
+// CHECK-NEXT: const kernel_param_desc_t kernel_signatures[] = {
+// CHECK-NEXT:   //--- _ZTSm
+// CHECK-EMPTY:
+// CHECK-NEXT:   //--- _ZTSl
+// CHECK-EMPTY:
+// CHECK-NEXT: };
+//
+// CHECK: static constexpr
+// CHECK-NEXT: const unsigned kernel_signature_start[] = {
+// CHECK-NEXT:  0, // _ZTSm
+// CHECK-NEXT:  1 // _ZTSl
+// CHECK-NEXT: };
+
+// CHECK: template <> struct KernelInfo<unsigned long> {
+// CHECK: template <> struct KernelInfo<long> {
+
+void usage() {
+}
+
+namespace std {
+typedef long unsigned int size_t;
+typedef long int ptrdiff_t;
+typedef decltype(nullptr) nullptr_t;
+class T;
+class U;
+} // namespace std
+
+template <typename T>
+struct Templated_kernel_name;
+
+template <typename name, typename Func>
+__attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
+  kernelFunc();
+}
+
+int main() {
+#ifdef CHECK_ERROR
+  kernel_single_task<std::nullptr_t>([=]() {});                        // expected-error {{kernel name cannot be a type in the "std" namespace}}
+  kernel_single_task<std::T>([=]() {});                                // expected-error {{kernel name cannot be a type in the "std" namespace}}
+  kernel_single_task<Templated_kernel_name<std::nullptr_t>>([=]() {}); // expected-error {{kernel name cannot be a type in the "std" namespace}}
+  kernel_single_task<Templated_kernel_name<std::U>>([=]() {});         // expected-error {{kernel name cannot be a type in the "std" namespace}}
+#endif
+
+  // Although in the std namespace, these resolve to builtins such as `int` that are allowed in kernel names
+  kernel_single_task<std::size_t>([=]() {});
+  kernel_single_task<std::ptrdiff_t>([=]() {});
+
+  return 0;
+}
diff --git a/clang/test/SemaSYCL/unnamed-kernel.cpp b/clang/test/SemaSYCL/unnamed-kernel.cpp
index 45954f325b4d6..c3790cbab3de3 100644
--- a/clang/test/SemaSYCL/unnamed-kernel.cpp
+++ b/clang/test/SemaSYCL/unnamed-kernel.cpp
@@ -11,6 +11,11 @@ template <typename T>
 class KernelName;
 }
 
+namespace std {
+typedef struct {
+} max_align_t;
+} // namespace std
+
 struct MyWrapper {
 private:
   class InvalidKernelName0 {};
@@ -41,7 +46,7 @@ struct MyWrapper {
 
 #ifndef __SYCL_UNNAMED_LAMBDA__
     // expected-error@+4 {{kernel needs to have a globally-visible name}}
-    // expected-note@16 {{InvalidKernelName0 declared here}}
+    // expected-note@21 {{InvalidKernelName0 declared here}}
 #endif
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<InvalidKernelName0>([] {});
@@ -49,7 +54,7 @@ struct MyWrapper {
 
 #ifndef __SYCL_UNNAMED_LAMBDA__
     // expected-error@+4 {{kernel needs to have a globally-visible name}}
-    // expected-note@17 {{InvalidKernelName3 declared here}}
+    // expected-note@22 {{InvalidKernelName3 declared here}}
 #endif
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<namespace1::KernelName<InvalidKernelName3>>([] {});
@@ -60,10 +65,17 @@ struct MyWrapper {
       h.single_task<ValidAlias>([] {});
     });
 
+#ifndef __SYCL_UNNAMED_LAMBDA__
+    // expected-error@+3 {{kernel name cannot be a type in the "std" namespace}}
+#endif
+    q.submit([&](cl::sycl::handler &h) {
+      h.single_task<std::max_align_t>([] {});
+    });
+
     using InvalidAlias = InvalidKernelName4;
 #ifndef __SYCL_UNNAMED_LAMBDA__
     // expected-error@+4 {{kernel needs to have a globally-visible name}}
-    // expected-note@18 {{InvalidKernelName4 declared here}}
+    // expected-note@23 {{InvalidKernelName4 declared here}}
 #endif
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<InvalidAlias>([] {});
@@ -72,7 +84,7 @@ struct MyWrapper {
     using InvalidAlias1 = InvalidKernelName5;
 #ifndef __SYCL_UNNAMED_LAMBDA__
     // expected-error@+4 {{kernel needs to have a globally-visible name}}
-    // expected-note@19 {{InvalidKernelName5 declared here}}
+    // expected-note@24 {{InvalidKernelName5 declared here}}
 #endif
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<namespace1::KernelName<InvalidAlias1>>([] {});
diff --git a/sycl/test/group-algorithm/broadcast.cpp b/sycl/test/group-algorithm/broadcast.cpp
index d0320701010f1..b9d05701113d4 100644
--- a/sycl/test/group-algorithm/broadcast.cpp
+++ b/sycl/test/group-algorithm/broadcast.cpp
@@ -15,14 +15,11 @@
 using namespace sycl;
 using namespace sycl::ONEAPI;
 
-template <typename InputContainer, typename OutputContainer>
-class broadcast_kernel;
-
-template <typename InputContainer, typename OutputContainer>
+template <typename kernel_name, typename InputContainer,
+          typename OutputContainer>
 void test(queue q, InputContainer input, OutputContainer output) {
   typedef typename InputContainer::value_type InputT;
   typedef typename OutputContainer::value_type OutputT;
-  typedef class broadcast_kernel<InputContainer, OutputContainer> kernel_name;
   size_t N = input.size();
   size_t G = 4;
   range<2> R(G, G);
@@ -63,7 +60,7 @@ int main() {
     std::array<int, 3> output;
     std::iota(input.begin(), input.end(), 1);
     std::fill(output.begin(), output.end(), false);
-    test(q, input, output);
+    test<class KernelName_EFL>(q, input, output);
   }
 
   // Test pointer type
@@ -74,7 +71,7 @@ int main() {
       input[i] = static_cast<int *>(0x0) + i;
     }
     std::fill(output.begin(), output.end(), static_cast<int *>(0x0));
-    test(q, input, output);
+    test<class KernelName_NrqELzFQToOSPsRNMi>(q, input, output);
   }
 
   // Test user-defined type
@@ -88,7 +85,7 @@ int main() {
           std::complex<float>(0, 1) + (float)i * std::complex<float>(2, 2);
     }
     std::fill(output.begin(), output.end(), std::complex<float>(0, 0));
-    test(q, input, output);
+    test<class KernelName_rCblcml>(q, input, output);
   }
   {
     std::array<std::complex<double>, N> input;
@@ -98,7 +95,7 @@ int main() {
           std::complex<double>(0, 1) + (double)i * std::complex<double>(2, 2);
     }
     std::fill(output.begin(), output.end(), std::complex<float>(0, 0));
-    test(q, input, output);
+    test<class KernelName_NCWhjnQ>(q, input, output);
   }
   std::cout << "Test passed." << std::endl;
 }
diff --git a/sycl/test/group-algorithm/exclusive_scan.cpp b/sycl/test/group-algorithm/exclusive_scan.cpp
index 1b831a18c0073..b18a16af1b816 100644
--- a/sycl/test/group-algorithm/exclusive_scan.cpp
+++ b/sycl/test/group-algorithm/exclusive_scan.cpp
@@ -24,7 +24,7 @@
 using namespace sycl;
 using namespace sycl::ONEAPI;
 
-template <class BinaryOperation, int TestNumber>
+template <class SpecializationKernelName, int TestNumber>
 class exclusive_scan_kernel;
 
 // std::exclusive_scan isn't implemented yet, so use serial implementation
@@ -44,17 +44,17 @@ OutputIterator exclusive_scan(InputIterator first, InputIterator last,
 }
 } // namespace emu
 
-template <typename InputContainer, typename OutputContainer,
-          class BinaryOperation>
+template <typename SpecializationKernelName, typename InputContainer,
+          typename OutputContainer, class BinaryOperation>
 void test(queue q, InputContainer input, OutputContainer output,
           BinaryOperation binary_op,
           typename OutputContainer::value_type identity) {
   typedef typename InputContainer::value_type InputT;
   typedef typename OutputContainer::value_type OutputT;
-  typedef class exclusive_scan_kernel<BinaryOperation, 0> kernel_name0;
-  typedef class exclusive_scan_kernel<BinaryOperation, 1> kernel_name1;
-  typedef class exclusive_scan_kernel<BinaryOperation, 2> kernel_name2;
-  typedef class exclusive_scan_kernel<BinaryOperation, 3> kernel_name3;
+  typedef class exclusive_scan_kernel<SpecializationKernelName, 0> kernel_name0;
+  typedef class exclusive_scan_kernel<SpecializationKernelName, 1> kernel_name1;
+  typedef class exclusive_scan_kernel<SpecializationKernelName, 2> kernel_name2;
+  typedef class exclusive_scan_kernel<SpecializationKernelName, 3> kernel_name3;
   OutputT init = 42;
   size_t N = input.size();
   size_t G = 16;
@@ -159,19 +159,24 @@ int main() {
   std::iota(input.begin(), input.end(), 0);
   std::fill(output.begin(), output.end(), 0);
 
-  test(q, input, output, plus<>(), 0);
-  test(q, input, output, minimum<>(), std::numeric_limits<int>::max());
-  test(q, input, output, maximum<>(), std::numeric_limits<int>::lowest());
+  test<class KernelNamePlusV>(q, input, output, plus<>(), 0);
+  test<class KernelNameMinimumV>(q, input, output, minimum<>(),
+                                 std::numeric_limits<int>::max());
+  test<class KernelNameMaximumV>(q, input, output, maximum<>(),
+                                 std::numeric_limits<int>::lowest());
 
-  test(q, input, output, plus<int>(), 0);
-  test(q, input, output, minimum<int>(), std::numeric_limits<int>::max());
-  test(q, input, output, maximum<int>(), std::numeric_limits<int>::lowest());
+  test<class KernelNamePlusI>(q, input, output, plus<int>(), 0);
+  test<class KernelNameMinimumI>(q, input, output, minimum<int>(),
+                                 std::numeric_limits<int>::max());
+  test<class KernelNameMaximumI>(q, input, output, maximum<int>(),
+                                 std::numeric_limits<int>::lowest());
 
 #ifdef SPIRV_1_3
-  test(q, input, output, multiplies<int>(), 1);
-  test(q, input, output, bit_or<int>(), 0);
-  test(q, input, output, bit_xor<int>(), 0);
-  test(q, input, output, bit_and<int>(), ~0);
+  test<class KernelName_VzAPutpBRRJrQPB>(q, input, output, multiplies<int>(),
+                                         1);
+  test<class KernelName_UXdGbr>(q, input, output, bit_or<int>(), 0);
+  test<class KernelName_saYaodNyJknrPW>(q, input, output, bit_xor<int>(), 0);
+  test<class KernelName_GPcuAlvAOjrDyP>(q, input, output, bit_and<int>(), ~0);
 #endif // SPIRV_1_3
 
   std::cout << "Test passed." << std::endl;
diff --git a/sycl/test/group-algorithm/inclusive_scan.cpp b/sycl/test/group-algorithm/inclusive_scan.cpp
index e6fddd1c2d4aa..ea398bf2d0273 100644
--- a/sycl/test/group-algorithm/inclusive_scan.cpp
+++ b/sycl/test/group-algorithm/inclusive_scan.cpp
@@ -24,7 +24,7 @@
 using namespace sycl;
 using namespace sycl::ONEAPI;
 
-template <class BinaryOperation, int TestNumber>
+template <class SpecializationKernelName, int TestNumber>
 class inclusive_scan_kernel;
 
 // std::inclusive_scan isn't implemented yet, so use serial implementation
@@ -44,17 +44,17 @@ OutputIterator inclusive_scan(InputIterator first, InputIterator last,
 }
 } // namespace emu
 
-template <typename InputContainer, typename OutputContainer,
-          class BinaryOperation>
+template <typename SpecializationKernelName, typename InputContainer,
+          typename OutputContainer, class BinaryOperation>
 void test(queue q, InputContainer input, OutputContainer output,
           BinaryOperation binary_op,
           typename OutputContainer::value_type identity) {
   typedef typename InputContainer::value_type InputT;
   typedef typename OutputContainer::value_type OutputT;
-  typedef class inclusive_scan_kernel<BinaryOperation, 0> kernel_name0;
-  typedef class inclusive_scan_kernel<BinaryOperation, 1> kernel_name1;
-  typedef class inclusive_scan_kernel<BinaryOperation, 2> kernel_name2;
-  typedef class inclusive_scan_kernel<BinaryOperation, 3> kernel_name3;
+  typedef class inclusive_scan_kernel<SpecializationKernelName, 0> kernel_name0;
+  typedef class inclusive_scan_kernel<SpecializationKernelName, 1> kernel_name1;
+  typedef class inclusive_scan_kernel<SpecializationKernelName, 2> kernel_name2;
+  typedef class inclusive_scan_kernel<SpecializationKernelName, 3> kernel_name3;
   OutputT init = 42;
   size_t N = input.size();
   size_t G = 16;
@@ -159,19 +159,25 @@ int main() {
   std::iota(input.begin(), input.end(), 0);
   std::fill(output.begin(), output.end(), 0);
 
-  test(q, input, output, plus<>(), 0);
-  test(q, input, output, minimum<>(), std::numeric_limits<int>::max());
-  test(q, input, output, maximum<>(), std::numeric_limits<int>::lowest());
+  test<class KernelNamePlusV>(q, input, output, plus<>(), 0);
+  test<class KernelNameMinimumV>(q, input, output, minimum<>(),
+                                 std::numeric_limits<int>::max());
+  test<class KernelNameMaximumV>(q, input, output, maximum<>(),
+                                 std::numeric_limits<int>::lowest());
 
-  test(q, input, output, plus<int>(), 0);
-  test(q, input, output, minimum<int>(), std::numeric_limits<int>::max());
-  test(q, input, output, maximum<int>(), std::numeric_limits<int>::lowest());
+  test<class KernelNamePlusI>(q, input, output, plus<int>(), 0);
+  test<class KernelNameMinimumI>(q, input, output, minimum<int>(),
+                                 std::numeric_limits<int>::max());
+  test<class KernelNameMaximumI>(q, input, output, maximum<int>(),
+                                 std::numeric_limits<int>::lowest());
 
 #ifdef SPIRV_1_3
-  test(q, input, output, multiplies<int>(), 1);
-  test(q, input, output, bit_or<int>(), 0);
-  test(q, input, output, bit_xor<int>(), 0);
-  test(q, input, output, bit_and<int>(), ~0);
+  test<class KernelName_zMyjxUrBgeUGoxmDwhvJ>(q, input, output,
+                                              multiplies<int>(), 1);
+  test<class KernelName_SljjtroxNRaAXoVnT>(q, input, output, bit_or<int>(), 0);
+  test<class KernelName_yXIZfjwjxQGiPeQAnc>(q, input, output, bit_xor<int>(),
+                                            0);
+  test<class KernelName_xGnAnMYHvqekCk>(q, input, output, bit_and<int>(), ~0);
 #endif // SPIRV_1_3
 
   std::cout << "Test passed." << std::endl;
diff --git a/sycl/test/group-algorithm/reduce.cpp b/sycl/test/group-algorithm/reduce.cpp
index 010a0ce75b2b4..708de23653d2d 100644
--- a/sycl/test/group-algorithm/reduce.cpp
+++ b/sycl/test/group-algorithm/reduce.cpp
@@ -23,17 +23,13 @@
 using namespace sycl;
 using namespace sycl::ONEAPI;
 
-template <class BinaryOperation>
-class reduce_kernel;
-
-template <typename InputContainer, typename OutputContainer,
-          class BinaryOperation>
+template <typename SpecializationKernelName, typename InputContainer,
+          typename OutputContainer, class BinaryOperation>
 void test(queue q, InputContainer input, OutputContainer output,
           BinaryOperation binary_op,
           typename OutputContainer::value_type identity) {
   typedef typename InputContainer::value_type InputT;
   typedef typename OutputContainer::value_type OutputT;
-  typedef class reduce_kernel<BinaryOperation> kernel_name;
   OutputT init = 42;
   size_t N = input.size();
   size_t G = 16;
@@ -44,15 +40,17 @@ void test(queue q, InputContainer input, OutputContainer output,
     q.submit([&](handler &cgh) {
       auto in = in_buf.template get_access<access::mode::read>(cgh);
       auto out = out_buf.template get_access<access::mode::discard_write>(cgh);
-      cgh.parallel_for<kernel_name>(nd_range<1>(G, G), [=](nd_item<1> it) {
-        group<1> g = it.get_group();
-        int lid = it.get_local_id(0);
-        out[0] = reduce(g, in[lid], binary_op);
-        out[1] = reduce(g, in[lid], init, binary_op);
-        out[2] = reduce(g, in.get_pointer(), in.get_pointer() + N, binary_op);
-        out[3] =
-            reduce(g, in.get_pointer(), in.get_pointer() + N, init, binary_op);
-      });
+      cgh.parallel_for<SpecializationKernelName>(
+          nd_range<1>(G, G), [=](nd_item<1> it) {
+            group<1> g = it.get_group();
+            int lid = it.get_local_id(0);
+            out[0] = reduce(g, in[lid], binary_op);
+            out[1] = reduce(g, in[lid], init, binary_op);
+            out[2] =
+                reduce(g, in.get_pointer(), in.get_pointer() + N, binary_op);
+            out[3] = reduce(g, in.get_pointer(), in.get_pointer() + N, init,
+                            binary_op);
+          });
     });
   }
   // std::reduce is not implemented yet, so use std::accumulate instead
@@ -97,19 +95,24 @@ int main() {
   std::iota(input.begin(), input.end(), 0);
   std::fill(output.begin(), output.end(), 0);
 
-  test(q, input, output, plus<>(), 0);
-  test(q, input, output, minimum<>(), std::numeric_limits<int>::max());
-  test(q, input, output, maximum<>(), std::numeric_limits<int>::lowest());
+  test<class KernelNamePlusV>(q, input, output, plus<>(), 0);
+  test<class KernelNameMinimumV>(q, input, output, minimum<>(),
+                                 std::numeric_limits<int>::max());
+  test<class KernelNameMaximumV>(q, input, output, maximum<>(),
+                                 std::numeric_limits<int>::lowest());
 
-  test(q, input, output, plus<int>(), 0);
-  test(q, input, output, minimum<int>(), std::numeric_limits<int>::max());
-  test(q, input, output, maximum<int>(), std::numeric_limits<int>::lowest());
+  test<class KernelNamePlusI>(q, input, output, plus<int>(), 0);
+  test<class KernelNameMinimumI>(q, input, output, minimum<int>(),
+                                 std::numeric_limits<int>::max());
+  test<class KernelNameMaximumI>(q, input, output, maximum<int>(),
+                                 std::numeric_limits<int>::lowest());
 
 #ifdef SPIRV_1_3
-  test(q, input, output, multiplies<int>(), 1);
-  test(q, input, output, bit_or<int>(), 0);
-  test(q, input, output, bit_xor<int>(), 0);
-  test(q, input, output, bit_and<int>(), ~0);
+  test<class KernelName_WonwuUVPUPOTKRKIBtT>(q, input, output,
+                                             multiplies<int>(), 1);
+  test<class KernelName_qYBaJDZTMGkdIwD>(q, input, output, bit_or<int>(), 0);
+  test<class KernelName_eLSFt>(q, input, output, bit_xor<int>(), 0);
+  test<class KernelName_uFhJnxSVhNAiFPTG>(q, input, output, bit_and<int>(), ~0);
 #endif // SPIRV_1_3
 
   std::cout << "Test passed." << std::endl;
diff --git a/sycl/test/reduction/reduction_ctor.cpp b/sycl/test/reduction/reduction_ctor.cpp
index 4828b1dc94535..c10fe74d7643c 100644
--- a/sycl/test/reduction/reduction_ctor.cpp
+++ b/sycl/test/reduction/reduction_ctor.cpp
@@ -10,7 +10,6 @@
 
 using namespace cl::sycl;
 
-
 template <typename T, typename Reduction>
 void test_reducer(Reduction &Redu, T A, T B) {
   typename Reduction::reducer_type Reducer;
@@ -34,12 +33,10 @@ void test_reducer(Reduction &Redu, T Identity, BinaryOperation BOp, T A, T B) {
          "Wrong result of binary operation.");
 }
 
-template <typename T, int Dim, class BinaryOperation>
-class Known;
-template <typename T, int Dim, class BinaryOperation>
-class Unknown;
+template <typename... Ts> class KernelNameGroup;
 
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void testKnown(T Identity, BinaryOperation BOp, T A, T B) {
   buffer<T, 1> ReduBuf(1);
 
@@ -50,17 +47,17 @@ void testKnown(T Identity, BinaryOperation BOp, T A, T B) {
     accessor<T, Dim, access::mode::discard_write, access::target::global_buffer>
         ReduAcc(ReduBuf, CGH);
     auto Redu = ONEAPI::reduction(ReduAcc, BOp);
-    assert(Redu.getIdentity() == Identity &&
-           "Failed getIdentity() check().");
+    assert(Redu.getIdentity() == Identity && "Failed getIdentity() check().");
     test_reducer(Redu, A, B);
     test_reducer(Redu, Identity, BOp, A, B);
 
     // Command group must have at least one task in it. Use an empty one.
-    CGH.single_task<Known<T, Dim, BinaryOperation>>([=]() {});
+    CGH.single_task<SpecializationKernelName>([=]() {});
   });
 }
 
-template <typename T, int Dim, typename KernelName, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void testUnknown(T Identity, BinaryOperation BOp, T A, T B) {
   buffer<T, 1> ReduBuf(1);
   queue Q;
@@ -70,49 +67,61 @@ void testUnknown(T Identity, BinaryOperation BOp, T A, T B) {
     accessor<T, Dim, access::mode::discard_write, access::target::global_buffer>
         ReduAcc(ReduBuf, CGH);
     auto Redu = ONEAPI::reduction(ReduAcc, Identity, BOp);
-    assert(Redu.getIdentity() == Identity &&
-           "Failed getIdentity() check().");
+    assert(Redu.getIdentity() == Identity && "Failed getIdentity() check().");
     test_reducer(Redu, Identity, BOp, A, B);
 
     // Command group must have at least one task in it. Use an empty one.
-    CGH.single_task<KernelName>([=]() {});
+    CGH.single_task<SpecializationKernelName>([=]() {});
   });
 }
 
-template <typename T, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, class BinaryOperation>
 void testBoth(T Identity, BinaryOperation BOp, T A, T B) {
-  testKnown<T, 0>(Identity, BOp, A, B);
-  testKnown<T, 1>(Identity, BOp, A, B);
-  testUnknown<T, 0, Unknown<T, 0, BinaryOperation>>(Identity, BOp, A, B);
-  testUnknown<T, 1, Unknown<T, 1, BinaryOperation>>(Identity, BOp, A, B);
+  testKnown<KernelNameGroup<SpecializationKernelName,
+                            class KernelName_SpronAvHpacKFL>,
+            T, 0>(Identity, BOp, A, B);
+  testKnown<
+      KernelNameGroup<SpecializationKernelName, class KernelName_XFxrYatPJlU>,
+      T, 1>(Identity, BOp, A, B);
+  testUnknown<
+      KernelNameGroup<SpecializationKernelName, class KernelName_oUFYMyQSlL>, T,
+      0>(Identity, BOp, A, B);
+  testUnknown<KernelNameGroup<SpecializationKernelName, class KernelName_Ndbp>,
+              T, 1>(Identity, BOp, A, B);
 }
 
 int main() {
-  testBoth<int>(0, ONEAPI::plus<int>(), 1, 7);
-  testBoth<int>(1, std::multiplies<int>(), 1, 7);
-  testBoth<int>(0, ONEAPI::bit_or<int>(), 1, 8);
-  testBoth<int>(0, ONEAPI::bit_xor<int>(), 7, 3);
-  testBoth<int>(~0, ONEAPI::bit_and<int>(), 7, 3);
-  testBoth<int>((std::numeric_limits<int>::max)(), ONEAPI::minimum<int>(), 7,
-                3);
-  testBoth<int>((std::numeric_limits<int>::min)(), ONEAPI::maximum<int>(), 7,
-                3);
-
-  testBoth<float>(0, ONEAPI::plus<float>(), 1, 7);
-  testBoth<float>(1, std::multiplies<float>(), 1, 7);
-  testBoth<float>(getMaximumFPValue<float>(), ONEAPI::minimum<float>(), 7, 3);
-  testBoth<float>(getMinimumFPValue<float>(), ONEAPI::maximum<float>(), 7, 3);
-
-  testUnknown<CustomVec<float>, 0,
-              Unknown<CustomVec<float>, 0, CustomVecPlus<float>>>(
-      CustomVec<float>(0), CustomVecPlus<float>(), CustomVec<float>(1),
-      CustomVec<float>(7));
-  testUnknown<CustomVec<float>, 1,
-              Unknown<CustomVec<float>, 1, CustomVecPlus<float>>>(
+  testBoth<class KernelName_DpWavJTNjhJtrHmLWt, int>(0, ONEAPI::plus<int>(), 1,
+                                                     7);
+  testBoth<class KernelName_MHRtc, int>(1, std::multiplies<int>(), 1, 7);
+  testBoth<class KernelName_eYhurMyKBZvzctmqwUZ, int>(0, ONEAPI::bit_or<int>(),
+                                                      1, 8);
+  testBoth<class KernelName_DpVPIUBjUMGZEwBFHH, int>(0, ONEAPI::bit_xor<int>(),
+                                                     7, 3);
+  testBoth<class KernelName_vGKFactgrkngMXd, int>(~0, ONEAPI::bit_and<int>(), 7,
+                                                  3);
+  testBoth<class KernelName_GLpknSBxclKWjm, int>(
+      (std::numeric_limits<int>::max)(), ONEAPI::minimum<int>(), 7, 3);
+  testBoth<class KernelName_EvOaOYQ, int>((std::numeric_limits<int>::min)(),
+                                          ONEAPI::maximum<int>(), 7, 3);
+
+  testBoth<class KernelName_iFbcoTtPeDtUEK, float>(0, ONEAPI::plus<float>(), 1,
+                                                   7);
+  testBoth<class KernelName_PEMJanstdNezDSXnP, float>(
+      1, std::multiplies<float>(), 1, 7);
+  testBoth<class KernelName_wOEuftXSjCLpoTOMrYHR, float>(
+      getMaximumFPValue<float>(), ONEAPI::minimum<float>(), 7, 3);
+  testBoth<class KernelName_HzFCIZQKeV, float>(getMinimumFPValue<float>(),
+                                               ONEAPI::maximum<float>(), 7, 3);
+
+  testUnknown<class KernelName_sJOZPgFeiALyqwIWnFP, CustomVec<float>, 0,
+              CustomVecPlus<float>>(CustomVec<float>(0), CustomVecPlus<float>(),
+                                    CustomVec<float>(1), CustomVec<float>(7));
+  testUnknown<class KernelName_jMA, CustomVec<float>, 1>(
       CustomVec<float>(0), CustomVecPlus<float>(), CustomVec<float>(1),
       CustomVec<float>(7));
 
-  testUnknown<int, 0, class BitOrName>(
+  testUnknown<class KernelName_zhF, int, 0>(
       0, [](auto a, auto b) { return a | b; }, 1, 8);
 
   std::cout << "Test passed\n";
diff --git a/sycl/test/reduction/reduction_nd_conditional.cpp b/sycl/test/reduction/reduction_nd_conditional.cpp
index 985f77cbc77f4..9db6fac910809 100644
--- a/sycl/test/reduction/reduction_nd_conditional.cpp
+++ b/sycl/test/reduction/reduction_nd_conditional.cpp
@@ -35,25 +35,16 @@ void initInputData(buffer<T, 1> &InBuf, T &ExpectedOut, T Identity,
   }
 };
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-
-template <typename T>
-struct Vec {
+template <typename T> struct Vec {
   Vec() : X(0), Y(0) {}
   Vec(T X, T Y) : X(X), Y(Y) {}
   Vec(T V) : X(V), Y(V) {}
-  bool operator==(const Vec &P) const {
-    return P.X == X && P.Y == Y;
-  }
-  bool operator!=(const Vec &P) const {
-    return !(*this == P);
-  }
+  bool operator==(const Vec &P) const { return P.X == X && P.Y == Y; }
+  bool operator!=(const Vec &P) const { return !(*this == P); }
   T X;
   T Y;
 };
-template <typename T>
-bool operator==(const Vec<T> &A, const Vec<T> &B) {
+template <typename T> bool operator==(const Vec<T> &A, const Vec<T> &B) {
   return A.X == B.X && A.Y == B.Y;
 }
 template <typename T>
@@ -61,15 +52,13 @@ std::ostream &operator<<(std::ostream &OS, const Vec<T> &P) {
   return OS << "(" << P.X << ", " << P.Y << ")";
 }
 
-template <class T>
-struct VecPlus {
+template <class T> struct VecPlus {
   using P = Vec<T>;
-  P operator()(const P &A, const P &B) const {
-    return P(A.X + B.X, A.Y + B.Y);
-  }
+  P operator()(const P &A, const P &B) const { return P(A.X + B.X, A.Y + B.Y); }
 };
 
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -90,7 +79,7 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           size_t I = NDIt.get_global_linear_id();
           if (I < 2)
@@ -114,10 +103,11 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
 }
 
 int main() {
-  test<int, 0, ONEAPI::plus<int>>(0, 2, 2);
-  test<int, 1, ONEAPI::plus<int>>(0, 7, 7);
-  test<int, 0, ONEAPI::plus<int>>(0, 2, 64);
-  test<short, 1, ONEAPI::plus<short>>(0, 16, 256);
+  test<class KernelName_lAx, int, 0, ONEAPI::plus<int>>(0, 2, 2);
+  test<class KernelName_eVBkBK, int, 1, ONEAPI::plus<int>>(0, 7, 7);
+  test<class KernelName_vMSyszeYKJbaXATnPL, int, 0, ONEAPI::plus<int>>(0, 2,
+                                                                       64);
+  test<class KernelName_UPKnfG, short, 1, ONEAPI::plus<short>>(0, 16, 256);
 
   std::cout << "Test passed\n";
   return 0;
diff --git a/sycl/test/reduction/reduction_nd_ext_type.hpp b/sycl/test/reduction/reduction_nd_ext_type.hpp
index f81a913837d46..4cb9046092c82 100644
--- a/sycl/test/reduction/reduction_nd_ext_type.hpp
+++ b/sycl/test/reduction/reduction_nd_ext_type.hpp
@@ -8,10 +8,8 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-
-template <typename T, int Dim, access::mode Mode, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          access::mode Mode, class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -28,14 +26,13 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
   queue Q;
   Q.submit([&](handler &CGH) {
     auto In = InBuf.template get_access<access::mode::read>(CGH);
-    accessor<T, Dim, Mode, access::target::global_buffer>
-        Out(OutBuf, CGH);
+    accessor<T, Dim, Mode, access::target::global_buffer> Out(OutBuf, CGH);
     auto Redu = ONEAPI::reduction(Out, Identity, BOp);
 
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -44,18 +41,18 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
   // Check correctness.
   auto Out = OutBuf.template get_access<access::mode::read>();
   T ComputedOut = *(Out.get_pointer());
-  T MaxDiff = 3 * std::numeric_limits<T>::epsilon() * std::fabs(ComputedOut + CorrectOut);
+  T MaxDiff = 3 * std::numeric_limits<T>::epsilon() *
+              std::fabs(ComputedOut + CorrectOut);
   if (std::fabs(static_cast<T>(ComputedOut - CorrectOut)) > MaxDiff) {
     std::cout << "NWItems = " << NWItems << ", WGSize = " << WGSize << "\n";
     std::cout << "Computed value: " << ComputedOut
-              << ", Expected value: " << CorrectOut
-              << ", MaxDiff = " << MaxDiff << "\n";
+              << ", Expected value: " << CorrectOut << ", MaxDiff = " << MaxDiff
+              << "\n";
     assert(0 && "Wrong value.");
   }
 }
 
-template <typename T>
-int runTests(const string_class &ExtensionName) {
+template <typename T> int runTests(const string_class &ExtensionName) {
   device D = default_selector().select_device();
   if (!D.is_host() && !D.has_extension(ExtensionName)) {
     std::cout << "Test skipped\n";
@@ -63,20 +60,23 @@ int runTests(const string_class &ExtensionName) {
   }
 
   // Check some less standards WG sizes and corner cases first.
-  test<T, 1, access::mode::read_write, std::multiplies<T>>(0, 4, 4);
-  test<T, 0, access::mode::discard_write, ONEAPI::plus<T>>(0, 4, 64);
+  test<class KernelName_oTh, T, 1, access::mode::read_write,
+       std::multiplies<T>>(0, 4, 4);
+  test<class KernelName_QUQnMARQT, T, 0, access::mode::discard_write,
+       ONEAPI::plus<T>>(0, 4, 64);
 
-  test<T, 0, access::mode::read_write, ONEAPI::minimum<T>>(
-      getMaximumFPValue<T>(), 7, 7);
-  test<T, 1, access::mode::discard_write, ONEAPI::maximum<T>>(
-      getMinimumFPValue<T>(), 7, 7 * 5);
+  test<class KernelName_xGixNo, T, 0, access::mode::read_write,
+       ONEAPI::minimum<T>>(getMaximumFPValue<T>(), 7, 7);
+  test<class KernelName_qXNFw, T, 1, access::mode::discard_write,
+       ONEAPI::maximum<T>>(getMinimumFPValue<T>(), 7, 7 * 5);
 
 #if __cplusplus >= 201402L
-  test<T, 1, access::mode::read_write, ONEAPI::plus<>>(1, 3, 3 * 5);
-  test<T, 1, access::mode::discard_write, ONEAPI::minimum<>>(
-      getMaximumFPValue<T>(), 3, 3);
-  test<T, 0, access::mode::discard_write, ONEAPI::maximum<>>(
-      getMinimumFPValue<T>(), 3, 3);
+  test<class KernelName_lXdWtzANdDcvm, T, 1, access::mode::read_write,
+       ONEAPI::plus<>>(1, 3, 3 * 5);
+  test<class KernelName_FDQalsDxmbi, T, 1, access::mode::discard_write,
+       ONEAPI::minimum<>>(getMaximumFPValue<T>(), 3, 3);
+  test<class KernelName_TaNRRxDRXbzYrFImPYC, T, 0, access::mode::discard_write,
+       ONEAPI::maximum<>>(getMinimumFPValue<T>(), 3, 3);
 #endif // __cplusplus >= 201402L
 
   std::cout << "Test passed\n";
diff --git a/sycl/test/reduction/reduction_nd_s0_dw.cpp b/sycl/test/reduction/reduction_nd_s0_dw.cpp
index 8b900a3a1fd9a..0a4a9032a3b30 100644
--- a/sycl/test/reduction/reduction_nd_s0_dw.cpp
+++ b/sycl/test/reduction/reduction_nd_s0_dw.cpp
@@ -16,10 +16,8 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -40,7 +38,7 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -59,36 +57,44 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
 
 int main() {
   // Check some less standards WG sizes and corner cases first.
-  test<int, 0, ONEAPI::plus<int>>(0, 2, 2);
-  test<int, 0, ONEAPI::plus<int>>(0, 7, 7);
-  test<int, 0, ONEAPI::plus<int>>(0, 9, 18);
-  test<int, 0, ONEAPI::plus<int>>(0, 49, 49 * 5);
+  test<class KernelName_TeSOazfnXqV, int, 0, ONEAPI::plus<int>>(0, 2, 2);
+  test<class KernelName_sDrWF, int, 0, ONEAPI::plus<int>>(0, 7, 7);
+  test<class KernelName_WClNhs, int, 0, ONEAPI::plus<int>>(0, 9, 18);
+  test<class KernelName_dGBzKHqZ, int, 0, ONEAPI::plus<int>>(0, 49, 49 * 5);
 
   // Try some power-of-two work-group sizes.
-  test<int, 0, ONEAPI::plus<int>>(0, 2, 64);
-  test<int, 0, ONEAPI::plus<int>>(0, 4, 64);
-  test<int, 0, ONEAPI::plus<int>>(0, 8, 128);
-  test<int, 0, ONEAPI::plus<int>>(0, 16, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 32, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 64, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 128, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 256, 256);
+  test<class KernelName_BBFqAKecrI, int, 0, ONEAPI::plus<int>>(0, 2, 64);
+  test<class KernelName_HMUbvvJOFTCETQHk, int, 0, ONEAPI::plus<int>>(0, 4, 64);
+  test<class KernelName_JocyLVjSXVPjdkezas, int, 0, ONEAPI::plus<int>>(0, 8,
+                                                                       128);
+  test<class KernelName_vXMabsyZtboaYDgkmuW, int, 0, ONEAPI::plus<int>>(0, 16,
+                                                                        256);
+  test<class KernelName_jmOMSDBPkCezwz, int, 0, ONEAPI::plus<int>>(0, 32, 256);
+  test<class KernelName_BZD, int, 0, ONEAPI::plus<int>>(0, 64, 256);
+  test<class KernelName_xAMTrtueBCmu, int, 0, ONEAPI::plus<int>>(0, 128, 256);
+  test<class KernelName_iIqMmgijPHeP, int, 0, ONEAPI::plus<int>>(0, 256, 256);
 
   // Check with various operations.
-  test<int, 0, std::multiplies<int>>(1, 8, 256);
-  test<int, 0, ONEAPI::bit_or<int>>(0, 8, 256);
-  test<int, 0, ONEAPI::bit_xor<int>>(0, 8, 256);
-  test<int, 0, ONEAPI::bit_and<int>>(~0, 8, 256);
-  test<int, 0, ONEAPI::minimum<int>>((std::numeric_limits<int>::max)(), 8, 256);
-  test<int, 0, ONEAPI::maximum<int>>((std::numeric_limits<int>::min)(), 8, 256);
+  test<class KernelName_JbXMe, int, 0, std::multiplies<int>>(1, 8, 256);
+  test<class KernelName_yxrYAlH, int, 0, ONEAPI::bit_or<int>>(0, 8, 256);
+  test<class KernelName_bclQP, int, 0, ONEAPI::bit_xor<int>>(0, 8, 256);
+  test<class KernelName_SEfBIfWrrGb, int, 0, ONEAPI::bit_and<int>>(~0, 8, 256);
+  test<class KernelName_dVCBKeW, int, 0, ONEAPI::minimum<int>>(
+      (std::numeric_limits<int>::max)(), 8, 256);
+  test<class KernelName_kFuGbwFvu, int, 0, ONEAPI::maximum<int>>(
+      (std::numeric_limits<int>::min)(), 8, 256);
 
   // Check with various types.
-  test<float, 0, std::multiplies<float>>(1, 8, 256);
-  test<float, 0, ONEAPI::minimum<float>>(getMaximumFPValue<float>(), 8, 256);
-  test<float, 0, ONEAPI::maximum<float>>(getMinimumFPValue<float>(), 8, 256);
+  test<class KernelName_UjmZVKjKReluws, float, 0, std::multiplies<float>>(1, 8,
+                                                                          256);
+  test<class KernelName_OszhECIDUagcinKGeWO, float, 0, ONEAPI::minimum<float>>(
+      getMaximumFPValue<float>(), 8, 256);
+  test<class KernelName_LpCicWZckILZRxZP, float, 0, ONEAPI::maximum<float>>(
+      getMinimumFPValue<float>(), 8, 256);
 
   // Check with CUSTOM type.
-  test<CustomVec<long long>, 0, CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
+  test<class KernelName_puwIibWWpn, CustomVec<long long>, 0,
+       CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
 
   std::cout << "Test passed\n";
   return 0;
diff --git a/sycl/test/reduction/reduction_nd_s0_rw.cpp b/sycl/test/reduction/reduction_nd_s0_rw.cpp
index 029458942390a..d346016ae4bfd 100644
--- a/sycl/test/reduction/reduction_nd_s0_rw.cpp
+++ b/sycl/test/reduction/reduction_nd_s0_rw.cpp
@@ -16,10 +16,8 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -42,7 +40,7 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -61,36 +59,47 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
 
 int main() {
   // Check some less standards WG sizes and corner cases first.
-  test<int, 0, ONEAPI::plus<int>>(0, 2, 2);
-  test<int, 0, ONEAPI::plus<int>>(0, 7, 7);
-  test<int, 0, ONEAPI::plus<int>>(0, 9, 18);
-  test<int, 0, ONEAPI::plus<int>>(0, 49, 49 * 5);
+  test<class KernelName_oXfFQUctpKif, int, 0, ONEAPI::plus<int>>(0, 2, 2);
+  test<class KernelName_YnoUqtntrJ, int, 0, ONEAPI::plus<int>>(0, 7, 7);
+  test<class KernelName_hfCsGycSpg, int, 0, ONEAPI::plus<int>>(0, 9, 18);
+  test<class KernelName_OtxLfwQuVfGAUEXMIs, int, 0, ONEAPI::plus<int>>(0, 49,
+                                                                       49 * 5);
 
   // Try some power-of-two work-group sizes.
-  test<int, 0, ONEAPI::plus<int>>(0, 2, 64);
-  test<int, 0, ONEAPI::plus<int>>(0, 4, 64);
-  test<int, 0, ONEAPI::plus<int>>(0, 8, 128);
-  test<int, 0, ONEAPI::plus<int>>(0, 16, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 32, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 64, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 128, 256);
-  test<int, 0, ONEAPI::plus<int>>(0, 256, 256);
+  test<class KernelName_lMJpe, int, 0, ONEAPI::plus<int>>(0, 2, 64);
+  test<class KernelName_jikSUrEuFUxYGGfXNet, int, 0, ONEAPI::plus<int>>(0, 4,
+                                                                        64);
+  test<class KernelName_cByxQmddzgEGUeboDDbO, int, 0, ONEAPI::plus<int>>(0, 8,
+                                                                         128);
+  test<class KernelName_pggyS, int, 0, ONEAPI::plus<int>>(0, 16, 256);
+  test<class KernelName_CWZouFJ, int, 0, ONEAPI::plus<int>>(0, 32, 256);
+  test<class KernelName_IjuYfJxWZdaVMdE, int, 0, ONEAPI::plus<int>>(0, 64, 256);
+  test<class KernelName_tcKhlzfhg, int, 0, ONEAPI::plus<int>>(0, 128, 256);
+  test<class KernelName_eWffIBPdwvvUwPFZFeG, int, 0, ONEAPI::plus<int>>(0, 256,
+                                                                        256);
 
   // Check with various operations.
-  test<int, 0, std::multiplies<int>>(1, 8, 256);
-  test<int, 0, ONEAPI::bit_or<int>>(0, 8, 256);
-  test<int, 0, ONEAPI::bit_xor<int>>(0, 8, 256);
-  test<int, 0, ONEAPI::bit_and<int>>(~0, 8, 256);
-  test<int, 0, ONEAPI::minimum<int>>((std::numeric_limits<int>::max)(), 8, 256);
-  test<int, 0, ONEAPI::maximum<int>>((std::numeric_limits<int>::min)(), 8, 256);
+  test<class KernelName_rWAaJsLUS, int, 0, std::multiplies<int>>(1, 8, 256);
+  test<class KernelName_jZoWyBoLxybjrbk, int, 0, ONEAPI::bit_or<int>>(0, 8,
+                                                                      256);
+  test<class KernelName_jdixaAPjypPSGPCbXIw, int, 0, ONEAPI::bit_xor<int>>(0, 8,
+                                                                           256);
+  test<class KernelName_FNGt, int, 0, ONEAPI::bit_and<int>>(~0, 8, 256);
+  test<class KernelName_KPtKKagKhZzwSibEl, int, 0, ONEAPI::minimum<int>>(
+      (std::numeric_limits<int>::max)(), 8, 256);
+  test<class KernelName_xdNhx, int, 0, ONEAPI::maximum<int>>(
+      (std::numeric_limits<int>::min)(), 8, 256);
 
   // Check with various types.
-  test<float, 0, std::multiplies<float>>(1, 8, 256);
-  test<float, 0, ONEAPI::minimum<float>>(getMaximumFPValue<float>(), 8, 256);
-  test<float, 0, ONEAPI::maximum<float>>(getMinimumFPValue<float>(), 8, 256);
+  test<class KernelName_IxDwu, float, 0, std::multiplies<float>>(1, 8, 256);
+  test<class KernelName_NpYzX, float, 0, ONEAPI::minimum<float>>(
+      getMaximumFPValue<float>(), 8, 256);
+  test<class KernelName_dofjVNlXWgJ, float, 0, ONEAPI::maximum<float>>(
+      getMinimumFPValue<float>(), 8, 256);
 
   // Check with CUSTOM type.
-  test<CustomVec<long long>, 0, CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
+  test<class KernelName_XrOnrVnB, CustomVec<long long>, 0,
+       CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
 
   std::cout << "Test passed\n";
   return 0;
diff --git a/sycl/test/reduction/reduction_nd_s1_dw.cpp b/sycl/test/reduction/reduction_nd_s1_dw.cpp
index 7cc975e261dc2..df31961a1c908 100644
--- a/sycl/test/reduction/reduction_nd_s1_dw.cpp
+++ b/sycl/test/reduction/reduction_nd_s1_dw.cpp
@@ -17,10 +17,8 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -41,7 +39,7 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -60,36 +58,48 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
 
 int main() {
   // Check some less standards WG sizes and corner cases first.
-  test<int, 1, ONEAPI::plus<int>>(0, 2, 2);
-  test<int, 1, ONEAPI::plus<int>>(0, 7, 7);
-  test<int, 1, ONEAPI::plus<int>>(0, 9, 18);
-  test<int, 1, ONEAPI::plus<int>>(0, 49, 49 * 5);
+  test<class KernelName_YvZmtZPNMqkXPfNQEqtU, int, 1, ONEAPI::plus<int>>(0, 2,
+                                                                         2);
+  test<class KernelName_jxkTUxpuBScJxMzUuVcO, int, 1, ONEAPI::plus<int>>(0, 7,
+                                                                         7);
+  test<class KernelName_ySnvYMbreHXDCwJSbSaH, int, 1, ONEAPI::plus<int>>(0, 9,
+                                                                         18);
+  test<class KernelName_UjxromGtR, int, 1, ONEAPI::plus<int>>(0, 49, 49 * 5);
 
   // Try some power-of-two work-group sizes.
-  test<int, 1, ONEAPI::plus<int>>(0, 2, 64);
-  test<int, 1, ONEAPI::plus<int>>(0, 4, 64);
-  test<int, 1, ONEAPI::plus<int>>(0, 8, 128);
-  test<int, 1, ONEAPI::plus<int>>(0, 16, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 32, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 64, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 128, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 256, 256);
+  test<class KernelName_EnupfpikIEjljnjxsR, int, 1, ONEAPI::plus<int>>(0, 2,
+                                                                       64);
+  test<class KernelName_rjRdxjtMBBG, int, 1, ONEAPI::plus<int>>(0, 4, 64);
+  test<class KernelName_EpopkaQNRW, int, 1, ONEAPI::plus<int>>(0, 8, 128);
+  test<class KernelName_OcP, int, 1, ONEAPI::plus<int>>(0, 16, 256);
+  test<class KernelName_lewnPBkCvTXJYXfNQs, int, 1, ONEAPI::plus<int>>(0, 32,
+                                                                       256);
+  test<class KernelName_sEtIX, int, 1, ONEAPI::plus<int>>(0, 64, 256);
+  test<class KernelName_yyXXOSx, int, 1, ONEAPI::plus<int>>(0, 128, 256);
+  test<class KernelName_BebxPvIBvukTydfg, int, 1, ONEAPI::plus<int>>(0, 256,
+                                                                     256);
 
   // Check with various operations.
-  test<int, 1, std::multiplies<int>>(1, 8, 256);
-  test<int, 1, ONEAPI::bit_or<int>>(0, 8, 256);
-  test<int, 1, ONEAPI::bit_xor<int>>(0, 8, 256);
-  test<int, 1, ONEAPI::bit_and<int>>(~0, 8, 256);
-  test<int, 1, ONEAPI::minimum<int>>((std::numeric_limits<int>::max)(), 8, 256);
-  test<int, 1, ONEAPI::maximum<int>>((std::numeric_limits<int>::min)(), 8, 256);
+  test<class KernelName_LaYCRJkYwJUzM, int, 1, std::multiplies<int>>(1, 8, 256);
+  test<class KernelName_rRbqrnaCoinW, int, 1, ONEAPI::bit_or<int>>(0, 8, 256);
+  test<class KernelName_WSadjhrpTq, int, 1, ONEAPI::bit_xor<int>>(0, 8, 256);
+  test<class KernelName_OigvbFHsl, int, 1, ONEAPI::bit_and<int>>(~0, 8, 256);
+  test<class KernelName_ZHcNbu, int, 1, ONEAPI::minimum<int>>(
+      (std::numeric_limits<int>::max)(), 8, 256);
+  test<class KernelName_JzbhkW, int, 1, ONEAPI::maximum<int>>(
+      (std::numeric_limits<int>::min)(), 8, 256);
 
   // Check with various types.
-  test<float, 1, std::multiplies<float>>(1, 8, 256);
-  test<float, 1, ONEAPI::minimum<float>>(getMaximumFPValue<float>(), 8, 256);
-  test<float, 1, ONEAPI::maximum<float>>(getMinimumFPValue<float>(), 8, 256);
+  test<class KernelName_XeQbNSZBWhbf, float, 1, std::multiplies<float>>(1, 8,
+                                                                        256);
+  test<class KernelName_Otl, float, 1, ONEAPI::minimum<float>>(
+      getMaximumFPValue<float>(), 8, 256);
+  test<class KernelName_KhyYgqwIgLKroAzjr, float, 1, ONEAPI::maximum<float>>(
+      getMinimumFPValue<float>(), 8, 256);
 
   // Check with CUSTOM type.
-  test<CustomVec<long long>, 1, CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
+  test<class KernelName_VzSVAWkAmHq, CustomVec<long long>, 1,
+       CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
 
   std::cout << "Test passed\n";
   return 0;
diff --git a/sycl/test/reduction/reduction_nd_s1_rw.cpp b/sycl/test/reduction/reduction_nd_s1_rw.cpp
index 2c8f6a8343e83..ec7044f1c12f8 100644
--- a/sycl/test/reduction/reduction_nd_s1_rw.cpp
+++ b/sycl/test/reduction/reduction_nd_s1_rw.cpp
@@ -17,10 +17,8 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -43,7 +41,7 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -62,36 +60,45 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
 
 int main() {
   // Check some less standards WG sizes and corner cases first.
-  test<int, 1, ONEAPI::plus<int>>(0, 2, 2);
-  test<int, 1, ONEAPI::plus<int>>(0, 7, 7);
-  test<int, 1, ONEAPI::plus<int>>(0, 9, 18);
-  test<int, 1, ONEAPI::plus<int>>(0, 49, 49 * 5);
+  test<class KernelName_KXo, int, 1, ONEAPI::plus<int>>(0, 2, 2);
+  test<class KernelName_bznJZlALYJ, int, 1, ONEAPI::plus<int>>(0, 7, 7);
+  test<class KernelName_rpv, int, 1, ONEAPI::plus<int>>(0, 9, 18);
+  test<class KernelName_vLBXMFYkqbrgegKkf, int, 1, ONEAPI::plus<int>>(0, 49,
+                                                                      49 * 5);
 
   // Try some power-of-two work-group sizes.
-  test<int, 1, ONEAPI::plus<int>>(0, 2, 64);
-  test<int, 1, ONEAPI::plus<int>>(0, 4, 64);
-  test<int, 1, ONEAPI::plus<int>>(0, 8, 128);
-  test<int, 1, ONEAPI::plus<int>>(0, 16, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 32, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 64, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 128, 256);
-  test<int, 1, ONEAPI::plus<int>>(0, 256, 256);
+  test<class KernelName_UfAE, int, 1, ONEAPI::plus<int>>(0, 2, 64);
+  test<class KernelName_JAuydtGTPKjMyKoFvN, int, 1, ONEAPI::plus<int>>(0, 4,
+                                                                       64);
+  test<class KernelName_llgFdNLtCm, int, 1, ONEAPI::plus<int>>(0, 8, 128);
+  test<class KernelName_YdE, int, 1, ONEAPI::plus<int>>(0, 16, 256);
+  test<class KernelName_OIL, int, 1, ONEAPI::plus<int>>(0, 32, 256);
+  test<class KernelName_PciECIxEoUIymqnyYiq, int, 1, ONEAPI::plus<int>>(0, 64,
+                                                                        256);
+  test<class KernelName_oqnGqZmfsZpGYmVOY, int, 1, ONEAPI::plus<int>>(0, 128,
+                                                                      256);
+  test<class KernelName_VxwwptlAZpflz, int, 1, ONEAPI::plus<int>>(0, 256, 256);
 
   // Check with various operations.
-  test<int, 1, std::multiplies<int>>(1, 8, 256);
-  test<int, 1, ONEAPI::bit_or<int>>(0, 8, 256);
-  test<int, 1, ONEAPI::bit_xor<int>>(0, 8, 256);
-  test<int, 1, ONEAPI::bit_and<int>>(~0, 8, 256);
-  test<int, 1, ONEAPI::minimum<int>>((std::numeric_limits<int>::max)(), 8, 256);
-  test<int, 1, ONEAPI::maximum<int>>((std::numeric_limits<int>::min)(), 8, 256);
+  test<class KernelName_GIjawXYajX, int, 1, std::multiplies<int>>(1, 8, 256);
+  test<class KernelName_jOm, int, 1, ONEAPI::bit_or<int>>(0, 8, 256);
+  test<class KernelName_GjfldZIgGoaP, int, 1, ONEAPI::bit_xor<int>>(0, 8, 256);
+  test<class KernelName_rtmiZQvIVAHj, int, 1, ONEAPI::bit_and<int>>(~0, 8, 256);
+  test<class KernelName_vsFbwaoREC, int, 1, ONEAPI::minimum<int>>(
+      (std::numeric_limits<int>::max)(), 8, 256);
+  test<class KernelName_rHeZYARRF, int, 1, ONEAPI::maximum<int>>(
+      (std::numeric_limits<int>::min)(), 8, 256);
 
   // Check with various types.
-  test<float, 1, std::multiplies<float>>(1, 8, 256);
-  test<float, 1, ONEAPI::minimum<float>>(getMaximumFPValue<float>(), 1, 16);
-  test<float, 1, ONEAPI::maximum<float>>(getMinimumFPValue<float>(), 8, 256);
+  test<class KernelName_BkpSVeNxs, float, 1, std::multiplies<float>>(1, 8, 256);
+  test<class KernelName_tDQManTv, float, 1, ONEAPI::minimum<float>>(
+      getMaximumFPValue<float>(), 1, 16);
+  test<class KernelName_lDQXQiJveKkXxjBIZ, float, 1, ONEAPI::maximum<float>>(
+      getMinimumFPValue<float>(), 8, 256);
 
   // Check with CUSTOM type.
-  test<CustomVec<long long>, 1, CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
+  test<class KernelName_tQeAgyjhLaAwt, CustomVec<long long>, 1,
+       CustomVecPlus<long long>>(CustomVec<long long>(0), 8, 256);
 
   std::cout << "Test passed\n";
   return 0;
diff --git a/sycl/test/reduction/reduction_placeholder.cpp b/sycl/test/reduction/reduction_placeholder.cpp
index 77633992ea2df..b0ce9ddfa88b8 100644
--- a/sycl/test/reduction/reduction_placeholder.cpp
+++ b/sycl/test/reduction/reduction_placeholder.cpp
@@ -19,10 +19,8 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
   // Initialize.
   T CorrectOut;
@@ -34,9 +32,9 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
 
   (OutBuf.template get_access<access::mode::write>())[0] = Identity;
 
-  auto Out = accessor<T, Dim, access::mode::read_write,
-                      access::target::global_buffer,
-                      access::placeholder::true_t>(OutBuf);
+  auto Out =
+      accessor<T, Dim, access::mode::read_write, access::target::global_buffer,
+               access::placeholder::true_t>(OutBuf);
   // Compute.
   queue Q;
   Q.submit([&](handler &CGH) {
@@ -46,7 +44,7 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -65,21 +63,26 @@ void test(T Identity, size_t WGSize, size_t NWItems) {
 
 int main() {
   // fast atomics and fast reduce
-  test<int, 1, ONEAPI::plus<int>>(0, 49, 49 * 5);
-  test<int, 0, ONEAPI::plus<int>>(0, 8, 8);
+  test<class KernelName_LpplYqDbNN, int, 1, ONEAPI::plus<int>>(0, 49, 49 * 5);
+  test<class KernelName_FlDEESAfXYXiBZhnEDQ, int, 0, ONEAPI::plus<int>>(0, 8,
+                                                                        8);
 
   // fast atomics
-  test<int, 0, ONEAPI::bit_or<int>>(0, 7, 7 * 3);
-  test<int, 1, ONEAPI::bit_or<int>>(0, 4, 128);
+  test<class KernelName_caKErpdwXzEsGGkr, int, 0, ONEAPI::bit_or<int>>(0, 7,
+                                                                       7 * 3);
+  test<class KernelName_YbnKY, int, 1, ONEAPI::bit_or<int>>(0, 4, 128);
 
   // fast reduce
-  test<float, 1, ONEAPI::minimum<float>>(getMaximumFPValue<float>(), 5, 5 * 7);
-  test<float, 0, ONEAPI::maximum<float>>(getMinimumFPValue<float>(), 4, 128);
+  test<class KernelName_JQuAndqdovQbAHmVLm, float, 1, ONEAPI::minimum<float>>(
+      getMaximumFPValue<float>(), 5, 5 * 7);
+  test<class KernelName_MBbbTWwSc, float, 0, ONEAPI::maximum<float>>(
+      getMinimumFPValue<float>(), 4, 128);
 
   // generic algorithm
-  test<int, 0, std::multiplies<int>>(1, 7, 7 * 5);
-  test<int, 1, std::multiplies<int>>(1, 8, 16);
-  test<CustomVec<short>, 0, CustomVecPlus<short>>(CustomVec<short>(0), 8, 8 * 3);
+  test<class KernelName_WpNdTbTtYt, int, 0, std::multiplies<int>>(1, 7, 7 * 5);
+  test<class KernelName_yAwH, int, 1, std::multiplies<int>>(1, 8, 16);
+  test<class KernelName_BNuHxeewzfXATi, CustomVec<short>, 0,
+       CustomVecPlus<short>>(CustomVec<short>(0), 8, 8 * 3);
 
   std::cout << "Test passed\n";
   return 0;
diff --git a/sycl/test/reduction/reduction_transparent.cpp b/sycl/test/reduction/reduction_transparent.cpp
index dea789b395401..5c7608b8930ab 100644
--- a/sycl/test/reduction/reduction_transparent.cpp
+++ b/sycl/test/reduction/reduction_transparent.cpp
@@ -19,14 +19,12 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeIdClass;
-template <typename T, int Dim, class BinaryOperation>
-class SomeNoIdClass;
+template <typename... Ts> class KernelNameGroup;
 
 // Checks reductions initialized with transparent functor and explicitly set
 // identity value.
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void testId(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -46,7 +44,7 @@ void testId(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeIdClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, ONEAPI::reduction(Out, Identity, BOp),
         [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
@@ -67,7 +65,8 @@ void testId(T Identity, size_t WGSize, size_t NWItems) {
 // Checks reductions initialized with transparent functor and identity
 // value not explicitly specified. The parameter 'Identity' is passed here
 // only to pre-initialize input data correctly.
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void testNoId(T Identity, size_t WGSize, size_t NWItems) {
   buffer<T, 1> InBuf(NWItems);
   buffer<T, 1> OutBuf(1);
@@ -87,7 +86,7 @@ void testNoId(T Identity, size_t WGSize, size_t NWItems) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeNoIdClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<SpecializationKernelName>(
         NDRange, ONEAPI::reduction(Out, BOp), [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -104,18 +103,26 @@ void testNoId(T Identity, size_t WGSize, size_t NWItems) {
   }
 }
 
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems) {
-  testId<T, Dim, BinaryOperation>(Identity, WGSize, NWItems);
-  testNoId<T, Dim, BinaryOperation>(Identity, WGSize, NWItems);
+  testId<KernelNameGroup<SpecializationKernelName,
+                         class KernelName_ObjsWYkZuXCCtNW>,
+         T, Dim, BinaryOperation>(Identity, WGSize, NWItems);
+  testNoId<KernelNameGroup<SpecializationKernelName,
+                           class KernelName_WFtswXpcLpzOBO>,
+           T, Dim, BinaryOperation>(Identity, WGSize, NWItems);
 }
 
 int main() {
 #if __cplusplus >= 201402L
-  test<float, 0, ONEAPI::maximum<>>(getMinimumFPValue<float>(), 7, 7 * 5);
-  test<signed char, 0, ONEAPI::plus<>>(0, 7, 49);
-  test<unsigned char, 1, std::multiplies<>>(1, 4, 16);
-  test<unsigned short, 0, ONEAPI::plus<>>(0, 1, 512 + 32);
+  test<class KernelName_slumazIfW, float, 0, ONEAPI::maximum<>>(
+      getMinimumFPValue<float>(), 7, 7 * 5);
+  test<class KernelName_XtRLKzVaIuL, signed char, 0, ONEAPI::plus<>>(0, 7, 49);
+  test<class KernelName_adpasoZLtoLyZcczwrkV, unsigned char, 1,
+       std::multiplies<>>(1, 4, 16);
+  test<class KernelName_BZDXCHzCBhBb, unsigned short, 0, ONEAPI::plus<>>(
+      0, 1, 512 + 32);
 #endif // __cplusplus >= 201402L
 
   std::cout << "Test passed\n";
diff --git a/sycl/test/reduction/reduction_usm.cpp b/sycl/test/reduction/reduction_usm.cpp
index 0ada4c515b615..d3d96b2cbcaa7 100644
--- a/sycl/test/reduction/reduction_usm.cpp
+++ b/sycl/test/reduction/reduction_usm.cpp
@@ -19,12 +19,10 @@
 
 using namespace cl::sycl;
 
-template <typename T, int Dim, class BinaryOperation>
-class SomeClass;
-template <typename T, int Dim, class BinaryOperation>
-class Copy1;
+template <typename... Ts> class KernelNameGroup;
 
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void test(T Identity, size_t WGSize, size_t NWItems, usm::alloc AllocType) {
   queue Q;
   auto Dev = Q.get_device();
@@ -44,9 +42,9 @@ void test(T Identity, size_t WGSize, size_t NWItems, usm::alloc AllocType) {
     return;
   if (AllocType == usm::alloc::device) {
     event E = Q.submit([&](handler &CGH) {
-      CGH.single_task<class Copy1<T, Dim, BinaryOperation>>([=]() {
-        *ReduVarPtr = Identity;
-      });
+      CGH.single_task<KernelNameGroup<SpecializationKernelName,
+                                      class KernelName_nCGedyQcDjVZG>>(
+          [=]() { *ReduVarPtr = Identity; });
     });
     E.wait();
   } else {
@@ -67,7 +65,8 @@ void test(T Identity, size_t WGSize, size_t NWItems, usm::alloc AllocType) {
     range<1> GlobalRange(NWItems);
     range<1> LocalRange(WGSize);
     nd_range<1> NDRange(GlobalRange, LocalRange);
-    CGH.parallel_for<SomeClass<T, Dim, BinaryOperation>>(
+    CGH.parallel_for<KernelNameGroup<SpecializationKernelName,
+                                     class KernelName_QhyGIsZzTKcB>>(
         NDRange, Redu, [=](nd_item<1> NDIt, auto &Sum) {
           Sum.combine(In[NDIt.get_global_linear_id()]);
         });
@@ -97,32 +96,41 @@ void test(T Identity, size_t WGSize, size_t NWItems, usm::alloc AllocType) {
   free(ReduVarPtr, Q.get_context());
 }
 
-template <typename T, int Dim, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, int Dim,
+          class BinaryOperation>
 void testUSM(T Identity, size_t WGSize, size_t NWItems) {
-  test<T, Dim, BinaryOperation>(Identity, WGSize, NWItems, usm::alloc::shared);
-  test<T, Dim, BinaryOperation>(Identity, WGSize, NWItems, usm::alloc::host);
-  test<T, Dim, BinaryOperation>(Identity, WGSize, NWItems, usm::alloc::device);
+  test<KernelNameGroup<SpecializationKernelName, class KernelName_iIib>, T, Dim,
+       BinaryOperation>(Identity, WGSize, NWItems, usm::alloc::shared);
+  test<KernelNameGroup<SpecializationKernelName, class KernelName_ZApfu>, T,
+       Dim, BinaryOperation>(Identity, WGSize, NWItems, usm::alloc::host);
+  test<KernelNameGroup<SpecializationKernelName, class KernelName_vEkbC>, T,
+       Dim, BinaryOperation>(Identity, WGSize, NWItems, usm::alloc::device);
 }
 
 int main() {
   // fast atomics and fast reduce
-  testUSM<int, 1, ONEAPI::plus<int>>(0, 49, 49 * 5);
-  testUSM<int, 0, ONEAPI::plus<int>>(0, 8, 128);
+  testUSM<class KernelName_ZiHgIpkuqwxFSU, int, 1, ONEAPI::plus<int>>(0, 49,
+                                                                      49 * 5);
+  testUSM<class KernelName_CJwo, int, 0, ONEAPI::plus<int>>(0, 8, 128);
 
   // fast atomics
-  testUSM<int, 0, ONEAPI::bit_or<int>>(0, 7, 7 * 3);
-  testUSM<int, 1, ONEAPI::bit_or<int>>(0, 4, 128);
+  testUSM<class KernelName_EJCJkOXyeXMGswJ, int, 0, ONEAPI::bit_or<int>>(0, 7,
+                                                                         7 * 3);
+  testUSM<class KernelName_UyTaqkIExBLbTK, int, 1, ONEAPI::bit_or<int>>(0, 4,
+                                                                        128);
 
   // fast reduce
-  testUSM<float, 1, ONEAPI::minimum<float>>(getMaximumFPValue<float>(), 5,
-                                            5 * 7);
-  testUSM<float, 0, ONEAPI::maximum<float>>(getMinimumFPValue<float>(), 4, 128);
+  testUSM<class KernelName_LUzMqQwFnsozwsg, float, 1, ONEAPI::minimum<float>>(
+      getMaximumFPValue<float>(), 5, 5 * 7);
+  testUSM<class KernelName_LGBVwsskb, float, 0, ONEAPI::maximum<float>>(
+      getMinimumFPValue<float>(), 4, 128);
 
   // generic algorithm
-  testUSM<int, 0, std::multiplies<int>>(1, 7, 7 * 5);
-  testUSM<int, 1, std::multiplies<int>>(1, 8, 16);
-  testUSM<CustomVec<short>, 0, CustomVecPlus<short>>(
-      CustomVec<short>(0), 8, 8 * 3);
+  testUSM<class KernelName_Jvshu, int, 0, std::multiplies<int>>(1, 7, 7 * 5);
+  testUSM<class KernelName_cOhfYypvvEfQPIpzrUeV, int, 1, std::multiplies<int>>(
+      1, 8, 16);
+  testUSM<class KernelName_VKPjwVpUPRf, CustomVec<short>, 0,
+          CustomVecPlus<short>>(CustomVec<short>(0), 8, 8 * 3);
 
   std::cout << "Test passed\n";
   return 0;
diff --git a/sycl/test/sub_group/generic-shuffle.cpp b/sycl/test/sub_group/generic-shuffle.cpp
index 786a9b57a0ec2..3363e44d88d8c 100644
--- a/sycl/test/sub_group/generic-shuffle.cpp
+++ b/sycl/test/sub_group/generic-shuffle.cpp
@@ -25,7 +25,7 @@ template <typename T> class pointer_kernel;
 
 using namespace cl::sycl;
 
-template <typename T>
+template <typename SpecializationKernelName, typename T>
 void check_pointer(queue &Queue, size_t G = 256, size_t L = 64) {
   try {
     nd_range<1> NdRange(G, L);
@@ -42,29 +42,30 @@ void check_pointer(queue &Queue, size_t G = 256, size_t L = 64) {
       auto acc_xor = buf_xor.template get_access<access::mode::read_write>(cgh);
       auto sgsizeacc = sgsizebuf.get_access<access::mode::read_write>(cgh);
 
-      cgh.parallel_for<pointer_kernel<T>>(NdRange, [=](nd_item<1> NdItem) {
-        ONEAPI::sub_group SG = NdItem.get_sub_group();
-        uint32_t wggid = NdItem.get_global_id(0);
-        uint32_t sgid = SG.get_group_id().get(0);
-        if (wggid == 0)
-          sgsizeacc[0] = SG.get_max_local_range()[0];
+      cgh.parallel_for<SpecializationKernelName>(
+          NdRange, [=](nd_item<1> NdItem) {
+            ONEAPI::sub_group SG = NdItem.get_sub_group();
+            uint32_t wggid = NdItem.get_global_id(0);
+            uint32_t sgid = SG.get_group_id().get(0);
+            if (wggid == 0)
+              sgsizeacc[0] = SG.get_max_local_range()[0];
 
-        T *ptr = static_cast<T *>(0x0) + wggid;
+            T *ptr = static_cast<T *>(0x0) + wggid;
 
-        /*GID of middle element in every subgroup*/
-        acc[NdItem.get_global_id()] =
-            SG.shuffle(ptr, SG.get_max_local_range()[0] / 2);
+            /*GID of middle element in every subgroup*/
+            acc[NdItem.get_global_id()] =
+                SG.shuffle(ptr, SG.get_max_local_range()[0] / 2);
 
-        /* Save GID-SGID */
-        acc_up[NdItem.get_global_id()] = SG.shuffle_up(ptr, sgid);
+            /* Save GID-SGID */
+            acc_up[NdItem.get_global_id()] = SG.shuffle_up(ptr, sgid);
 
-        /* Save GID+SGID */
-        acc_down[NdItem.get_global_id()] = SG.shuffle_down(ptr, sgid);
+            /* Save GID+SGID */
+            acc_down[NdItem.get_global_id()] = SG.shuffle_down(ptr, sgid);
 
-        /* Save GID with SGLID = ( SGLID XOR SGID ) % SGMaxSize */
-        acc_xor[NdItem.get_global_id()] =
-            SG.shuffle_xor(ptr, sgid % SG.get_max_local_range()[0]);
-      });
+            /* Save GID with SGLID = ( SGLID XOR SGID ) % SGMaxSize */
+            acc_xor[NdItem.get_global_id()] =
+                SG.shuffle_xor(ptr, sgid % SG.get_max_local_range()[0]);
+          });
     });
     auto acc = buf.template get_access<access::mode::read_write>();
     auto acc_up = buf_up.template get_access<access::mode::read_write>();
@@ -119,7 +120,7 @@ void check_pointer(queue &Queue, size_t G = 256, size_t L = 64) {
   }
 }
 
-template <typename T, typename Generator>
+template <typename SpecializationKernelName, typename T, typename Generator>
 void check_struct(queue &Queue, Generator &Gen, size_t G = 256, size_t L = 64) {
 
   // Fill a vector with values that will be shuffled
@@ -143,29 +144,30 @@ void check_struct(queue &Queue, Generator &Gen, size_t G = 256, size_t L = 64) {
       auto sgsizeacc = sgsizebuf.get_access<access::mode::read_write>(cgh);
       auto in = buf_in.template get_access<access::mode::read>(cgh);
 
-      cgh.parallel_for<pointer_kernel<T>>(NdRange, [=](nd_item<1> NdItem) {
-        ONEAPI::sub_group SG = NdItem.get_sub_group();
-        uint32_t wggid = NdItem.get_global_id(0);
-        uint32_t sgid = SG.get_group_id().get(0);
-        if (wggid == 0)
-          sgsizeacc[0] = SG.get_max_local_range()[0];
+      cgh.parallel_for<SpecializationKernelName>(
+          NdRange, [=](nd_item<1> NdItem) {
+            ONEAPI::sub_group SG = NdItem.get_sub_group();
+            uint32_t wggid = NdItem.get_global_id(0);
+            uint32_t sgid = SG.get_group_id().get(0);
+            if (wggid == 0)
+              sgsizeacc[0] = SG.get_max_local_range()[0];
 
-        T val = in[wggid];
+            T val = in[wggid];
 
-        /*GID of middle element in every subgroup*/
-        acc[NdItem.get_global_id()] =
-            SG.shuffle(val, SG.get_max_local_range()[0] / 2);
+            /*GID of middle element in every subgroup*/
+            acc[NdItem.get_global_id()] =
+                SG.shuffle(val, SG.get_max_local_range()[0] / 2);
 
-        /* Save GID-SGID */
-        acc_up[NdItem.get_global_id()] = SG.shuffle_up(val, sgid);
+            /* Save GID-SGID */
+            acc_up[NdItem.get_global_id()] = SG.shuffle_up(val, sgid);
 
-        /* Save GID+SGID */
-        acc_down[NdItem.get_global_id()] = SG.shuffle_down(val, sgid);
+            /* Save GID+SGID */
+            acc_down[NdItem.get_global_id()] = SG.shuffle_down(val, sgid);
 
-        /* Save GID with SGLID = ( SGLID XOR SGID ) % SGMaxSize */
-        acc_xor[NdItem.get_global_id()] =
-            SG.shuffle_xor(val, sgid % SG.get_max_local_range()[0]);
-      });
+            /* Save GID with SGLID = ( SGLID XOR SGID ) % SGMaxSize */
+            acc_xor[NdItem.get_global_id()] =
+                SG.shuffle_xor(val, sgid % SG.get_max_local_range()[0]);
+          });
     });
     auto acc = buf.template get_access<access::mode::read_write>();
     auto acc_up = buf_up.template get_access<access::mode::read_write>();
@@ -223,18 +225,20 @@ int main() {
   }
 
   // Test shuffle of pointer types
-  check_pointer<int>(Queue);
+  check_pointer<class KernelName_mNiN, int>(Queue);
 
   // Test shuffle of non-native types
   auto ComplexFloatGenerator = [state = std::complex<float>(0, 1)]() mutable {
     return state += std::complex<float>(2, 2);
   };
-  check_struct<std::complex<float>>(Queue, ComplexFloatGenerator);
+  check_struct<class KernelName_zHfIPOLOFsXiZiCvG, std::complex<float>>(
+      Queue, ComplexFloatGenerator);
 
   auto ComplexDoubleGenerator = [state = std::complex<double>(0, 1)]() mutable {
     return state += std::complex<double>(2, 2);
   };
-  check_struct<std::complex<double>>(Queue, ComplexDoubleGenerator);
+  check_struct<class KernelName_CjlHUmnuxWtyejZFD, std::complex<double>>(
+      Queue, ComplexDoubleGenerator);
 
   std::cout << "Test passed." << std::endl;
   return 0;
diff --git a/sycl/test/sub_group/reduce.cpp b/sycl/test/sub_group/reduce.cpp
index f7a324f10b38c..6644516f52158 100644
--- a/sycl/test/sub_group/reduce.cpp
+++ b/sycl/test/sub_group/reduce.cpp
@@ -24,11 +24,11 @@ int main() {
     std::cout << "Skipping test\n";
     return 0;
   }
-  check<int>(Queue);
-  check<unsigned int>(Queue);
-  check<long>(Queue);
-  check<unsigned long>(Queue);
-  check<float>(Queue);
+  check<class KernelName_AJprOaCZgUmsYFRTTGNw, int>(Queue);
+  check<class KernelName_ShKFIYTqaI, unsigned int>(Queue);
+  check<class KernelName_TovsKTk, long>(Queue);
+  check<class KernelName_JqbvoN, unsigned long>(Queue);
+  check<class KernelName_mAWqKSWTT, float>(Queue);
   std::cout << "Test passed." << std::endl;
   return 0;
 }
diff --git a/sycl/test/sub_group/reduce.hpp b/sycl/test/sub_group/reduce.hpp
index 66a737a95c8c4..f606dcf5e9898 100644
--- a/sycl/test/sub_group/reduce.hpp
+++ b/sycl/test/sub_group/reduce.hpp
@@ -9,11 +9,11 @@
 #include "helper.hpp"
 #include <CL/sycl.hpp>
 
-template <typename T, class BinaryOperation> class sycl_subgr;
+template <typename... Ts> class sycl_subgr;
 
 using namespace cl::sycl;
 
-template <typename T, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, class BinaryOperation>
 void check_op(queue &Queue, T init, BinaryOperation op, bool skip_init = false,
               size_t G = 256, size_t L = 64) {
   try {
@@ -23,7 +23,7 @@ void check_op(queue &Queue, T init, BinaryOperation op, bool skip_init = false,
     Queue.submit([&](handler &cgh) {
       auto sgsizeacc = sgsizebuf.get_access<access::mode::read_write>(cgh);
       auto acc = buf.template get_access<access::mode::read_write>(cgh);
-      cgh.parallel_for<sycl_subgr<T, BinaryOperation>>(
+      cgh.parallel_for<SpecializationKernelName>(
           NdRange, [=](nd_item<1> NdItem) {
             ONEAPI::sub_group sg = NdItem.get_sub_group();
             if (skip_init) {
@@ -64,30 +64,48 @@ void check_op(queue &Queue, T init, BinaryOperation op, bool skip_init = false,
   }
 }
 
-template <typename T> void check(queue &Queue, size_t G = 256, size_t L = 64) {
+template <typename SpecializationKernelName, typename T>
+void check(queue &Queue, size_t G = 256, size_t L = 64) {
   // limit data range for half to avoid rounding issues
   if (std::is_same<T, cl::sycl::half>::value) {
     G = 64;
     L = 32;
   }
 
-  check_op<T>(Queue, T(L), ONEAPI::plus<T>(), false, G, L);
-  check_op<T>(Queue, T(0), ONEAPI::plus<T>(), true, G, L);
+  check_op<
+      sycl_subgr<SpecializationKernelName, class KernelName_cNsJzXxSBQfEKY>, T>(
+      Queue, T(L), ONEAPI::plus<T>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_bWdCJaxe>, T>(
+      Queue, T(0), ONEAPI::plus<T>(), true, G, L);
 
-  check_op<T>(Queue, T(0), ONEAPI::minimum<T>(), false, G, L);
-  check_op<T>(Queue, T(G), ONEAPI::minimum<T>(), true, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_wjspvpHJtI>,
+           T>(Queue, T(0), ONEAPI::minimum<T>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_BUioaQYxhjN>,
+           T>(Queue, T(G), ONEAPI::minimum<T>(), true, G, L);
 
-  check_op<T>(Queue, T(G), ONEAPI::maximum<T>(), false, G, L);
-  check_op<T>(Queue, T(0), ONEAPI::maximum<T>(), true, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_bIHcoJBNpiB>,
+           T>(Queue, T(G), ONEAPI::maximum<T>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_bPPlfvdGShi>,
+           T>(Queue, T(0), ONEAPI::maximum<T>(), true, G, L);
 
 #if __cplusplus >= 201402L
-  check_op<T>(Queue, T(L), ONEAPI::plus<>(), false, G, L);
-  check_op<T>(Queue, T(0), ONEAPI::plus<>(), true, G, L);
+  check_op<sycl_subgr<SpecializationKernelName,
+                      class KernelName_fkOyLRYirfMnvBcnbRFy>,
+           T>(Queue, T(L), ONEAPI::plus<>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName,
+                      class KernelName_zhzfRmSAFlswKWShyecv>,
+           T>(Queue, T(0), ONEAPI::plus<>(), true, G, L);
 
-  check_op<T>(Queue, T(0), ONEAPI::minimum<>(), false, G, L);
-  check_op<T>(Queue, T(G), ONEAPI::minimum<>(), true, G, L);
+  check_op<sycl_subgr<SpecializationKernelName,
+                      class KernelName_NaOzDnOmDPiDIXnXvaGy>,
+           T>(Queue, T(0), ONEAPI::minimum<>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_XXAfdcNmCNX>,
+           T>(Queue, T(G), ONEAPI::minimum<>(), true, G, L);
 
-  check_op<T>(Queue, T(G), ONEAPI::maximum<>(), false, G, L);
-  check_op<T>(Queue, T(0), ONEAPI::maximum<>(), true, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_pLlvjjZsPv>,
+           T>(Queue, T(G), ONEAPI::maximum<>(), false, G, L);
+  check_op<
+      sycl_subgr<SpecializationKernelName, class KernelName_BaCGaWDMFeMFqvotbk>,
+      T>(Queue, T(0), ONEAPI::maximum<>(), true, G, L);
 #endif
 }
diff --git a/sycl/test/sub_group/reduce_fp16.cpp b/sycl/test/sub_group/reduce_fp16.cpp
index 17bd8507a7c90..dfe9299bfcd9e 100644
--- a/sycl/test/sub_group/reduce_fp16.cpp
+++ b/sycl/test/sub_group/reduce_fp16.cpp
@@ -19,7 +19,7 @@ int main() {
     std::cout << "Skipping test\n";
     return 0;
   }
-  check<cl::sycl::half>(Queue);
+  check<class KernelName_oMg, cl::sycl::half>(Queue);
   std::cout << "Test passed." << std::endl;
   return 0;
 }
diff --git a/sycl/test/sub_group/reduce_fp64.cpp b/sycl/test/sub_group/reduce_fp64.cpp
index 1af1ae040e02e..958052e979324 100644
--- a/sycl/test/sub_group/reduce_fp64.cpp
+++ b/sycl/test/sub_group/reduce_fp64.cpp
@@ -24,7 +24,7 @@ int main() {
     std::cout << "Skipping test\n";
     return 0;
   }
-  check<double>(Queue);
+  check<class KernelName_alTnImqzYasRyHjYg, double>(Queue);
   std::cout << "Test passed." << std::endl;
   return 0;
 }
diff --git a/sycl/test/sub_group/scan.cpp b/sycl/test/sub_group/scan.cpp
index 32df9d63e9faa..03d3f2ab90f53 100644
--- a/sycl/test/sub_group/scan.cpp
+++ b/sycl/test/sub_group/scan.cpp
@@ -25,11 +25,11 @@ int main() {
     std::cout << "Skipping test\n";
     return 0;
   }
-  check<int>(Queue);
-  check<unsigned int>(Queue);
-  check<long>(Queue);
-  check<unsigned long>(Queue);
-  check<float>(Queue);
+  check<class KernelName_QTbNYAsEmawQ, int>(Queue);
+  check<class KernelName_FQFNSdcVGrCLUbn, unsigned int>(Queue);
+  check<class KernelName_kWYnyHJx, long>(Queue);
+  check<class KernelName_qmL, unsigned long>(Queue);
+  check<class KernelName_BckYc, float>(Queue);
   std::cout << "Test passed." << std::endl;
   return 0;
 }
diff --git a/sycl/test/sub_group/scan.hpp b/sycl/test/sub_group/scan.hpp
index ae9b4ced66ab0..c9d630dea2ea3 100644
--- a/sycl/test/sub_group/scan.hpp
+++ b/sycl/test/sub_group/scan.hpp
@@ -10,11 +10,11 @@
 #include <CL/sycl.hpp>
 #include <limits>
 
-template <typename T, class BinaryOperation> class sycl_subgr;
+template <typename... Ts> class sycl_subgr;
 
 using namespace cl::sycl;
 
-template <typename T, class BinaryOperation>
+template <typename SpecializationKernelName, typename T, class BinaryOperation>
 void check_op(queue &Queue, T init, BinaryOperation op, bool skip_init = false,
               size_t G = 256, size_t L = 64) {
   try {
@@ -25,7 +25,7 @@ void check_op(queue &Queue, T init, BinaryOperation op, bool skip_init = false,
       auto sgsizeacc = sgsizebuf.get_access<access::mode::read_write>(cgh);
       auto exacc = exbuf.template get_access<access::mode::read_write>(cgh);
       auto inacc = inbuf.template get_access<access::mode::read_write>(cgh);
-      cgh.parallel_for<sycl_subgr<T, BinaryOperation>>(
+      cgh.parallel_for<SpecializationKernelName>(
           NdRange, [=](nd_item<1> NdItem) {
             ONEAPI::sub_group sg = NdItem.get_sub_group();
             if (skip_init) {
@@ -72,58 +72,83 @@ void check_op(queue &Queue, T init, BinaryOperation op, bool skip_init = false,
   }
 }
 
-template <typename T> void check(queue &Queue, size_t G = 256, size_t L = 64) {
+template <typename SpecializationKernelName, typename T>
+void check(queue &Queue, size_t G = 256, size_t L = 64) {
   // limit data range for half to avoid rounding issues
   if (std::is_same<T, cl::sycl::half>::value) {
     G = 64;
     L = 32;
   }
 
-  check_op<T>(Queue, T(L), ONEAPI::plus<T>(), false, G, L);
-  check_op<T>(Queue, T(0), ONEAPI::plus<T>(), true, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_UdKabTMplbvM>,
+           T>(Queue, T(L), ONEAPI::plus<T>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_hYvJ>, T>(
+      Queue, T(0), ONEAPI::plus<T>(), true, G, L);
 
-  check_op<T>(Queue, T(0), ONEAPI::minimum<T>(), false, G, L);
+  check_op<
+      sycl_subgr<SpecializationKernelName, class KernelName_eozPcciiaOmKkKUEp>,
+      T>(Queue, T(0), ONEAPI::minimum<T>(), false, G, L);
   if (std::is_floating_point<T>::value ||
       std::is_same<T, cl::sycl::half>::value) {
-    check_op<T>(Queue, std::numeric_limits<T>::infinity(), ONEAPI::minimum<T>(),
-                true, G, L);
+    check_op<
+        sycl_subgr<SpecializationKernelName, class KernelName_LylCkHSTmrFhMH>,
+        T>(Queue, std::numeric_limits<T>::infinity(), ONEAPI::minimum<T>(),
+           true, G, L);
   } else {
-    check_op<T>(Queue, std::numeric_limits<T>::max(), ONEAPI::minimum<T>(),
+    check_op<sycl_subgr<SpecializationKernelName,
+                        class KernelName_gYWXQQXGnzJEpaftEQly>,
+             T>(Queue, std::numeric_limits<T>::max(), ONEAPI::minimum<T>(),
                 true, G, L);
   }
 
-  check_op<T>(Queue, T(G), ONEAPI::maximum<T>(), false, G, L);
+  check_op<
+      sycl_subgr<SpecializationKernelName, class KernelName_NEgmAHtvPAWDyXPoo>,
+      T>(Queue, T(G), ONEAPI::maximum<T>(), false, G, L);
   if (std::is_floating_point<T>::value ||
       std::is_same<T, cl::sycl::half>::value) {
-    check_op<T>(Queue, -std::numeric_limits<T>::infinity(),
-                ONEAPI::maximum<T>(), true, G, L);
+    check_op<
+        sycl_subgr<SpecializationKernelName, class KernelName_EBNigvpxbxYEyRcl>,
+        T>(Queue, -std::numeric_limits<T>::infinity(), ONEAPI::maximum<T>(),
+           true, G, L);
   } else {
-    check_op<T>(Queue, std::numeric_limits<T>::min(), ONEAPI::maximum<T>(),
-                true, G, L);
+    check_op<sycl_subgr<SpecializationKernelName, class KernelName_KayihC>, T>(
+        Queue, std::numeric_limits<T>::min(), ONEAPI::maximum<T>(), true, G, L);
   }
 
 #if __cplusplus >= 201402L
-  check_op<T>(Queue, T(L), ONEAPI::plus<>(), false, G, L);
-  check_op<T>(Queue, T(0), ONEAPI::plus<>(), true, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_TPWS>, T>(
+      Queue, T(L), ONEAPI::plus<>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_hWZv>, T>(
+      Queue, T(0), ONEAPI::plus<>(), true, G, L);
 
-  check_op<T>(Queue, T(0), ONEAPI::minimum<>(), false, G, L);
+  check_op<
+      sycl_subgr<SpecializationKernelName, class KernelName_MdoesLriZMCljse>,
+      T>(Queue, T(0), ONEAPI::minimum<>(), false, G, L);
   if (std::is_floating_point<T>::value ||
       std::is_same<T, cl::sycl::half>::value) {
-    check_op<T>(Queue, std::numeric_limits<T>::infinity(), ONEAPI::minimum<>(),
-                true, G, L);
+    check_op<
+        sycl_subgr<SpecializationKernelName, class KernelName_fgMMknFqTMGts>,
+        T>(Queue, std::numeric_limits<T>::infinity(), ONEAPI::minimum<>(), true,
+           G, L);
   } else {
-    check_op<T>(Queue, std::numeric_limits<T>::max(), ONEAPI::minimum<>(), true,
+    check_op<sycl_subgr<SpecializationKernelName,
+                        class KernelName_FVbXDSctbMnggHMCz>,
+             T>(Queue, std::numeric_limits<T>::max(), ONEAPI::minimum<>(), true,
                 G, L);
   }
 
-  check_op<T>(Queue, T(G), ONEAPI::maximum<>(), false, G, L);
+  check_op<sycl_subgr<SpecializationKernelName, class KernelName_zzvRru>, T>(
+      Queue, T(G), ONEAPI::maximum<>(), false, G, L);
   if (std::is_floating_point<T>::value ||
       std::is_same<T, cl::sycl::half>::value) {
-    check_op<T>(Queue, -std::numeric_limits<T>::infinity(), ONEAPI::maximum<>(),
-                true, G, L);
+    check_op<sycl_subgr<SpecializationKernelName, class KernelName_NJh>, T>(
+        Queue, -std::numeric_limits<T>::infinity(), ONEAPI::maximum<>(), true,
+        G, L);
   } else {
-    check_op<T>(Queue, std::numeric_limits<T>::min(), ONEAPI::maximum<>(), true,
-                G, L);
+    check_op<
+        sycl_subgr<SpecializationKernelName, class KernelName_XjMHvRfLSQerFi>,
+        T>(Queue, std::numeric_limits<T>::min(), ONEAPI::maximum<>(), true, G,
+           L);
   }
 #endif
 }
diff --git a/sycl/test/sub_group/scan_fp16.cpp b/sycl/test/sub_group/scan_fp16.cpp
index 13e3f45b27944..4c0570fd4bdf7 100644
--- a/sycl/test/sub_group/scan_fp16.cpp
+++ b/sycl/test/sub_group/scan_fp16.cpp
@@ -23,7 +23,7 @@ int main() {
     std::cout << "Skipping test\n";
     return 0;
   }
-  check<cl::sycl::half>(Queue);
+  check<class KernelName_dlpo, cl::sycl::half>(Queue);
   std::cout << "Test passed." << std::endl;
   return 0;
 }
diff --git a/sycl/test/sub_group/scan_fp64.cpp b/sycl/test/sub_group/scan_fp64.cpp
index f2ecd6024e7a4..de7bbd9707464 100644
--- a/sycl/test/sub_group/scan_fp64.cpp
+++ b/sycl/test/sub_group/scan_fp64.cpp
@@ -25,7 +25,7 @@ int main() {
     std::cout << "Skipping test\n";
     return 0;
   }
-  check<double>(Queue);
+  check<class KernelName_cYZflKkIXS, double>(Queue);
   std::cout << "Test passed." << std::endl;
   return 0;
 }