A hot compilation fix for MacOS, OpenMP backend; + full qualified names for some internal functions

[MikeDvorskiy]

Summary

A hot compilation fix for MacOS, OpenMP backend; + full qualified names for some internal functions

[nadiasvertex]

LGTM

pstl/include/pstl/internal/omp/parallel_for.h

 {
     // initial partition of the iteration space into chunks
     auto __policy = __omp_backend::__chunk_partitioner(__first, __last);
 
     // To avoid over-subscription we use taskloop for the nested parallelism
     _PSTL_PRAGMA(omp taskloop untied mergeable)
     for (std::size_t __chunk = 0; __chunk < __policy.__n_chunks; ++__chunk)
     {
-        __omp_backend::__process_chunk(__policy, __first, __chunk, __f);
+        __pstl::__omp_backend::__process_chunk(__policy, __first, __chunk, __f);
     }
 }
 
 //------------------------------------------------------------------------
 // Notation:
 // Evaluation of brick f[i,j) for each subrange [i,j) of [first, last)
 //------------------------------------------------------------------------
 

pstl/include/pstl/internal/omp/parallel_invoke.h

 }
 
 template <class _ExecutionPolicy, typename _F1, typename _F2>
 void
 __parallel_invoke(_ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
 {
     if (omp_in_parallel())
     {
-        __parallel_invoke_body(std::forward<_F1>(__f1), std::forward<_F2>(__f2));
+        __pstl::__omp_backend::__parallel_invoke_body(std::forward<_F1>(__f1), std::forward<_F2>(__f2));
     }
     else
     {
         _PSTL_PRAGMA(omp parallel)
         _PSTL_PRAGMA(omp single nowait)
-        __parallel_invoke_body(std::forward<_F1>(__f1), std::forward<_F2>(__f2));
+        __pstl::__omp_backend::__parallel_invoke_body(std::forward<_F1>(__f1), std::forward<_F2>(__f2));
     }
 }
 
 } // namespace __omp_backend
 } // namespace __pstl
 #endif // _PSTL_INTERNAL_OMP_PARALLEL_INVOKE_H

pstl/include/pstl/internal/omp/parallel_merge.h

else
         __xm = __xs + (__size_x / 2);
         __ym = std::lower_bound(__ys, __ye, *__xm, __comp);
     }
 
     auto __zm = __zs + (__xm - __xs) + (__ym - __ys);
 
     _PSTL_PRAGMA(omp task untied mergeable default(none)
                      firstprivate(__xs, __xm, __ys, __ym, __zs, __comp, __leaf_merge))
-    __parallel_merge_body(__xm - __xs, __ym - __ys, __xs, __xm, __ys, __ym, __zs, __comp, __leaf_merge);
+    __pstl::__omp_backend::__parallel_merge_body(__xm - __xs, __ym - __ys, __xs, __xm, __ys, __ym, __zs, __comp,
+                                                      __leaf_merge);
 
     _PSTL_PRAGMA(omp task untied mergeable default(none)
                      firstprivate(__xm, __xe, __ym, __ye, __zm, __comp, __leaf_merge))
-    __parallel_merge_body(__xe - __xm, __ye - __ym, __xm, __xe, __ym, __ye, __zm, __comp, __leaf_merge);
+    __pstl::__omp_backend::__parallel_merge_body(__xe - __xm, __ye - __ym, __xm, __xe, __ym, __ye, __zm, __comp,
+                                                      __leaf_merge);
 
     _PSTL_PRAGMA(omp taskwait)
 }
 
 template <class _ExecutionPolicy, typename _RandomAccessIterator1, typename _RandomAccessIterator2,
           typename _RandomAccessIterator3, typename _Compare, typename _LeafMerge>
 void
 __parallel_merge(_ExecutionPolicy&& /*__exec*/, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe,
                  _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp,
                  _LeafMerge __leaf_merge)
 
 {
     std::size_t __size_x = __xe - __xs;
     std::size_t __size_y = __ye - __ys;
 
     /*
      * Run the merge in parallel by chunking it up. Use the smaller range (if any) as the iteration range, and the
      * larger range as the search range.
      */
 
     if (omp_in_parallel())
     {
-        __parallel_merge_body(__size_x, __size_y, __xs, __xe, __ys, __ye, __zs, __comp, __leaf_merge);
+        __pstl::__omp_backend::__parallel_merge_body(__size_x, __size_y, __xs, __xe, __ys, __ye, __zs, __comp,
+                                                          __leaf_merge);
     }
     else
     {
         _PSTL_PRAGMA(omp parallel)
         {
             _PSTL_PRAGMA(omp single nowait)
-            __parallel_merge_body(__size_x, __size_y, __xs, __xe, __ys, __ye, __zs, __comp, __leaf_merge);
+            __pstl::__omp_backend::__parallel_merge_body(__size_x, __size_y, __xs, __xe, __ys, __ye, __zs, __comp,
+                                                              __leaf_merge);
         }
     }
 }
 
 } // namespace __omp_backend
 } // namespace __pstl
 #endif // _PSTL_INTERNAL_OMP_PARALLEL_MERGE_H

pstl/include/pstl/internal/omp/parallel_stable_sort.h

 // -*- C++ -*-
 // -*-===----------------------------------------------------------------------===//
 //
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_INTERNAL_OMP_PARALLEL_STABLE_SORT_H
 #define _PSTL_INTERNAL_OMP_PARALLEL_STABLE_SORT_H
 
 #include "util.h"
+#include "parallel_merge.h"
 
 namespace __pstl
 {
 namespace __omp_backend
 {
 
 namespace __sort_details
 {
__parallel_move_range(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _OutputIterator __d_first)
     // Perform serial moving of small chunks
 
     if (__size <= __default_chunk_size)
     {
         return std::move(__first1, __last1, __d_first);
     }
 
     // Perform parallel moving of larger chunks
-    auto __policy = __omp_backend::__chunk_partitioner(__first1, __last1);
+    auto __policy = __pstl::__omp_backend::__chunk_partitioner(__first1, __last1);
 
     _PSTL_PRAGMA(omp taskloop)
     for (std::size_t __chunk = 0; __chunk < __policy.__n_chunks; ++__chunk)
     {
-        __omp_backend::__process_chunk(__policy, __first1, __chunk,
+        __pstl::__omp_backend::__process_chunk(__policy, __first1, __chunk,
                                        [&](auto __chunk_first, auto __chunk_last)
                                        {
                                            auto __chunk_offset = __chunk_first - __first1;
                                            auto __output_it = __d_first + __chunk_offset;
                                            std::move(__chunk_first, __chunk_last, __output_it);
                                        });
     }
 
     return __d_first + __size;
 }
 
 struct __move_range
 {
     template <typename _RandomAccessIterator, typename _OutputIterator>
     _OutputIterator
     operator()(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _OutputIterator __d_first) const
     {
-        return __parallel_move_range(__first1, __last1, __d_first);
+        return __pstl::__omp_backend::__sort_details::__parallel_move_range(__first1, __last1, __d_first);
     }
 };
 } // namespace __sort_details
 
 template <typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
 void
 __parallel_stable_sort_body(_RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
                             _LeafSort __leaf_sort)
 {
     using _ValueType = typename std::iterator_traits<_RandomAccessIterator>::value_type;
     using _VecType = typename std::vector<_ValueType>;
     using _OutputIterator = typename _VecType::iterator;
     using _MoveValue = typename __omp_backend::__sort_details::__move_value;
     using _MoveRange = __omp_backend::__sort_details::__move_range;
 
     if (__should_run_serial(__xs, __xe))
     {
         __leaf_sort(__xs, __xe, __comp);
     }
     else
     {
         std::size_t __size = __xe - __xs;
         auto __mid = __xs + (__size / 2);
-        __parallel_invoke_body([&]() { __parallel_stable_sort_body(__xs, __mid, __comp, __leaf_sort); },
-                               [&]() { __parallel_stable_sort_body(__mid, __xe, __comp, __leaf_sort); });
+        __pstl::__omp_backend::__parallel_invoke_body(
+            [&]() { __parallel_stable_sort_body(__xs, __mid, __comp, __leaf_sort); },
 
         // Perform a parallel merge of the sorted ranges into __output_data.
         _VecType __output_data(__size);
         _MoveValue __move_value;
         _MoveRange __move_range;
         __utils::__serial_move_merge __merge(__size);
-        __parallel_merge_body(
+        __pstl::__omp_backend::__parallel_merge_body(
             __mid - __xs, __xe - __mid, __xs, __mid, __mid, __xe, __output_data.begin(), __comp,
             [&__merge, &__move_value, &__move_range](_RandomAccessIterator __as, _RandomAccessIterator __ae,
                                                      _RandomAccessIterator __bs, _RandomAccessIterator __be,
                                                      _OutputIterator __cs, _Compare __comp)
             { __merge(__as, __ae, __bs, __be, __cs, __comp, __move_value, __move_value, __move_range, __move_range); });
 
         // Move the values from __output_data back in the original source range.
-        __omp_backend::__sort_details::__parallel_move_range(__output_data.begin(), __output_data.end(), __xs);
+        __pstl::__omp_backend::__sort_details::__parallel_move_range(__output_data.begin(), __output_data.end(), __xs);
     }
 }
 
 template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
 void
 __parallel_stable_sort(_ExecutionPolicy&& /*__exec*/, _RandomAccessIterator __xs, _RandomAccessIterator __xe,
                        _Compare __comp, _LeafSort __leaf_sort, std::size_t __nsort = 0)
 {
     auto __count = static_cast<std::size_t>(__xe - __xs);
     if (__count <= __default_chunk_size || __nsort < __count)
     {
         __leaf_sort(__xs, __xe, __comp);
         return;
     }
 
     // TODO: the partial sort implementation should
     // be shared with the other backends.
 
     if (omp_in_parallel())
     {
         if (__count <= __nsort)
         {
-            __parallel_stable_sort_body(__xs, __xe, __comp, __leaf_sort);
+            __pstl::__omp_backend::__parallel_stable_sort_body(__xs, __xe, __comp, __leaf_sort);
         }
         else
         {
-            __parallel_stable_partial_sort(__xs, __xe, __comp, __leaf_sort, __nsort);
+            __pstl::__omp_backend::__parallel_stable_partial_sort(__xs, __xe, __comp, __leaf_sort, __nsort);
         }
     }
     else
     {
         _PSTL_PRAGMA(omp parallel)
         _PSTL_PRAGMA(omp single nowait)
         if (__count <= __nsort)
         {
-            __parallel_stable_sort_body(__xs, __xe, __comp, __leaf_sort);
+            __pstl::__omp_backend::__parallel_stable_sort_body(__xs, __xe, __comp, __leaf_sort);
         }
         else
         {
-            __parallel_stable_partial_sort(__xs, __xe, __comp, __leaf_sort, __nsort);
+            __pstl::__omp_backend::__parallel_stable_partial_sort(__xs, __xe, __comp, __leaf_sort, __nsort);
         }
     }
 }
 
 } // namespace __omp_backend
 } // namespace __pstl
 #endif // _PSTL_INTERNAL_OMP_PARALLEL_STABLE_SORT_H

pstl/include/pstl/internal/omp/parallel_transform_reduce.h

__transform_reduce_body(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryOp __unary_op, _Value __init,
     {
         __accums.emplace_back(__unary_op(__first + __i));
     }
 
     // main loop
     _PSTL_PRAGMA(omp taskloop shared(__accums))
     for (std::size_t __chunk = 0; __chunk < __policy.__n_chunks; ++__chunk)
     {
-        __omp_backend::__process_chunk(__policy, __first + __num_threads, __chunk,
+        __pstl::__omp_backend::__process_chunk(__policy, __first + __num_threads, __chunk,
                                        [&](auto __chunk_first, auto __chunk_last)
                                        {
                                            auto __thread_num = omp_get_thread_num();
                                            __accums[__thread_num] =
                                                __reduction(__chunk_first, __chunk_last, __accums[__thread_num]);
                                        });
     }