[SYCL] Throw for invalid info::kernel::num_args query (#9061)

According to SYCL2020 spec:
This descriptor may only be used to query a kernel that resides in a
kernel bundle that was constructed using a backend specific
interoperability function or to query a device built-in kernel, and the
semantics of this descriptor are defined by each SYCL backend
specification. Attempting to use this descriptor for other kernels
throws an exception with the errc::invalid error code.

Fow now the only one way to create such kernel bundle - use
make_kernel(). And creating bundle from built-in kernels is not fully
supported, so it should throw in most cases at the present time.

Resolves #7630

Author: KornevNikita

sycl/source/detail/kernel_impl.cpp

@@ -93,6 +93,31 @@ bool kernel_impl::isCreatedFromSource() const {
   return MCreatedFromSource;
 }
 
+bool kernel_impl::isBuiltInKernel(const device &Device) const {
+  auto BuiltInKernels = Device.get_info<info::device::built_in_kernel_ids>();
+  if (BuiltInKernels.empty())
+    return false;
+  std::string KernelName = get_info<info::kernel::function_name>();
+  return (std::any_of(
+      BuiltInKernels.begin(), BuiltInKernels.end(),
+      [&KernelName](kernel_id &Id) { return Id.get_name() == KernelName; }));
+}
+
+void kernel_impl::checkIfValidForNumArgsInfoQuery() const {
+  if (MKernelBundleImpl->isInterop())
+    return;
+  auto Devices = MKernelBundleImpl->get_devices();
+  if (std::any_of(Devices.begin(), Devices.end(),
+                  [this](device &Device) { return isBuiltInKernel(Device); }))
+    return;
+
+  throw sycl::exception(
+      sycl::make_error_code(errc::invalid),
+      "info::kernel::num_args descriptor may only be used to query a kernel "
+      "that resides in a kernel bundle constructed using a backend specific"
+      "interoperability function or to query a device built-in kernel");
+}
+
 } // namespace detail
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl

sycl/source/detail/kernel_impl.hpp

@@ -186,6 +186,9 @@ class kernel_impl {
   const KernelBundleImplPtr MKernelBundleImpl;
   bool MIsInterop = false;
   std::mutex MNoncacheableEnqueueMutex;
+
+  bool isBuiltInKernel(const device &Device) const;
+  void checkIfValidForNumArgsInfoQuery() const;
 };
 
 template <typename Param>
@@ -196,6 +199,10 @@ inline typename Param::return_type kernel_impl::get_info() const {
     // TODO implement
     assert(0 && "Not implemented");
   }
+
+  if constexpr (std::is_same_v<Param, info::kernel::num_args>)
+    checkIfValidForNumArgsInfoQuery();
+
   return get_kernel_info<Param>(this->getHandleRef(), getPlugin());
 }
 

sycl/test-e2e/Basic/kernel_info.cpp

@@ -36,8 +36,25 @@ int main() {
 
   const std::string krnName = krn.get_info<info::kernel::function_name>();
   assert(!krnName.empty());
-  const cl_uint krnArgCount = krn.get_info<info::kernel::num_args>();
-  assert(krnArgCount > 0);
+
+  std::string ErrMsg = "";
+  std::error_code Errc;
+  bool ExceptionWasThrown = false;
+  try {
+    const cl_uint krnArgCount = krn.get_info<info::kernel::num_args>();
+  } catch (exception &e) {
+    ErrMsg = e.what();
+    Errc = e.code();
+    ExceptionWasThrown = true;
+  }
+  assert(ExceptionWasThrown && "Invalid using of \"info::kernel::num_args\" "
+                               "query should throw an exception.");
+  assert(ErrMsg ==
+         "info::kernel::num_args descriptor may only be used to query a kernel "
+         "that resides in a kernel bundle constructed using a backend specific"
+         "interoperability function or to query a device built-in kernel");
+  assert(Errc == errc::invalid);
+
   const context krnCtx = krn.get_info<info::kernel::context>();
   assert(krnCtx == q.get_context());
   const cl_uint krnRefCount = krn.get_info<info::kernel::reference_count>();

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

@@ -33,17 +33,11 @@ int main() {
   auto ExpectedKernelName =
       ExpectedKernel.get_info<sycl::info::kernel::function_name>();
 
-  auto FoundKernelNumArgs =
-      FoundKernel.get_info<sycl::info::kernel::num_args>();
-  auto ExpectedKernelNumArgs =
-      ExpectedKernel.get_info<sycl::info::kernel::num_args>();
-
   auto FoundKernelContext = FoundKernel.get_info<sycl::info::kernel::context>();
   auto ExpectedKernelContext =
       ExpectedKernel.get_info<sycl::info::kernel::context>();
 
   assert(FoundKernelName == ExpectedKernelName);
-  assert(FoundKernelNumArgs == ExpectedKernelNumArgs);
   assert(FoundKernelContext == ExpectedKernelContext);
 
   return 0;

sycl/test-e2e/OnlineCompiler/online_compiler_L0.cpp

@@ -56,9 +56,21 @@ sycl::kernel getSYCLKernelWithIL(sycl::queue &Queue,
       sycl::make_kernel_bundle<sycl::backend::ext_oneapi_level_zero,
                                sycl::bundle_state::executable>(
           {ZeModule, sycl::ext::oneapi::level_zero::ownership::keep}, Context);
-  return sycl::make_kernel<sycl::backend::ext_oneapi_level_zero>(
+
+  auto Kernel = sycl::make_kernel<sycl::backend::ext_oneapi_level_zero>(
       {SyclKB, ZeKernel, sycl::ext::oneapi::level_zero::ownership::keep},
       Context);
+
+  // Should not throw an exception
+  try {
+    auto num_args = Kernel.get_info<sycl::info::kernel::num_args>();
+    (void)num_args;
+  } catch (sycl::exception &e) {
+    assert(false && "Using \"info::kernel::num_args\" query for valid kernel "
+                    "should not throw an exception.");
+  }
+
+  return Kernel;
 }
 #endif // RUN_KERNELS
 

sycl/test-e2e/Plugin/interop-opencl-make-kernel.cpp

@@ -45,6 +45,14 @@ int main() {
   assert(OpenCLError == CL_SUCCESS);
 
   kernel Kernel = make_kernel<backend::opencl>(OpenCLKernel, Context);
+  // Should not throw an exception
+  try {
+    auto num_args = Kernel.get_info<info::kernel::num_args>();
+    (void)num_args;
+  } catch (exception &e) {
+    assert(false && "Using \"info::kernel::num_args\" query for valid kernel "
+                    "should not throw an exception.");
+  }
 
   // The associated kernel bundle should not contain the dummy-kernel.
   assert(!Kernel.get_kernel_bundle().has_kernel(get_kernel_id<DummyKernel>()));