@@@

Author: SergeyKopienko

include/oneapi/dpl/internal/scan_by_segment_impl.h

@@ -119,18 +119,24 @@ struct __sycl_scan_by_segment_submitter : protected __sycl_submitter_base<_Execu
 {
     friend __sycl_scan_by_segment_submitter_factory;
 
-    template <typename... _Name>
-    using _SegScanWgPhase = __seg_scan_wg_kernel<__is_inclusive, _Name...>;
-
-    template <typename... _Name>
-    using _SegScanPrefixPhase = __seg_scan_prefix_kernel<__is_inclusive, _Name...>;
+    using _submitter_base = __sycl_submitter_base<_ExecutionPolicy>;
 
+  protected:
     template <typename _ExecutionPolicyCtor>
     __sycl_scan_by_segment_submitter(_ExecutionPolicyCtor&& __exec)
         : __sycl_submitter_base<_ExecutionPolicy>(std::forward<_ExecutionPolicyCtor>(__exec))
     {
     }
 
+  public:
+
+    template <typename... _Name>
+    using _SegScanWgPhase = __seg_scan_wg_kernel<__is_inclusive, _Name...>;
+
+    template <typename... _Name>
+    using _SegScanPrefixPhase = __seg_scan_prefix_kernel<__is_inclusive, _Name...>;
+
+
     template <typename _BackendTag, typename _Range1, typename _Range2, typename _Range3, typename _BinaryPredicate,
               typename _BinaryOperator, typename _T>
     void
@@ -153,34 +159,34 @@ struct __sycl_scan_by_segment_submitter : protected __sycl_submitter_base<_Execu
 
         // Limit the work-group size to prevent large sizes on CPUs. Empirically found value.
         // This value exceeds the current practical limit for GPUs, but may need to be re-evaluated in the future.
-        std::size_t __wgroup_size = oneapi::dpl::__internal::__max_work_group_size(__exec, (std::size_t)2048);
+        std::size_t __wgroup_size = oneapi::dpl::__internal::__max_work_group_size(_submitter_base::__exec, (std::size_t)2048);
 
         // We require 2 * sizeof(__val_type) * __wgroup_size of SLM for the work group segmented scan. We add
         // an additional sizeof(__val_type) * __wgroup_size requirement to ensure sufficient SLM for the group algorithms.
         __wgroup_size =
-            oneapi::dpl::__internal::__slm_adjusted_work_group_size(__exec, 3 * sizeof(__val_type), __wgroup_size);
+            oneapi::dpl::__internal::__slm_adjusted_work_group_size(_submitter_base::__exec, 3 * sizeof(__val_type), __wgroup_size);
 
 #if _ONEDPL_COMPILE_KERNEL
         auto __seg_scan_wg_kernel =
-            __par_backend_hetero::__internal::__kernel_compiler<_SegScanWgKernel>::__compile(__exec);
+            __par_backend_hetero::__internal::__kernel_compiler<_SegScanWgKernel>::__compile(_submitter_base::__exec);
         auto __seg_scan_prefix_kernel =
-            __par_backend_hetero::__internal::__kernel_compiler<_SegScanPrefixKernel>::__compile(__exec);
+            __par_backend_hetero::__internal::__kernel_compiler<_SegScanPrefixKernel>::__compile(_submitter_base::__exec);
         __wgroup_size =
-            ::std::min({__wgroup_size, oneapi::dpl::__internal::__kernel_work_group_size(__exec, __seg_scan_wg_kernel),
-                        oneapi::dpl::__internal::__kernel_work_group_size(__exec, __seg_scan_prefix_kernel)});
+            ::std::min({__wgroup_size, oneapi::dpl::__internal::__kernel_work_group_size(_submitter_base::__exec, __seg_scan_wg_kernel),
+                        oneapi::dpl::__internal::__kernel_work_group_size(_submitter_base::__exec, __seg_scan_prefix_kernel)});
 #endif
 
         ::std::size_t __n_groups = __internal::__dpl_ceiling_div(__n, __wgroup_size * __vals_per_item);
 
         auto __partials =
-            oneapi::dpl::__par_backend_hetero::__buffer<_ExecutionPolicy, __val_type>(__exec, __n_groups).get_buffer();
+            oneapi::dpl::__par_backend_hetero::__buffer<_ExecutionPolicy, __val_type>(_submitter_base::__exec, __n_groups).get_buffer();
 
         // the number of segment ends found in each work group
         auto __seg_ends =
-            oneapi::dpl::__par_backend_hetero::__buffer<_ExecutionPolicy, bool>(__exec, __n_groups).get_buffer();
+            oneapi::dpl::__par_backend_hetero::__buffer<_ExecutionPolicy, bool>(_submitter_base::__exec, __n_groups).get_buffer();
 
         // 1. Work group reduction
-        auto __wg_scan = __exec.queue().submit([&](sycl::handler& __cgh) {
+        auto __wg_scan = _submitter_base::__exec.queue().submit([&](sycl::handler& __cgh) {
             auto __partials_acc = __partials.template get_access<sycl::access_mode::write>(__cgh);
             auto __seg_ends_acc = __seg_ends.template get_access<sycl::access_mode::write>(__cgh);
 
@@ -280,7 +286,7 @@ struct __sycl_scan_by_segment_submitter : protected __sycl_submitter_base<_Execu
         });
 
         // 2. Apply work group carry outs, calculate output indices, and load results into correct indices.
-        __exec.queue()
+        _submitter_base::__exec.queue()
             .submit([&](sycl::handler& __cgh) {
                 oneapi::dpl::__ranges::__require_access(__cgh, __keys, __out_values);
 

include/oneapi/dpl/internal/sycl_submitter_base_impl.h

@@ -60,6 +60,14 @@ struct __sycl_submitter_base
         : __exec(std::forward<_ExecutionPolicyCtor>(__exec))
     {
     }
+
+public:
+
+   inline const _ExecutionPolicy&
+   get_execution_policy() const
+   {
+       return __exec;
+   }
 };
 
 } // namespace internal

include/oneapi/dpl/pstl/hetero/dpcpp/parallel_backend_sycl.h

@@ -225,13 +225,13 @@ class __scan_copy_single_wg_kernel;
 //------------------------------------------------------------------------
 
 // Please see the comment above __parallel_for_small_submitter for optional kernel name explanation
-template <typename _PropagateScanName>
+template <typename _ExecutionPolicy, typename _PropagateScanName>
 struct __parallel_scan_submitter;
 
 // Even if this class submits three kernel optional name is allowed to be only for one of them
 // because for two others we have to provide the name to get the reliable work group size
-template <typename... _PropagateScanName>
-struct __parallel_scan_submitter<__internal::__optional_kernel_name<_PropagateScanName...>>;
+template <typename _ExecutionPolicy, typename... _PropagateScanName>
+struct __parallel_scan_submitter<_ExecutionPolicy, __internal::__optional_kernel_name<_PropagateScanName...>>;
 
 struct __parallel_scan_submitter_factory
 {
@@ -249,15 +249,21 @@ struct __parallel_scan_submitter_factory
 // Even if this class submits three kernel optional name is allowed to be only for one of them
 // because for two others we have to provide the name to get the reliable work group size
 template <typename _ExecutionPolicy, typename... _PropagateScanName>
-struct __parallel_scan_submitter<__internal::__optional_kernel_name<_PropagateScanName...>>
-    : protected __sycl_submitter_base<_ExecutionPolicy>
+struct __parallel_scan_submitter<_ExecutionPolicy, __internal::__optional_kernel_name<_PropagateScanName...>>
+    : protected internal::__sycl_submitter_base<_ExecutionPolicy>
 {
+    friend __parallel_scan_submitter_factory;
+
+    using _submitter_base = internal::__sycl_submitter_base<_ExecutionPolicy>;
+
+  protected:
     template <typename _ExecutionPolicyCtor>
     __parallel_scan_submitter(_ExecutionPolicyCtor&& __exec)
-        : __sycl_submitter_base<_ExecutionPolicy>(std::forward<_ExecutionPolicyCtor>(__exec))
+        : internal::__sycl_submitter_base<_ExecutionPolicy>(std::forward<_ExecutionPolicyCtor>(__exec))
     {
     }
 
+  public:
     template <typename _Range1, typename _Range2, typename _InitType,
               typename _LocalScan, typename _GroupScan, typename _GlobalScan>
     auto
@@ -273,21 +279,21 @@ struct __parallel_scan_submitter<__internal::__optional_kernel_name<_PropagateSc
         auto __n = __rng1.size();
         assert(__n > 0);
 
-        auto __max_cu = oneapi::dpl::__internal::__max_compute_units(__exec);
+        auto __max_cu = oneapi::dpl::__internal::__max_compute_units(_submitter_base::__exec);
         // get the work group size adjusted to the local memory limit
         // TODO: find a way to generalize getting of reliable work-group sizes
-        ::std::size_t __wgroup_size = oneapi::dpl::__internal::__slm_adjusted_work_group_size(__exec, sizeof(_Type));
+        ::std::size_t __wgroup_size = oneapi::dpl::__internal::__slm_adjusted_work_group_size(_submitter_base::__exec, sizeof(_Type));
         // Limit the work-group size to prevent large sizes on CPUs. Empirically found value.
         // This value matches the current practical limit for GPUs, but may need to be re-evaluated in the future.
         __wgroup_size = std::min(__wgroup_size, (std::size_t)1024);
 
 #if _ONEDPL_COMPILE_KERNEL
         //Actually there is one kernel_bundle for the all kernels of the pattern.
-        auto __kernels = __internal::__kernel_compiler<_LocalScanKernel, _GroupScanKernel>::__compile(__exec);
+        auto __kernels = __internal::__kernel_compiler<_LocalScanKernel, _GroupScanKernel>::__compile(_submitter_base::__exec);
         auto __kernel_1 = __kernels[0];
         auto __kernel_2 = __kernels[1];
-        auto __wgroup_size_kernel_1 = oneapi::dpl::__internal::__kernel_work_group_size(__exec, __kernel_1);
-        auto __wgroup_size_kernel_2 = oneapi::dpl::__internal::__kernel_work_group_size(__exec, __kernel_2);
+        auto __wgroup_size_kernel_1 = oneapi::dpl::__internal::__kernel_work_group_size(_submitter_base::__exec, __kernel_1);
+        auto __wgroup_size_kernel_2 = oneapi::dpl::__internal::__kernel_work_group_size(_submitter_base::__exec, __kernel_2);
         __wgroup_size = ::std::min({__wgroup_size, __wgroup_size_kernel_1, __wgroup_size_kernel_2});
 #endif
 
@@ -298,12 +304,12 @@ struct __parallel_scan_submitter<__internal::__optional_kernel_name<_PropagateSc
         // Storage for the results of scan for each workgroup
 
         using __result_and_scratch_storage_t = __result_and_scratch_storage<_ExecutionPolicy, _Type>;
-        __result_and_scratch_storage_t __result_and_scratch{__exec, 1, __n_groups + 1};
+        __result_and_scratch_storage_t __result_and_scratch{_submitter_base::__exec, 1, __n_groups + 1};
 
-        _PRINT_INFO_IN_DEBUG_MODE(__exec, __wgroup_size, __max_cu);
+        _PRINT_INFO_IN_DEBUG_MODE(_submitter_base::__exec, __wgroup_size, __max_cu);
 
         // 1. Local scan on each workgroup
-        auto __submit_event = __exec.queue().submit([&](sycl::handler& __cgh) {
+        auto __submit_event = _submitter_base::__exec.queue().submit([&](sycl::handler& __cgh) {
             oneapi::dpl::__ranges::__require_access(__cgh, __rng1, __rng2); //get an access to data under SYCL buffer
             auto __temp_acc = __result_and_scratch.template __get_scratch_acc<sycl::access_mode::write>(
                 __cgh, __dpl_sycl::__no_init{});
@@ -325,7 +331,7 @@ struct __parallel_scan_submitter<__internal::__optional_kernel_name<_PropagateSc
         if (__n_groups > 1)
         {
             auto __iters_per_single_wg = oneapi::dpl::__internal::__dpl_ceiling_div(__n_groups, __wgroup_size);
-            __submit_event = __exec.queue().submit([&](sycl::handler& __cgh) {
+            __submit_event = _submitter_base::__exec.queue().submit([&](sycl::handler& __cgh) {
                 __cgh.depends_on(__submit_event);
                 auto __temp_acc = __result_and_scratch.template __get_scratch_acc<sycl::access_mode::read_write>(__cgh);
                 __dpl_sycl::__local_accessor<_Type> __local_acc(__wgroup_size, __cgh);
@@ -346,7 +352,7 @@ struct __parallel_scan_submitter<__internal::__optional_kernel_name<_PropagateSc
         }
 
         // 3. Final scan for whole range
-        auto __final_event = __exec.queue().submit([&](sycl::handler& __cgh) {
+        auto __final_event = _submitter_base::__exec.queue().submit([&](sycl::handler& __cgh) {
             __cgh.depends_on(__submit_event);
             oneapi::dpl::__ranges::__require_access(__cgh, __rng1, __rng2); //get an access to data under SYCL buffer
             auto __temp_acc = __result_and_scratch.template __get_scratch_acc<sycl::access_mode::read>(__cgh);