Apply GitHUB clang format

SergeyKopienko · SergeyKopienko · commit b7cd78941c5e · 2025-06-11T11:27:07.000+02:00
diff --git a/include/oneapi/dpl/pstl/hetero/dpcpp/parallel_backend_sycl_utils.h b/include/oneapi/dpl/pstl/hetero/dpcpp/parallel_backend_sycl_utils.h
@@ -493,12 +493,12 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
     };
 
   private:
-
     // struct __result_and_scratch_storage_impl - internal implementation of result and scratch storage
     // for support of pimpl-implementation pattern
     class __result_and_scratch_storage_impl : __result_and_scratch_storage_base
     {
-        static constexpr bool __is_the_same_result_and_scratch_data_types()
+        static constexpr bool
+        __is_the_same_result_and_scratch_data_types()
         {
 #if _ONEDPL_SYCL2020_DEFAULT_ACCESSOR_CONSTRUCTOR_PRESENT
             return std::is_same_v<_TResult, _TScratchData>;
@@ -620,7 +620,9 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
             __get_value_impl(const sycl::queue& __q, std::size_t _Idx, std::size_t __scratch_n) const
             {
                 _TResult __tmp;
-                const_cast<sycl::queue&>(__q).memcpy(&__tmp, __scratch.get() + __scratch_n + _Idx, 1 * sizeof(_TResult)).wait();
+                const_cast<sycl::queue&>(__q)
+                    .memcpy(&__tmp, __scratch.get() + __scratch_n + _Idx, 1 * sizeof(_TResult))
+                    .wait();
                 return __tmp;
             }
         };
@@ -663,63 +665,64 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
                 return __results->get_host_access(sycl::read_only)[__scratch_n + _Idx];
             }
         };
-        using BufferPlacementVariants = std::variant<BufferPlacementInUSMTogether, BufferPlacementInUSMSeparate, BufferPlacementInSyclBufTogether, BufferPlacementInSyclBufSeparate>;
+        using BufferPlacementVariants =
+            std::variant<BufferPlacementInUSMTogether, BufferPlacementInUSMSeparate, BufferPlacementInSyclBufTogether,
+                         BufferPlacementInSyclBufSeparate>;
 
-        BufferPlacementVariants __buffers;    // All internal containers
+        BufferPlacementVariants __buffers; // All internal containers
 
       private:
-
-          static BufferPlacementVariants
+        static BufferPlacementVariants
         __create_buffers(sycl::queue& __q_ref, std::size_t __scratch_n)
         {
             if (__use_USM_allocations(__q_ref))
             {
                 // Separate scratch (device) and result (host) allocations on performant backends (i.e. L0)
-                const sycl::usm::alloc __alloc_type_results = __use_USM_host_allocations(__q_ref) ? sycl::usm::alloc::host : sycl::usm::alloc::device;
+                const sycl::usm::alloc __alloc_type_results =
+                    __use_USM_host_allocations(__q_ref) ? sycl::usm::alloc::host : sycl::usm::alloc::device;
                 constexpr sycl::usm::alloc __alloc_type_scratch = sycl::usm::alloc::device;
 
                 if (__is_the_same_result_and_scratch_data_types() && __alloc_type_scratch == __alloc_type_results)
                 {
                     return BufferPlacementVariants(BufferPlacementInUSMTogether{
-                        { /* empty initialization for wait_and_throw impl */ },
+                        {/* empty initialization for wait_and_throw impl */},
                         BufferPlacementInUsmMemory::template __create<_TScratchData, sycl::usm::alloc::device>(
                             &__q_ref, __scratch_n + _NResults)});
                 }
                 else
                 {
                     return BufferPlacementVariants(BufferPlacementInUSMSeparate{
-                        { /* empty initialization for wait_and_throw impl */ },
-                        BufferPlacementInUsmMemory::template __create<_TScratchData, sycl::usm::alloc::device>(&__q_ref,
-                                                                                                      __scratch_n),
+                        {/* empty initialization for wait_and_throw impl */},
+                        BufferPlacementInUsmMemory::template __create<_TScratchData, sycl::usm::alloc::device>(
+                            &__q_ref, __scratch_n),
                         __alloc_type_results == sycl::usm::alloc::device
-                            ? BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::device>(&__q_ref, _NResults)
-                            : BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::host>(&__q_ref, _NResults)});
+                            ? BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::device>(
+                                  &__q_ref, _NResults)
+                            : BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::host>(
+                                  &__q_ref, _NResults)});
                 }
             }
             else
             {
                 if (__is_the_same_result_and_scratch_data_types())
                 {
                     return BufferPlacementVariants(BufferPlacementInSyclBufTogether{
-                        { /* empty initialization for wait_and_throw impl */ },
+                        {/* empty initialization for wait_and_throw impl */},
                         BufferPlacementInSyclBuf::template __create<_TScratchData>(__scratch_n + _NResults)});
                 }
                 else
                 {
                     return BufferPlacementVariants(BufferPlacementInSyclBufSeparate{
-                        { /* empty initialization for wait_and_throw impl */ },
+                        {/* empty initialization for wait_and_throw impl */},
                         BufferPlacementInSyclBuf::template __create<_TScratchData>(__scratch_n),
                         BufferPlacementInSyclBuf::template __create<_TResult>(_NResults)});
                 }
             }
         }
 
       public:
-
         __result_and_scratch_storage_impl(sycl::queue& __q_ref, std::size_t __scratch_n)
-            : __q{__q_ref}
-            , __scratch_n{__scratch_n}
-            , __buffers(__create_buffers(__q, __scratch_n))
+            : __q{__q_ref}, __scratch_n{__scratch_n}, __buffers(__create_buffers(__q, __scratch_n))
         {
         }
 
@@ -729,7 +732,8 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
         {
             return std::visit(
                 [&](auto&& __arg) {
-                    return __get_scratch_acc_impl<_AccessMode>(__cgh, __prop_list, std::forward<decltype(__arg)>(__arg));
+                    return __get_scratch_acc_impl<_AccessMode>(__cgh, __prop_list,
+                                                               std::forward<decltype(__arg)>(__arg));
                 },
                 __buffers);
         }
@@ -780,12 +784,12 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
 
             const sycl::queue& __q_ref = __q;
             const std::size_t __s_n = __scratch_n;
-            return std::visit([__q_ref, __s_n](auto&& __arg) { return __arg.__get_value_impl(__q_ref, _Idx, __s_n); }, __buffers);
+            return std::visit([__q_ref, __s_n](auto&& __arg) { return __arg.__get_value_impl(__q_ref, _Idx, __s_n); },
+                              __buffers);
         }
 
-    // __result_and_scratch_storage_base
-    public:
-
+        // __result_and_scratch_storage_base
+      public:
         virtual std::size_t
         __get_data(sycl::event __event, std::size_t* __p_buf) const override
         {
@@ -799,17 +803,15 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
             return 0;
         }
 
-    private:
-
+      private:
         // Only use USM host allocations on L0 GPUs. Other devices show significant slowdowns and will use a device allocation instead.
         static bool
         __use_USM_host_allocations(sycl::queue& __q)
         {
 #if _ONEDPL_SYCL2020_DEFAULT_ACCESSOR_CONSTRUCTOR_PRESENT && _ONEDPL_SYCL_L0_EXT_PRESENT
             const sycl::device& __device = __q.get_device();
-            if (__device.is_gpu()
-                && __device.has(sycl::aspect::usm_host_allocations)
-                && __device.get_backend() != __dpl_sycl::__level_zero_backend)
+            if (__device.is_gpu() && __device.has(sycl::aspect::usm_host_allocations) &&
+                __device.get_backend() != __dpl_sycl::__level_zero_backend)
             {
                 return true;
             }
@@ -883,7 +885,8 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
             }
         }
 
-        void __wait_and_throw(sycl::event& __event) const
+        void
+        __wait_and_throw(sycl::event& __event) const
         {
             return std::visit([&](auto&& __arg) { __arg.__wait_and_throw_impl(__event); }, __buffers);
         }
@@ -894,7 +897,6 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
     std::unique_ptr<__result_and_scratch_storage_impl> __impl;
 
   public:
-
     __result_and_scratch_storage(sycl::queue& __q_ref, std::size_t __scratch_n)
         : __impl(std::make_unique<__result_and_scratch_storage_impl>(__q_ref, __scratch_n))
     {
@@ -936,9 +938,8 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base
         return __impl->template __get_value<_Idx>();
     }
 
-// __result_and_scratch_storage_base
+    // __result_and_scratch_storage_base
   public:
-
     virtual std::size_t
     __get_data(sycl::event __event, std::size_t* __p_buf) const override
     {
@@ -1003,7 +1004,6 @@ class __future : private std::tuple<_Args...>
     }
 
   public:
-
     template <typename TEvent, typename... TArgs>
     __future(TEvent&& __e, TArgs&&... __args)
         : __base_t(std::forward<TArgs>(__args)...), __my_event(std::forward<TEvent>(__e))

Original file line number	Diff line number	Diff line change
`@@ -493,12 +493,12 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`493`	`493`	`};`
`494`	`494`
`495`	`495`	`private:`
`496`		`-`
`497`	`496`	`// struct __result_and_scratch_storage_impl - internal implementation of result and scratch storage`
`498`	`497`	`// for support of pimpl-implementation pattern`
`499`	`498`	`class __result_and_scratch_storage_impl : __result_and_scratch_storage_base`
`500`	`499`	`{`
`501`		`- static constexpr bool __is_the_same_result_and_scratch_data_types()`
	`500`	`+ static constexpr bool`
	`501`	`+ __is_the_same_result_and_scratch_data_types()`
`502`	`502`	`{`
`503`	`503`	`#if _ONEDPL_SYCL2020_DEFAULT_ACCESSOR_CONSTRUCTOR_PRESENT`
`504`	`504`	`return std::is_same_v<_TResult, _TScratchData>;`
`@@ -620,7 +620,9 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`620`	`620`	`__get_value_impl(const sycl::queue& __q, std::size_t _Idx, std::size_t __scratch_n) const`
`621`	`621`	`{`
`622`	`622`	`_TResult __tmp;`
`623`		`- const_cast<sycl::queue&>(__q).memcpy(&__tmp, __scratch.get() + __scratch_n + _Idx, 1 * sizeof(_TResult)).wait();`
	`623`	`+ const_cast<sycl::queue&>(__q)`
	`624`	`+ .memcpy(&__tmp, __scratch.get() + __scratch_n + _Idx, 1 * sizeof(_TResult))`
	`625`	`+ .wait();`
`624`	`626`	`return __tmp;`
`625`	`627`	`}`
`626`	`628`	`};`
`@@ -663,63 +665,64 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`663`	`665`	`return __results->get_host_access(sycl::read_only)[__scratch_n + _Idx];`
`664`	`666`	`}`
`665`	`667`	`};`
`666`		`- using BufferPlacementVariants = std::variant<BufferPlacementInUSMTogether, BufferPlacementInUSMSeparate, BufferPlacementInSyclBufTogether, BufferPlacementInSyclBufSeparate>;`
	`668`	`+ using BufferPlacementVariants =`
	`669`	`+ std::variant<BufferPlacementInUSMTogether, BufferPlacementInUSMSeparate, BufferPlacementInSyclBufTogether,`
	`670`	`+ BufferPlacementInSyclBufSeparate>;`
`667`	`671`
`668`		`- BufferPlacementVariants __buffers; // All internal containers`
	`672`	`+ BufferPlacementVariants __buffers; // All internal containers`
`669`	`673`
`670`	`674`	`private:`
`671`		`-`
`672`		`- static BufferPlacementVariants`
	`675`	`+ static BufferPlacementVariants`
`673`	`676`	`__create_buffers(sycl::queue& __q_ref, std::size_t __scratch_n)`
`674`	`677`	`{`
`675`	`678`	`if (__use_USM_allocations(__q_ref))`
`676`	`679`	`{`
`677`	`680`	`// Separate scratch (device) and result (host) allocations on performant backends (i.e. L0)`
`678`		`- const sycl::usm::alloc __alloc_type_results = __use_USM_host_allocations(__q_ref) ? sycl::usm::alloc::host : sycl::usm::alloc::device;`
	`681`	`+ const sycl::usm::alloc __alloc_type_results =`
	`682`	`+ __use_USM_host_allocations(__q_ref) ? sycl::usm::alloc::host : sycl::usm::alloc::device;`
`679`	`683`	`constexpr sycl::usm::alloc __alloc_type_scratch = sycl::usm::alloc::device;`
`680`	`684`
`681`	`685`	`if (__is_the_same_result_and_scratch_data_types() && __alloc_type_scratch == __alloc_type_results)`
`682`	`686`	`{`
`683`	`687`	`return BufferPlacementVariants(BufferPlacementInUSMTogether{`
`684`		`- { /* empty initialization for wait_and_throw impl */ },`
	`688`	`+ {/* empty initialization for wait_and_throw impl */},`
`685`	`689`	`BufferPlacementInUsmMemory::template __create<_TScratchData, sycl::usm::alloc::device>(`
`686`	`690`	`&__q_ref, __scratch_n + _NResults)});`
`687`	`691`	`}`
`688`	`692`	`else`
`689`	`693`	`{`
`690`	`694`	`return BufferPlacementVariants(BufferPlacementInUSMSeparate{`
`691`		`- { /* empty initialization for wait_and_throw impl */ },`
`692`		`- BufferPlacementInUsmMemory::template __create<_TScratchData, sycl::usm::alloc::device>(&__q_ref,`
`693`		`- __scratch_n),`
	`695`	`+ {/* empty initialization for wait_and_throw impl */},`
	`696`	`+ BufferPlacementInUsmMemory::template __create<_TScratchData, sycl::usm::alloc::device>(`
	`697`	`+ &__q_ref, __scratch_n),`
`694`	`698`	`__alloc_type_results == sycl::usm::alloc::device`
`695`		`- ? BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::device>(&__q_ref, _NResults)`
`696`		`- : BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::host>(&__q_ref, _NResults)});`
	`699`	`+ ? BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::device>(`
	`700`	`+ &__q_ref, _NResults)`
	`701`	`+ : BufferPlacementInUsmMemory::template __create<_TResult, sycl::usm::alloc::host>(`
	`702`	`+ &__q_ref, _NResults)});`
`697`	`703`	`}`
`698`	`704`	`}`
`699`	`705`	`else`
`700`	`706`	`{`
`701`	`707`	`if (__is_the_same_result_and_scratch_data_types())`
`702`	`708`	`{`
`703`	`709`	`return BufferPlacementVariants(BufferPlacementInSyclBufTogether{`
`704`		`- { /* empty initialization for wait_and_throw impl */ },`
	`710`	`+ {/* empty initialization for wait_and_throw impl */},`
`705`	`711`	`BufferPlacementInSyclBuf::template __create<_TScratchData>(__scratch_n + _NResults)});`
`706`	`712`	`}`
`707`	`713`	`else`
`708`	`714`	`{`
`709`	`715`	`return BufferPlacementVariants(BufferPlacementInSyclBufSeparate{`
`710`		`- { /* empty initialization for wait_and_throw impl */ },`
	`716`	`+ {/* empty initialization for wait_and_throw impl */},`
`711`	`717`	`BufferPlacementInSyclBuf::template __create<_TScratchData>(__scratch_n),`
`712`	`718`	`BufferPlacementInSyclBuf::template __create<_TResult>(_NResults)});`
`713`	`719`	`}`
`714`	`720`	`}`
`715`	`721`	`}`
`716`	`722`
`717`	`723`	`public:`
`718`		`-`
`719`	`724`	`__result_and_scratch_storage_impl(sycl::queue& __q_ref, std::size_t __scratch_n)`
`720`		`- : __q{__q_ref}`
`721`		`- , __scratch_n{__scratch_n}`
`722`		`- , __buffers(__create_buffers(__q, __scratch_n))`
	`725`	`+ : __q{__q_ref}, __scratch_n{__scratch_n}, __buffers(__create_buffers(__q, __scratch_n))`
`723`	`726`	`{`
`724`	`727`	`}`
`725`	`728`
`@@ -729,7 +732,8 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`729`	`732`	`{`
`730`	`733`	`return std::visit(`
`731`	`734`	`[&](auto&& __arg) {`
`732`		`- return __get_scratch_acc_impl<_AccessMode>(__cgh, __prop_list, std::forward<decltype(__arg)>(__arg));`
	`735`	`+ return __get_scratch_acc_impl<_AccessMode>(__cgh, __prop_list,`
	`736`	`+ std::forward<decltype(__arg)>(__arg));`
`733`	`737`	`},`
`734`	`738`	`__buffers);`
`735`	`739`	`}`
`@@ -780,12 +784,12 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`780`	`784`
`781`	`785`	`const sycl::queue& __q_ref = __q;`
`782`	`786`	`const std::size_t __s_n = __scratch_n;`
`783`		`- return std::visit([__q_ref, __s_n](auto&& __arg) { return __arg.__get_value_impl(__q_ref, _Idx, __s_n); }, __buffers);`
	`787`	`+ return std::visit([__q_ref, __s_n](auto&& __arg) { return __arg.__get_value_impl(__q_ref, _Idx, __s_n); },`
	`788`	`+ __buffers);`
`784`	`789`	`}`
`785`	`790`
`786`		`- // __result_and_scratch_storage_base`
`787`		`- public:`
`788`		`-`
	`791`	`+ // __result_and_scratch_storage_base`
	`792`	`+ public:`
`789`	`793`	`virtual std::size_t`
`790`	`794`	`__get_data(sycl::event __event, std::size_t* __p_buf) const override`
`791`	`795`	`{`
`@@ -799,17 +803,15 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`799`	`803`	`return 0;`
`800`	`804`	`}`
`801`	`805`
`802`		`- private:`
`803`		`-`
	`806`	`+ private:`
`804`	`807`	`// Only use USM host allocations on L0 GPUs. Other devices show significant slowdowns and will use a device allocation instead.`
`805`	`808`	`static bool`
`806`	`809`	`__use_USM_host_allocations(sycl::queue& __q)`
`807`	`810`	`{`
`808`	`811`	`#if _ONEDPL_SYCL2020_DEFAULT_ACCESSOR_CONSTRUCTOR_PRESENT && _ONEDPL_SYCL_L0_EXT_PRESENT`
`809`	`812`	`const sycl::device& __device = __q.get_device();`
`810`		`- if (__device.is_gpu()`
`811`		`- && __device.has(sycl::aspect::usm_host_allocations)`
`812`		`- && __device.get_backend() != __dpl_sycl::__level_zero_backend)`
	`813`	`+ if (__device.is_gpu() && __device.has(sycl::aspect::usm_host_allocations) &&`
	`814`	`+ __device.get_backend() != __dpl_sycl::__level_zero_backend)`
`813`	`815`	`{`
`814`	`816`	`return true;`
`815`	`817`	`}`
`@@ -883,7 +885,8 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`883`	`885`	`}`
`884`	`886`	`}`
`885`	`887`
`886`		`- void __wait_and_throw(sycl::event& __event) const`
	`888`	`+ void`
	`889`	`+ __wait_and_throw(sycl::event& __event) const`
`887`	`890`	`{`
`888`	`891`	`return std::visit([&](auto&& __arg) { __arg.__wait_and_throw_impl(__event); }, __buffers);`
`889`	`892`	`}`
`@@ -894,7 +897,6 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`894`	`897`	`std::unique_ptr<__result_and_scratch_storage_impl> __impl;`
`895`	`898`
`896`	`899`	`public:`
`897`		`-`
`898`	`900`	`__result_and_scratch_storage(sycl::queue& __q_ref, std::size_t __scratch_n)`
`899`	`901`	`: __impl(std::make_unique<__result_and_scratch_storage_impl>(__q_ref, __scratch_n))`
`900`	`902`	`{`
`@@ -936,9 +938,8 @@ struct __result_and_scratch_storage : __result_and_scratch_storage_base`
`936`	`938`	`return __impl->template __get_value<_Idx>();`
`937`	`939`	`}`
`938`	`940`
`939`		`-// __result_and_scratch_storage_base`
	`941`	`+ // __result_and_scratch_storage_base`
`940`	`942`	`public:`
`941`		`-`
`942`	`943`	`virtual std::size_t`
`943`	`944`	`__get_data(sycl::event __event, std::size_t* __p_buf) const override`
`944`	`945`	`{`
`@@ -1003,7 +1004,6 @@ class __future : private std::tuple<_Args...>`
`1003`	`1004`	`}`
`1004`	`1005`
`1005`	`1006`	`public:`
`1006`		`-`
`1007`	`1007`	`template <typename TEvent, typename... TArgs>`
`1008`	`1008`	`__future(TEvent&& __e, TArgs&&... __args)`
`1009`	`1009`	`: __base_t(std::forward<TArgs>(__args)...), __my_event(std::forward<TEvent>(__e))`