[SYCL][E2E] Add free function kernel queries tests (#18904)

Add 2 tests for the free function kernel extension as per the [test
plan](https://github.com/intel/llvm/blob/6af08fe9c6fd4dc8e433555646606898c71d92fb/sycl/test-e2e/FreeFunctionKernels/test-plan.md).

More specifically,

- Check that the 3 overloads of `get_kernel_info` for free function
kernels as defined
[here](https://github.com/intel/llvm/blob/6af08fe9c6fd4dc8e433555646606898c71d92fb/sycl/doc/extensions/proposed/sycl_ext_oneapi_free_function_kernels.asciidoc#new-free-functions-to-query-kernel-information-descriptors)
return the same values as the regular `get_info` called on the kernel
object.

- Check that `get_kernel_ids` on a kernel bundle as defined
[here](https://github.com/intel/llvm/blob/6af08fe9c6fd4dc8e433555646606898c71d92fb/sycl/doc/extensions/proposed/sycl_ext_oneapi_free_function_kernels.asciidoc#behavior-with-kernel-bundle-functions-in-the-core-sycl-specification)
returns all kernels defined in the source be they free function kernels,
lambdas or function objects.

Author: lbushi25

sycl/test-e2e/KernelAndProgram/free_function_apis.cpp

@@ -6,6 +6,7 @@
 #include <sycl/detail/core.hpp>
 #include <sycl/ext/oneapi/experimental/free_function_traits.hpp>
 #include <sycl/ext/oneapi/free_function_queries.hpp>
+#include <sycl/ext/oneapi/get_kernel_info.hpp>
 #include <sycl/kernel_bundle.hpp>
 #include <sycl/usm.hpp>
 
@@ -207,6 +208,41 @@ bool test_bundle_apis(queue Queue) {
   std::cout << "PassR=" << PassR << std::endl;
   Pass &= PassR;
 
+  kernel_bundle Bundle_ff2 = ext::oneapi::experimental::get_kernel_bundle<
+      ff_2, bundle_state::executable>(Context);
+
+  bool PassS =
+      ext::oneapi::experimental::get_kernel_info<ff_2,
+                                                 info::kernel::function_name>(
+          Context) == Bundle_ff2.ext_oneapi_get_kernel<ff_2>()
+                          .get_info<info::kernel::function_name>();
+  std::cout << "Test retrieving function_name using context: " << PassS
+            << std::endl;
+  Pass &= PassS;
+
+  kernel_bundle Bundle_ff3 = ext::oneapi::experimental::get_kernel_bundle<
+      ff_3<int>, bundle_state::executable>(Context);
+
+  bool PassT =
+      ext::oneapi::experimental::get_kernel_info<
+          ff_3<int>, info::kernel_device_specific::work_group_size>(Context,
+                                                                    Device) ==
+      Bundle_ff3.ext_oneapi_get_kernel<ff_3<int>>()
+          .get_info<info::kernel_device_specific::work_group_size>(Device);
+  std::cout << "Test retrieving work_group_size using context and device: "
+            << PassT << std::endl;
+  Pass &= PassT;
+
+  bool PassU =
+      ext::oneapi::experimental::get_kernel_info<
+          ff_3<int>, info::kernel_device_specific::work_group_size>(Queue) ==
+      Bundle_ff3.ext_oneapi_get_kernel<ff_3<int>>()
+          .get_info<info::kernel_device_specific::work_group_size>(
+              Queue.get_device());
+  std::cout << "Test retrieving work_group_size using queue: " << PassU
+            << std::endl;
+  Pass &= PassU;
+
   std::cout << "Test bundle APIs: " << (Pass ? "PASS" : "FAIL") << std::endl;
   return Pass;
 }

sycl/test-e2e/KernelAndProgram/kernel-bundle-get-kernel-ids.cpp

@@ -0,0 +1,55 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
+
+// This test checks that get_kernel_ids returns all the kernels defined
+// in the source regardless of whether they are expressed as lambdas,
+// function objects or free functions.
+
+#include <sycl/detail/core.hpp>
+#include <sycl/ext/oneapi/experimental/free_function_traits.hpp>
+#include <sycl/kernel_bundle.hpp>
+
+class FunctionObjectKernel {
+public:
+  void operator()() const {}
+};
+
+class LambdaKernel;
+
+SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
+    (sycl::ext::oneapi::experimental::nd_range_kernel<1>))
+void FreeFunctionKernel() {}
+
+int main() {
+  sycl::queue Queue;
+  sycl::device Dev = Queue.get_device();
+  sycl::context Context = Queue.get_context();
+
+  sycl::kernel_id FunctionObjectKernelId =
+      sycl::get_kernel_id<FunctionObjectKernel>();
+  sycl::kernel_id LambdaKernelId = sycl::get_kernel_id<LambdaKernel>();
+  sycl::kernel_id FreeFunctionKernelId =
+      sycl::ext::oneapi::experimental::get_kernel_id<FreeFunctionKernel>();
+
+  sycl::kernel_bundle KernelBundle =
+      sycl::get_kernel_bundle<sycl::bundle_state::executable>(Context, {Dev});
+  sycl::kernel FreeFunction = KernelBundle.get_kernel(FreeFunctionKernelId);
+  Queue.submit(
+      [&](sycl::handler &CGH) { CGH.single_task<LambdaKernel>([=]() {}); });
+  Queue.submit([&](sycl::handler &CGH) {
+    FunctionObjectKernel kernel;
+    CGH.single_task(kernel);
+  });
+  Queue.submit([&](sycl::handler &CGH) {
+    CGH.parallel_for(sycl::nd_range{{1}, {1}}, FreeFunction);
+  });
+
+  std::vector<sycl::kernel_id> KernelIds = KernelBundle.get_kernel_ids();
+  assert(KernelIds.size() == 3);
+  for (const sycl::kernel_id &KernelId :
+       {FunctionObjectKernelId, LambdaKernelId, FreeFunctionKernelId}) {
+    auto FoundId = std::find(KernelIds.begin(), KernelIds.end(), KernelId);
+    assert(FoundId != KernelIds.end());
+  }
+  return 0;
+}