[SYCL] Add lightweight free-function kernel property headers

Introduce lightweight kernel-property headers for free-function kernel
annotation and launch-tuning use cases:

- function_properties.hpp provides a standalone path for execution-kind
  annotations such as nd_range_kernel and single_task_kernel.
- function_launch_properties.hpp provides a lightweight path for launch
  properties such as work_group_size, work_group_size_hint, and
  sub_group_size.
- kernel_properties/properties.hpp remains the umbrella path for full
  property-list semantics and cross-property conflict checking.

This reduces compile-time cost for kernel-language and JIT-style usage
while preserving the full umbrella interface for users who need complete
property-list behavior.

Measured header compile times:
- function_properties.hpp: ~26 ms
- function_launch_properties path: ~58 ms
- kernel_properties/properties.hpp umbrella: ~68 ms

Author: koparasy

sycl/doc/extensions/experimental/sycl_ext_oneapi_free_function_kernels.asciidoc

@@ -112,6 +112,36 @@ supports.
  feature-test macro always has this value.
 |===
 
+=== Headers
+
+In the {dpcpp} implementation, applications that use this extension have a
+choice of headers depending on which properties they need:
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` is
+  sufficient for `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`,
+  `nd_range_kernel<Dims>`, and `single_task_kernel`.
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>`
+  additionally provides the launch-configuration properties that may be applied
+  directly to a free function kernel declaration, such as
+  `work_group_size`, `work_group_size_hint`, `sub_group_size`,
+  `max_work_group_size`, and `max_linear_work_group_size`.
+
+* `#include <sycl/ext/oneapi/kernel_properties/properties.hpp>` provides the
+  full kernel properties interface, including property lists such as
+  `properties{...}` and embedded kernel properties via `properties_tag`.
+
+Applications may include the umbrella header in all cases. The lighter-weight
+headers are intended for code that only needs function annotations on free
+function kernels and where reducing compile time is a priority.
+
+The lighter-weight headers retain validation of each individual property, such
+as arity and non-zero size requirements, but they do not provide the
+cross-property validation that is performed when properties are combined via
+the full property-list machinery. For example, checks for conflicting
+combinations such as `work_group_size` together with `max_work_group_size` are
+available only through the umbrella header.
+
 === Defining a free function kernel
 
 A free function kernel is a normal C++ function definition, where the function
@@ -803,6 +833,13 @@ in link:../experimental/sycl_ext_oneapi_kernel_properties.asciidoc[
 sycl_ext_oneapi_kernel_properties] by applying the properties to the function
 declaration as illustrated below.
 
+In the {dpcpp} implementation, code that uses only function annotations may
+include either `function_properties.hpp` or
+`function_launch_properties.hpp` instead of the full
+`kernel_properties/properties.hpp` header. Applications that need property-list
+semantics, including cross-property validation, should include the umbrella
+header.
+
 ```
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::nd_range_kernel<1>))
 SYCL_EXT_ONEAPI_FUNCTION_PROPERTY((syclexp::work_group_size<32>))

sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_properties.asciidoc

@@ -115,6 +115,40 @@ supports.
  feature-test macro always has this value.
 |===
 
+=== Headers
+
+In the {dpcpp} implementation, the full API described in this extension is
+provided by:
+
+* `#include <sycl/ext/oneapi/kernel_properties/properties.hpp>`
+
+This umbrella header should be used when code needs property lists such as
+`properties{...}`, embedded kernel properties via `properties_tag`, or any of
+the non-launch kernel properties described in this extension.
+
+The implementation also provides lighter-weight headers for code that only
+needs free-function annotations:
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>` for
+  `nd_range_kernel<Dims>`, `single_task_kernel`, and
+  `SYCL_EXT_ONEAPI_FUNCTION_PROPERTY`.
+
+* `#include <sycl/ext/oneapi/kernel_properties/function_launch_properties.hpp>`
+  for the launch-configuration properties that can be applied directly to free
+  function declarations, including `work_group_size`,
+  `work_group_size_hint`, `sub_group_size`, `max_work_group_size`, and
+  `max_linear_work_group_size`.
+
+These lighter-weight headers are primarily intended for code paths where
+reduced compile time is a high priority and the application only needs
+function-level annotations.
+
+They retain validation of each individual property, but they do not provide
+the cross-property validation that depends on forming a full property list.
+For example, checks for conflicting combinations such as `work_group_size`
+together with `max_work_group_size` or `max_linear_work_group_size` are
+performed only when using the umbrella header.
+
 === Kernel Properties
 
 The kernel properties below correspond to kernel attributes defined in

sycl/include/sycl/ext/oneapi/experimental/virtual_functions.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <sycl/ext/oneapi/kernel_properties/function_properties.hpp>
 #include <sycl/ext/oneapi/properties/property.hpp>
 #include <sycl/ext/oneapi/properties/property_utils.hpp>
 #include <sycl/ext/oneapi/properties/property_value.hpp>
@@ -49,6 +50,17 @@ struct PropertyMetaInfo<indirectly_callable_key::value_t<Set>> {
 #endif
 };
 
+template <typename Set>
+struct FunctionPropertyMetaInfo<indirectly_callable_key::value_t<Set>> {
+  static constexpr const char *name = "indirectly-callable";
+  static constexpr const char *value =
+#ifdef __SYCL_DEVICE_ONLY__
+      __builtin_sycl_unique_stable_name(Set);
+#else
+      "";
+#endif
+};
+
 #ifdef __SYCL_DEVICE_ONLY__
 // Helper to concatenate several lists of characters into a single string.
 // Lists are separated from each other with comma within the resulting string.
@@ -105,6 +117,17 @@ struct PropertyMetaInfo<calls_indirectly_key::value_t<SetIds...>> {
 #endif
 };
 
+template <typename... SetIds>
+struct FunctionPropertyMetaInfo<calls_indirectly_key::value_t<SetIds...>> {
+  static constexpr const char *name = "calls-indirectly";
+  static constexpr const char *value =
+#ifdef __SYCL_DEVICE_ONLY__
+      UniqueStableNameListStr<SetIds...>::value;
+#else
+      "";
+#endif
+};
+
 } // namespace detail
 
 } // namespace ext::oneapi::experimental