Limit code in try...catch and uglify

mmichel11 · mmichel11 · commit 7020dc276f32 · 2025-01-30T08:22:36.000-06:00
Signed-off-by: Matthew Michel &lt;matthew.michel@intel.com&gt;
diff --git a/include/oneapi/dpl/pstl/hetero/dpcpp/parallel_backend_sycl.h b/include/oneapi/dpl/pstl/hetero/dpcpp/parallel_backend_sycl.h
@@ -1134,17 +1134,17 @@ __parallel_transform_scan(oneapi::dpl::__internal::__device_backend_tag __backen
             using _ScanInputTransform = oneapi::dpl::__internal::__no_op;
             using _WriteOp = oneapi::dpl::__par_backend_hetero::__simple_write_to_id;
 
+            _GenInput __gen_transform{__unary_op};
             try
             {
-                _GenInput __gen_transform{__unary_op};
                 return __parallel_transform_reduce_then_scan(__backend_tag, __exec, __in_rng, __out_rng,
                                                              __gen_transform, __binary_op, __gen_transform,
                                                              _ScanInputTransform{}, _WriteOp{}, __init, _Inclusive{},
                                                              /*_IsUniquePattern=*/std::false_type{});
             }
-            catch (const sycl::exception& e)
+            catch (const sycl::exception& __e)
             {
-                __bypass_sycl_kernel_not_supported(e);
+                __bypass_sycl_kernel_not_supported(__e);
             }
         }
 #endif
@@ -1296,17 +1296,17 @@ __parallel_unique_copy(oneapi::dpl::__internal::__device_backend_tag __backend_t
 #if _ONEDPL_COMPILE_KERNEL
     if (oneapi::dpl::__par_backend_hetero::__is_gpu_with_sg_32(__exec))
     {
+        using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_unique_mask<_BinaryPredicate>;
+        using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<1, _Assign>;
         try
         {
-            using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_unique_mask<_BinaryPredicate>;
-            using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<1, _Assign>;
             return __parallel_reduce_then_scan_copy(__backend_tag, __exec, __rng, __result, __n, _GenMask{__pred},
                                                     _WriteOp{_Assign{}},
                                                     /*_IsUniquePattern=*/std::true_type{});
         }
-        catch (const sycl::exception& e)
+        catch (const sycl::exception& __e)
         {
-            __bypass_sycl_kernel_not_supported(e);
+            __bypass_sycl_kernel_not_supported(__e);
         }
     }
 #endif
@@ -1364,18 +1364,18 @@ __parallel_partition_copy(oneapi::dpl::__internal::__device_backend_tag __backen
 #if _ONEDPL_COMPILE_KERNEL
     if (oneapi::dpl::__par_backend_hetero::__is_gpu_with_sg_32(__exec))
     {
+        using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_UnaryPredicate>;
+        using _WriteOp =
+            oneapi::dpl::__par_backend_hetero::__write_to_id_if_else<oneapi::dpl::__internal::__pstl_assign>;
         try
         {
-            using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_UnaryPredicate>;
-            using _WriteOp =
-                oneapi::dpl::__par_backend_hetero::__write_to_id_if_else<oneapi::dpl::__internal::__pstl_assign>;
             return __parallel_reduce_then_scan_copy(__backend_tag, __exec, __rng, __result, __n, _GenMask{__pred},
                                                     _WriteOp{},
                                                     /*_IsUniquePattern=*/std::false_type{});
         }
-        catch (const sycl::exception& e)
+        catch (const sycl::exception& __e)
         {
-            __bypass_sycl_kernel_not_supported(e);
+            __bypass_sycl_kernel_not_supported(__e);
         }
     }
 #endif
@@ -1421,17 +1421,17 @@ __parallel_copy_if(oneapi::dpl::__internal::__device_backend_tag __backend_tag,
 #if _ONEDPL_COMPILE_KERNEL
     else if (oneapi::dpl::__par_backend_hetero::__is_gpu_with_sg_32(__exec))
     {
+        using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_Pred>;
+        using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<0, _Assign>;
         try
         {
-            using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_Pred>;
-            using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<0, _Assign>;
             return __parallel_reduce_then_scan_copy(__backend_tag, __exec, __in_rng, __out_rng, __n, _GenMask{__pred},
                                                     _WriteOp{__assign},
                                                     /*_IsUniquePattern=*/std::false_type{});
         }
-        catch (const sycl::exception& e)
+        catch (const sycl::exception& __e)
         {
-            __bypass_sycl_kernel_not_supported(e);
+            __bypass_sycl_kernel_not_supported(__e);
         }
     }
 #endif
@@ -1546,9 +1546,9 @@ __parallel_set_op(oneapi::dpl::__internal::__device_backend_tag __backend_tag, c
             return __parallel_set_reduce_then_scan(__backend_tag, __exec, __rng1, __rng2, __result, __comp,
                                                    __is_op_difference);
         }
-        catch (const sycl::exception& e)
+        catch (const sycl::exception& __e)
         {
-            __bypass_sycl_kernel_not_supported(e);
+            __bypass_sycl_kernel_not_supported(__e);
         }
     }
 #endif
@@ -2495,9 +2495,9 @@ __parallel_reduce_by_segment(oneapi::dpl::__internal::__device_backend_tag, cons
                 // past-the-end iterator pair of segmented reduction.
                 return std::get<0>(__res.get()) + 1;
             }
-            catch (const sycl::exception& e)
+            catch (const sycl::exception& __e)
             {
-                __bypass_sycl_kernel_not_supported(e);
+                __bypass_sycl_kernel_not_supported(__e);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -1134,17 +1134,17 @@ __parallel_transform_scan(oneapi::dpl::__internal::__device_backend_tag __backen`
`1134`	`1134`	`using _ScanInputTransform = oneapi::dpl::__internal::__no_op;`
`1135`	`1135`	`using _WriteOp = oneapi::dpl::__par_backend_hetero::__simple_write_to_id;`
`1136`	`1136`
	`1137`	`+ _GenInput __gen_transform{__unary_op};`
`1137`	`1138`	`try`
`1138`	`1139`	`{`
`1139`		`- _GenInput __gen_transform{__unary_op};`
`1140`	`1140`	`return __parallel_transform_reduce_then_scan(__backend_tag, __exec, __in_rng, __out_rng,`
`1141`	`1141`	`__gen_transform, __binary_op, __gen_transform,`
`1142`	`1142`	`_ScanInputTransform{}, _WriteOp{}, __init, _Inclusive{},`
`1143`	`1143`	`/_IsUniquePattern=/std::false_type{});`
`1144`	`1144`	`}`
`1145`		`- catch (const sycl::exception& e)`
	`1145`	`+ catch (const sycl::exception& __e)`
`1146`	`1146`	`{`
`1147`		`- __bypass_sycl_kernel_not_supported(e);`
	`1147`	`+ __bypass_sycl_kernel_not_supported(__e);`
`1148`	`1148`	`}`
`1149`	`1149`	`}`
`1150`	`1150`	`#endif`
`@@ -1296,17 +1296,17 @@ __parallel_unique_copy(oneapi::dpl::__internal::__device_backend_tag __backend_t`
`1296`	`1296`	`#if _ONEDPL_COMPILE_KERNEL`
`1297`	`1297`	`if (oneapi::dpl::__par_backend_hetero::__is_gpu_with_sg_32(__exec))`
`1298`	`1298`	`{`
	`1299`	`+ using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_unique_mask<_BinaryPredicate>;`
	`1300`	`+ using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<1, _Assign>;`
`1299`	`1301`	`try`
`1300`	`1302`	`{`
`1301`		`- using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_unique_mask<_BinaryPredicate>;`
`1302`		`- using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<1, _Assign>;`
`1303`	`1303`	`return __parallel_reduce_then_scan_copy(__backend_tag, __exec, __rng, __result, __n, _GenMask{__pred},`
`1304`	`1304`	`_WriteOp{_Assign{}},`
`1305`	`1305`	`/_IsUniquePattern=/std::true_type{});`
`1306`	`1306`	`}`
`1307`		`- catch (const sycl::exception& e)`
	`1307`	`+ catch (const sycl::exception& __e)`
`1308`	`1308`	`{`
`1309`		`- __bypass_sycl_kernel_not_supported(e);`
	`1309`	`+ __bypass_sycl_kernel_not_supported(__e);`
`1310`	`1310`	`}`
`1311`	`1311`	`}`
`1312`	`1312`	`#endif`
`@@ -1364,18 +1364,18 @@ __parallel_partition_copy(oneapi::dpl::__internal::__device_backend_tag __backen`
`1364`	`1364`	`#if _ONEDPL_COMPILE_KERNEL`
`1365`	`1365`	`if (oneapi::dpl::__par_backend_hetero::__is_gpu_with_sg_32(__exec))`
`1366`	`1366`	`{`
	`1367`	`+ using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_UnaryPredicate>;`
	`1368`	`+ using _WriteOp =`
	`1369`	`+ oneapi::dpl::__par_backend_hetero::__write_to_id_if_else<oneapi::dpl::__internal::__pstl_assign>;`
`1367`	`1370`	`try`
`1368`	`1371`	`{`
`1369`		`- using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_UnaryPredicate>;`
`1370`		`- using _WriteOp =`
`1371`		`- oneapi::dpl::__par_backend_hetero::__write_to_id_if_else<oneapi::dpl::__internal::__pstl_assign>;`
`1372`	`1372`	`return __parallel_reduce_then_scan_copy(__backend_tag, __exec, __rng, __result, __n, _GenMask{__pred},`
`1373`	`1373`	`_WriteOp{},`
`1374`	`1374`	`/_IsUniquePattern=/std::false_type{});`
`1375`	`1375`	`}`
`1376`		`- catch (const sycl::exception& e)`
	`1376`	`+ catch (const sycl::exception& __e)`
`1377`	`1377`	`{`
`1378`		`- __bypass_sycl_kernel_not_supported(e);`
	`1378`	`+ __bypass_sycl_kernel_not_supported(__e);`
`1379`	`1379`	`}`
`1380`	`1380`	`}`
`1381`	`1381`	`#endif`
`@@ -1421,17 +1421,17 @@ __parallel_copy_if(oneapi::dpl::__internal::__device_backend_tag __backend_tag,`
`1421`	`1421`	`#if _ONEDPL_COMPILE_KERNEL`
`1422`	`1422`	`else if (oneapi::dpl::__par_backend_hetero::__is_gpu_with_sg_32(__exec))`
`1423`	`1423`	`{`
	`1424`	`+ using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_Pred>;`
	`1425`	`+ using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<0, _Assign>;`
`1424`	`1426`	`try`
`1425`	`1427`	`{`
`1426`		`- using _GenMask = oneapi::dpl::__par_backend_hetero::__gen_mask<_Pred>;`
`1427`		`- using _WriteOp = oneapi::dpl::__par_backend_hetero::__write_to_id_if<0, _Assign>;`
`1428`	`1428`	`return __parallel_reduce_then_scan_copy(__backend_tag, __exec, __in_rng, __out_rng, __n, _GenMask{__pred},`
`1429`	`1429`	`_WriteOp{__assign},`
`1430`	`1430`	`/_IsUniquePattern=/std::false_type{});`
`1431`	`1431`	`}`
`1432`		`- catch (const sycl::exception& e)`
	`1432`	`+ catch (const sycl::exception& __e)`
`1433`	`1433`	`{`
`1434`		`- __bypass_sycl_kernel_not_supported(e);`
	`1434`	`+ __bypass_sycl_kernel_not_supported(__e);`
`1435`	`1435`	`}`
`1436`	`1436`	`}`
`1437`	`1437`	`#endif`
`@@ -1546,9 +1546,9 @@ __parallel_set_op(oneapi::dpl::__internal::__device_backend_tag __backend_tag, c`
`1546`	`1546`	`return __parallel_set_reduce_then_scan(__backend_tag, __exec, __rng1, __rng2, __result, __comp,`
`1547`	`1547`	`__is_op_difference);`
`1548`	`1548`	`}`
`1549`		`- catch (const sycl::exception& e)`
	`1549`	`+ catch (const sycl::exception& __e)`
`1550`	`1550`	`{`
`1551`		`- __bypass_sycl_kernel_not_supported(e);`
	`1551`	`+ __bypass_sycl_kernel_not_supported(__e);`
`1552`	`1552`	`}`
`1553`	`1553`	`}`
`1554`	`1554`	`#endif`
`@@ -2495,9 +2495,9 @@ __parallel_reduce_by_segment(oneapi::dpl::__internal::__device_backend_tag, cons`
`2495`	`2495`	`// past-the-end iterator pair of segmented reduction.`
`2496`	`2496`	`return std::get<0>(__res.get()) + 1;`
`2497`	`2497`	`}`
`2498`		`- catch (const sycl::exception& e)`
	`2498`	`+ catch (const sycl::exception& __e)`
`2499`	`2499`	`{`
`2500`		`- __bypass_sycl_kernel_not_supported(e);`
	`2500`	`+ __bypass_sycl_kernel_not_supported(__e);`
`2501`	`2501`	`}`
`2502`	`2502`	`}`
`2503`	`2503`	`}`