Merge branch 'sycl' into cperkins-windows-shutdown-fix

Author: cperkinsintel

sycl/doc/extensions/deprecated/sycl_ext_oneapi_default_context.asciidoc

@@ -0,0 +1,44 @@
+= SYCL(TM) Proposals: Platform Default Contexts
+James Brodman <james[email protected]>
+v0.1
+:source-highlighter: pygments
+:icons: font
+:y: icon:check[role="green"]
+:n: icon:times[role="red"]
+:dpcpp: pass:[DPC++]
+
+== Platform Default Contexts
+
+== Status
+
+This extension has been deprecated.  Although it is still supported in {dpcpp},
+we expect that the interfaces defined in this specification will be removed in
+an upcoming {dpcpp} release.  *Shipping software products should stop using
+APIs defined in this specification and use an alternative instead.*
+
+== Overview
+
+This extension adds the notion of a default SYCL context per SYCL platform. The default context for each platform contains all devices in the platform.
+
+The platform class gains one new method:
+
+[cols="^60a,40"]
+|===
+| Member Function | Description
+
+|
+[source,c++]
+----
+context ext_oneapi_get_default_context()
+----
+
+| Returns the current default context for this `platform`
+
+|===
+
+This extension also modifies the behavior of `queue` constructors. Queues will no longer create a new `context` upon construction. Instead, they will use the default context from the device's platform.
+
+== Feature Test Macro
+
+This extension defines the macro `SYCL_EXT_ONEAPI_DEFAULT_CONTEXT` to `1` to indicate that it is enabled.
+

sycl/doc/extensions/experimental/sycl_ext_oneapi_kernel_compiler.asciidoc

@@ -485,53 +485,52 @@ a!
 ----
 namespace sycl::ext::oneapi::experimental {
 
-struct registered_kernel_names {
-  registered_kernel_names();                                       (1)
-  registered_kernel_names(const std::string &name);                (2)
-  registered_kernel_names(const std::vector<std::string> &names);  (3)
-  void add(const std::string &name);                               (4)
+struct registered_names {
+  registered_names();                                       (1)
+  registered_names(const std::string &name);                (2)
+  registered_names(const std::vector<std::string> &names);  (3)
+  void add(const std::string &name);                        (4)
 };
-using registered_kernel_names_key = registered_kernel_names;
+using registered_names_key = registered_names;
 
 template<>
-struct is_property_key<registered_kernel_names_key> : std::true_type {};
+struct is_property_key<registered_names_key> : std::true_type {};
 
 } // namespace sycl::ext::oneapi::experimental
 ----
 !====
 
-This property is useful when the source language represents kernel names
-differently in the source code and the generated code.
-For example, {cpp} function names in the generated code are "mangled" in an
-implementation-defined way.
+This property is useful when the source language represents names differently in
+the source code and the generated code.
+For example, {cpp} function names and the names of static variables at global
+scope are "mangled" in an implementation-defined way in the generated code.
 The precise meaning of this property is defined by each source language, but in
-general it allows the application to supply a list of kernel names as they
-appear in the source code.
+general it allows the application to supply a list of names as they appear in
+the source code.
 The application can then get the corresponding raw (i.e. mangled) names after
 the code is compiled.
 See the section below "Obtaining a kernel when the language is ``sycl``" for a
 description of how this property is used with the `source_language::sycl`
 language.
 
-_Effects (1):_ Creates a new `registered_kernel_names` property with no
-registered kernel names.
+_Effects (1):_ Creates a new `registered_names` property with no registered
+names.
 
-_Effects (2):_ Creates a new `registered_kernel_names` property with a single
-registered kernel name.
+_Effects (2):_ Creates a new `registered_names` property with a single
+registered name.
 
-_Effects (3):_ Creates a new `registered_kernel_names` property from a vector
-of kernel names.
+_Effects (3):_ Creates a new `registered_names` property from a vector of names.
 
-_Effects (4):_ Adds `name` to the property's list of registered kernel names.
+_Effects (4):_ Adds `name` to the property's list of registered names.
 
-_Preconditions (2-4):_ Each source language defines its own requirements for
-the registered kernel names.
+_Preconditions (2-4):_ Each source language defines its own requirements for the
+registered names.
 For the language `source_language::sycl`, each name must be a {cpp} expression
 for a pointer to a kernel function as defined below under "Obtaining a kernel
 when the language is ``sycl``".
 
-[_Note:_ It is not an error to have duplicate names in a
-`registered_kernel_names` property, but the duplicates have no effect.
+[_Note:_ It is not an error to have duplicate names in a `registered_names`
+property, but the duplicates have no effect.
 _{endnote}_]
 |====
 
@@ -643,8 +642,8 @@ _Constraints:_ This function is not available when `State` is
 
 _Returns:_ If the kernel bundle was created from a bundle of state
 `bundle_state::ext_oneapi_source` and `name` was registered via
-`registered_kernel_names`, returns the compiler-generated (e.g. mangled) name
-for this kernel function.
+`registered_names`, returns the compiler-generated (e.g. mangled) name for this
+kernel function.
 If the kernel bundle was created from a bundle of state
 `bundle_state::ext_oneapi_source` and `name` is the same as a
 compiler-generated name for a kernel defined in that bundle, that same
@@ -661,7 +660,7 @@ _Throws:_
 When the kernel is defined in the language `source_language::sycl`, the host
 code may query for the kernel or obtain the `kernel` object using either the
 kernel's name as it is generated by the compiler (i.e. the {cpp} mangled name)
-or by using the `registered_kernel_names` property.
+or by using the `registered_names` property.
 
 ==== Using the compiler-generated name
 
@@ -691,11 +690,10 @@ sycl::kernel_bundle<sycl::bundle_state::executable> kb = /*...*/;
 sycl::kernel k = kb.ext_oneapi_get_kernel("foo");
 ----
 
-==== Using the `registered_kernel_names` property
+==== Using the `registered_names` property
 
 When the kernel is not declared as `extern "C"`, the compiler generates a
-mangled name, so it is more convenient to use the `registered_kernel_names`
-property.
+mangled name, so it is more convenient to use the `registered_names` property.
 Each string in the property must be the {cpp} expression for a pointer to a
 kernel function.
 These expression strings are conceptually compiled at the bottom of source
@@ -724,7 +722,7 @@ The host code can compile this and get the kernel's `kernel` object like so:
 sycl::kernel_bundle<sycl::bundle_state::ext_oneapi_source> kb_src = /*...*/;
 
 sycl::kernel_bundle<sycl::bundle_state::executable> kb = syclexp::build(kb_src,
-  syclexp::properties{syclexp::registered_kernel_names{"mykernels::bar"}});
+  syclexp::properties{syclexp::registered_names{"mykernels::bar"}});
 
 sycl::kernel k = kb.ext_oneapi_get_kernel("mykernels::bar");
 ----
@@ -744,21 +742,21 @@ the kernel by calling `ext_oneapi_get_raw_kernel_name` like this:
 sycl::kernel_bundle<sycl::bundle_state::ext_oneapi_source> kb_src = /*...*/;
 
 sycl::kernel_bundle<sycl::bundle_state::executable> kb = syclexp::build(kb_src,
-  syclexp::properties{syclexp::registered_kernel_names{"mykernels::bar"}});
+  syclexp::properties{syclexp::registered_names{"mykernels::bar"}});
 
 std::string mangled_name = kb.ext_oneapi_get_raw_kernel_name("mykernels::bar");
 ----
 
 Again, the string passed to `ext_oneapi_get_raw_kernel_name` must have exactly
-the same content as the string that was used to construct the
-`registered_kernel_names` property.
+the same content as the string that was used to construct the `registered_names`
+property.
 The application may also pass this compiler-generated (i.e. mangled) name to
 `ext_oneapi_get_kernel` in order to get the `kernel` object.
 
 ==== Instantiating templated kernel functions
 
-The `registered_kernel_names` property can also be used to instantiate a
-kernel that is defined as a function template.
+The `registered_names` property can also be used to instantiate a kernel that is
+defined as a function template.
 For example, consider source code that defines a kernel function template like
 this:
 
@@ -774,8 +772,8 @@ std::string source = R"""(
 )""";
 ----
 
-The application can use the `registered_kernel_names` property to instantiate
-the template for specific template arguments.
+The application can use the `registered_names` property to instantiate the
+template for specific template arguments.
 For example, this host code instantiates the template twice and gets a `kernel`
 object for each instantiation:
 
@@ -784,7 +782,7 @@ object for each instantiation:
 sycl::kernel_bundle<sycl::bundle_state::ext_oneapi_source> kb_src = /*...*/;
 
 sycl::kernel_bundle<sycl::bundle_state::executable> kb = syclexp::build(kb_src,
-  syclexp::properties{syclexp::registered_kernel_names{{"bartmpl<float>", "bartmpl<int>"}});
+  syclexp::properties{syclexp::registered_names{{"bartmpl<float>", "bartmpl<int>"}});
 
 sycl::kernel k_float = kb.ext_oneapi_get_kernel("bartmpl<float>");
 sycl::kernel k_int = kb.ext_oneapi_get_kernel("bartmpl<int>");
@@ -830,7 +828,7 @@ int main() {
       syclexp::source_language::sycl,
       source);
 
-  // Compile the kernel.  There is no need to use the "registered_kernel_names"
+  // Compile the kernel.  There is no need to use the "registered_names"
   // property because the kernel is declared extern "C".
   sycl::kernel_bundle<sycl::bundle_state::executable> kb_exe =
     syclexp::build(kb_src);
@@ -852,7 +850,7 @@ int main() {
 
 === Disambiguating overloaded kernel functions
 
-This example demonstrates how to use the `registered_kernel_names` property to
+This example demonstrates how to use the `registered_names` property to
 disambiguate a kernel function that has several overloads.
 
 [source,c++]
@@ -896,11 +894,11 @@ int main() {
   // use a C++ cast to disambiguate between them.  Here, we are selecting the
   // "int" overload.
   std::string iota_name{"(void(*)(int, int*))iota"};
-  sycl::kernel_bundle<sycl::bundle_state::executable> kb_exe = syclexp::build(kb_src,
-    syclexp::properties{syclexp::registered_kernel_names{iota_name}});
+  sycl::kernel_bundle<sycl::bundle_state::executable> kb_exe =
+    syclexp::build(kb_src, syclexp::properties{syclexp::registered_names{iota_name}});
 
   // Get the kernel by passing the same string we used to construct the
-  // "registered_kernel_names" property.
+  // "registered_names" property.
   sycl::kernel iota = kb_exe.ext_oneapi_get_kernel(iota_name);
 
   int *ptr = sycl::malloc_shared<int>(NUM, q);

sycl/doc/extensions/supported/sycl_ext_oneapi_default_context.asciidoc

@@ -1,34 +1,2 @@
-= SYCL(TM) Proposals: Platform Default Contexts
-James Brodman <james[email protected]>
-v0.1
-:source-highlighter: pygments
-:icons: font
-:y: icon:check[role="green"]
-:n: icon:times[role="red"]
-
-== Platform Default Contexts
-
-This extension adds the notion of a default SYCL context per SYCL platform. The default context for each platform contains all devices in the platform.
-
-The platform class gains one new method:
-
-[cols="^60a,40"]
-|===
-| Member Function | Description
-
-|
-[source,c++]
-----
-context ext_oneapi_get_default_context()
-----
-
-| Returns the current default context for this `platform`
-
-|===
-
-This extension also modifies the behavior of `queue` constructors. Queues will no longer create a new `context` upon construction. Instead, they will use the default context from the device's platform.
-
-== Feature Test Macro
-
-This extension defines the macro `SYCL_EXT_ONEAPI_DEFAULT_CONTEXT` to `1` to indicate that it is enabled.
-
+This extension has been deprecated, but the specification is still available
+link:../deprecated/sycl_ext_oneapi_default_context.asciidoc[here].

sycl/include/sycl/detail/generic_type_traits.hpp

@@ -172,7 +172,7 @@ template <typename T> auto convertToOpenCLType(T &&x) {
   } else if constexpr (std::is_same_v<no_ref, ext::oneapi::bfloat16>) {
     // On host, don't interpret BF16 as uint16.
 #ifdef __SYCL_DEVICE_ONLY__
-    using OpenCLType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+    using OpenCLType = sycl::ext::oneapi::bfloat16::Bfloat16StorageT;
     return sycl::bit_cast<OpenCLType>(x);
 #else
     return std::forward<T>(x);