[libc++][PSTL] Replace _PSTL_ASSERT with _LIBCPP_ASSERT

[ldionne]

libcxx/include/__pstl/internal/parallel_backend_utils.h

12–14

You should include <__assert> here and in the other headers that now use _LIBCPP_ASSERT.

[philnik]

Rebased

[philnik]

Address comments

[philnik]

Rebased

[philnik]

Rebased

[philnik]

Rebased

libcxx/include/__pstl/internal/algorithm_impl.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_ALGORITHM_IMPL_H
 #define _PSTL_ALGORITHM_IMPL_H
 
+#include <__assert>
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <type_traits>
 #include <utility>
 
 #include "execution_impl.h"
 #include "memory_impl.h"
bool __pattern_includes(
 
   return __internal::__except_handler([&]() {
     return !__internal::__parallel_or(
         __backend_tag{},
         std::forward<_ExecutionPolicy>(__exec),
         __first2,
         __last2,
         [__first1, __last1, __first2, __last2, &__comp](_RandomAccessIterator2 __i, _RandomAccessIterator2 __j) {
-          _PSTL_ASSERT(__j > __i);
-          //_PSTL_ASSERT(__j - __i > 1);
+          _LIBCPP_ASSERT(__j > __i, "");
+          //_LIBCPP_ASSERT(__j - __i > 1, "");
 
           // 1. moving boundaries to "consume" subsequence of equal elements
           auto __is_equal = [&__comp](_RandomAccessIterator2 __a, _RandomAccessIterator2 __b) -> bool {
             return !__comp(*__a, *__b) && !__comp(*__b, *__a);
           };
 
           // 1.1 left bound, case "aaa[aaaxyz...]" - searching "x"
           if (__i > __first2 && __is_equal(__i, __i - 1)) {
             // whole subrange continues to content equal elements - return "no op"
             if (__is_equal(__i, __j - 1))
               return false;
 
             __i = std::upper_bound(__i, __last2, *__i, __comp);
           }
 
           // 1.2 right bound, case "[...aaa]aaaxyz" - searching "x"
           if (__j < __last2 && __is_equal(__j - 1, __j))
             __j = std::upper_bound(__j, __last2, *__j, __comp);
 
           // 2. testing is __a subsequence of the second range included into the first range
           auto __b = std::lower_bound(__first1, __last1, *__i, __comp);
 
-          _PSTL_ASSERT(!__comp(*(__last1 - 1), *__b));
-          _PSTL_ASSERT(!__comp(*(__j - 1), *__i));
+          _LIBCPP_ASSERT(!__comp(*(__last1 - 1), *__b), "");
+          _LIBCPP_ASSERT(!__comp(*(__j - 1), *__i), "");
           return !std::includes(__b, __last1, __i, __j, __comp);
         });
   });
 }
 
 constexpr auto __set_algo_cut_off = 1000;
 
 template <class _IsVector,
__par_backend::__parallel_invoke(
               __comp,
               [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
               __set_union_op);
         });
     return __result;
   }
 
   const auto __m2 = __left_bound_seq_2 - __first2;
-  _PSTL_ASSERT(__m1 == 0 || __m2 == 0);
+  _LIBCPP_ASSERT(__m1 == 0 || __m2 == 0, "");
   if (__m2 > __set_algo_cut_off) {
     auto __res_or = __result;
     __result += __m2; // we know proper offset due to [first2; left_bound_seq_2) < [first1; last1)
     __par_backend::__parallel_invoke(
         __backend_tag{},
         std::forward<_ExecutionPolicy>(__exec),
         // do parallel copying of [first2; left_bound_seq_2)
         [=] {

libcxx/include/__pstl/internal/numeric_impl.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_NUMERIC_IMPL_H
 #define _PSTL_NUMERIC_IMPL_H
 
+#include <__assert>
 #include <iterator>
 #include <type_traits>
 #include <numeric>
 
 #include "parallel_backend.h"
 #include "pstl_config.h"
 #include "execution_impl.h"
 #include "unseq_backend_simd.h"

 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class BinaryOperation>
 _RandomAccessIterator2 __brick_adjacent_difference(
     _RandomAccessIterator1 __first,
     _RandomAccessIterator1 __last,
     _RandomAccessIterator2 __d_first,
     BinaryOperation __op,
     /*is_vector=*/std::true_type) noexcept {
-  _PSTL_ASSERT(__first != __last);
+  _LIBCPP_ASSERT(__first != __last, "Range cannot be empty");
 
   typedef typename std::iterator_traits<_RandomAccessIterator1>::reference _ReferenceType1;
   typedef typename std::iterator_traits<_RandomAccessIterator2>::reference _ReferenceType2;
 
   auto __n   = __last - __first;
   *__d_first = *__first;
   return __unseq_backend::__simd_walk_3(
       __first + 1,
template <class _IsVector,
           class _BinaryOperation>
 _RandomAccessIterator2 __pattern_adjacent_difference(
     __parallel_tag<_IsVector> __tag,
     _ExecutionPolicy&& __exec,
     _RandomAccessIterator1 __first,
     _RandomAccessIterator1 __last,
     _RandomAccessIterator2 __d_first,
     _BinaryOperation __op) {
-  _PSTL_ASSERT(__first != __last);
+  _LIBCPP_ASSERT(__first != __last, "range cannot be empty");
   typedef typename std::iterator_traits<_RandomAccessIterator1>::reference _ReferenceType1;
   typedef typename std::iterator_traits<_RandomAccessIterator2>::reference _ReferenceType2;
 
   using __backend_tag = typename decltype(__tag)::__backend_tag;
 
   *__d_first = *__first;
   __par_backend::__parallel_for(
       __backend_tag{},

libcxx/include/__pstl/internal/parallel_backend_tbb.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_PARALLEL_BACKEND_TBB_H
 #define _PSTL_PARALLEL_BACKEND_TBB_H
 
+#include <__assert>
 #include <algorithm>
 #include <type_traits>
 
 #include "pstl_config.h"
 #include "parallel_backend_utils.h"
 
 // Bring in minimal required subset of Intel TBB
 #include <tbb/blocked_range.h>
protected:
     __task* _M_parent{};
     std::atomic<int> _M_refcount{};
     bool _M_recycle{};
 
     template <typename _Fn>
     __task*
     allocate_func_task(_Fn&& __f)
     {
-        _PSTL_ASSERT(_M_execute_data != nullptr);
+        _LIBCPP_ASSERT(_M_execute_data != nullptr, "");
         tbb::detail::d1::small_object_allocator __alloc{};
         auto __t =
             __alloc.new_object<__func_task<typename std::decay<_Fn>::type>>(*_M_execute_data, std::forward<_Fn>(__f));
         __t->_M_allocator = __alloc;
         return __t;
     }
 
   public:
make_child_of(__task* __parent, _Fn&& __f)
         return __t;
     }
 
     template <typename _Fn>
     __task*
     make_additional_child_of(__task* __parent, _Fn&& __f)
     {
         auto __t = make_child_of(__parent, std::forward<_Fn>(__f));
-        _PSTL_ASSERT(__parent->_M_refcount.load(std::memory_order_relaxed) > 0);
+        _LIBCPP_ASSERT(__parent->_M_refcount.load(std::memory_order_relaxed) > 0, "");
         ++__parent->_M_refcount;
         return __t;
     }
 
     inline void
     recycle_as_continuation()
     {
         _M_recycle = true;
     }
 
     inline void
     recycle_as_child_of(__task* parent)
     {
         _M_recycle = true;
         _M_parent = parent;
     }
 
     inline void
     spawn(__task* __t)
     {
-        _PSTL_ASSERT(_M_execute_data != nullptr);
+        _LIBCPP_ASSERT(_M_execute_data != nullptr, "");
         tbb::detail::d1::spawn(*__t, *_M_execute_data->context);
     }
 
     template <typename _Fn>
     static inline void
     spawn_root_and_wait(__root_task<_Fn>& __root)
     {
         tbb::detail::d1::execute_and_wait(*__root._M_func_task, __root._M_context, __root._M_wait_object,
finalize(__task* __next)
         }
 
         auto __parent = _M_parent;
         auto __alloc = _M_allocator;
         auto __ed = _M_execute_data;
 
         this->~__func_task();
 
-        _PSTL_ASSERT(__parent != nullptr);
-        _PSTL_ASSERT(__parent->_M_refcount.load(std::memory_order_relaxed) > 0);
+        _LIBCPP_ASSERT(__parent != nullptr, "");
+        _LIBCPP_ASSERT(__parent->_M_refcount.load(std::memory_order_relaxed) > 0, "");
         if (--__parent->_M_refcount == 0)
         {
-            _PSTL_ASSERT(__next == nullptr);
+            _LIBCPP_ASSERT(__next == nullptr, "");
             __alloc.deallocate(this, *__ed);
             return __parent;
         }
 
         return __next;
     }
 
     friend class __root_task<_Func>;
private:
     {
         return _root ? nullptr : &static_cast<__func_task<__merge_func>*>(__self->parent())->body();
     }
     bool
     x_less_y()
     {
         const auto __nx = (_M_xe - _M_xs);
         const auto __ny = (_M_ye - _M_ys);
-        _PSTL_ASSERT(__nx > 0 && __ny > 0);
+        _LIBCPP_ASSERT(__nx > 0 && __ny > 0, "");
 
-        _PSTL_ASSERT(_x_orig == _y_orig);
-        _PSTL_ASSERT(!is_partial());
+        _LIBCPP_ASSERT(_x_orig == _y_orig, "");
+        _LIBCPP_ASSERT(!is_partial(), "");
 
         if (_x_orig)
         {
-            _PSTL_ASSERT(std::is_sorted(_M_x_beg + _M_xs, _M_x_beg + _M_xe, _M_comp));
-            _PSTL_ASSERT(std::is_sorted(_M_x_beg + _M_ys, _M_x_beg + _M_ye, _M_comp));
+            _LIBCPP_ASSERT(std::is_sorted(_M_x_beg + _M_xs, _M_x_beg + _M_xe, _M_comp), "");
+            _LIBCPP_ASSERT(std::is_sorted(_M_x_beg + _M_ys, _M_x_beg + _M_ye, _M_comp), "");
             return !_M_comp(*(_M_x_beg + _M_ys), *(_M_x_beg + _M_xe - 1));
         }
 
-        _PSTL_ASSERT(std::is_sorted(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_comp));
-        _PSTL_ASSERT(std::is_sorted(_M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_comp));
+        _LIBCPP_ASSERT(std::is_sorted(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_comp), "");
+        _LIBCPP_ASSERT(std::is_sorted(_M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_comp), "");
         return !_M_comp(*(_M_z_beg + _M_zs + __nx), *(_M_z_beg + _M_zs + __nx - 1));
     }
     void
     move_x_range()
     {
         const auto __nx = (_M_xe - _M_xs);
         const auto __ny = (_M_ye - _M_ys);
-        _PSTL_ASSERT(__nx > 0 && __ny > 0);
+        _LIBCPP_ASSERT(__nx > 0 && __ny > 0, "");
 
         if (_x_orig)
             __move_range_construct()(_M_x_beg + _M_xs, _M_x_beg + _M_xe, _M_z_beg + _M_zs);
         else
         {
             __move_range()(_M_z_beg + _M_zs, _M_z_beg + _M_zs + __nx, _M_x_beg + _M_xs);
             __cleanup_range()(_M_z_beg + _M_zs, _M_z_beg + _M_zs + __nx);
         }
move_y_range()
             __cleanup_range()(_M_z_beg + _M_zs + __nx, _M_z_beg + _M_zs + __nx + __ny);
         }
 
         _y_orig = !_y_orig;
     }
     __task*
     merge_ranges(__task* __self)
     {
-        _PSTL_ASSERT(_x_orig == _y_orig); //two merged subrange must be lie into the same buffer
+        _LIBCPP_ASSERT(_x_orig == _y_orig, ""); //two merged subrange must be lie into the same buffer
 
         const auto __nx = (_M_xe - _M_xs);
         const auto __ny = (_M_ye - _M_ys);
         const auto __n = __nx + __ny;
 
         // need to merge {x} and {y}
         if (__n > __merge_cut_off)
             return split_merging(__self);
 
         //merge to buffer
         if (_x_orig)
         {
             _M_leaf_merge(_M_x_beg + _M_xs, _M_x_beg + _M_xe, _M_x_beg + _M_ys, _M_x_beg + _M_ye, _M_z_beg + _M_zs,
                           _M_comp, __move_value_construct(), __move_value_construct(), __move_range_construct(),
                           __move_range_construct());
-            _PSTL_ASSERT(parent_merge(__self)); //not root merging task
+            _LIBCPP_ASSERT(parent_merge(__self), ""); //not root merging task
         }
         //merge to "origin"
         else
         {
-            _PSTL_ASSERT(_x_orig == _y_orig);
+            _LIBCPP_ASSERT(_x_orig == _y_orig, "");
 
-            _PSTL_ASSERT(is_partial() || std::is_sorted(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_comp));
-            _PSTL_ASSERT(is_partial() || std::is_sorted(_M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_comp));
+            _LIBCPP_ASSERT(is_partial() || std::is_sorted(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_comp), "");
+            _LIBCPP_ASSERT(is_partial() || std::is_sorted(_M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_comp), "");
 
             const auto __nx = (_M_xe - _M_xs);
             const auto __ny = (_M_ye - _M_ys);
 
             _M_leaf_merge(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_x_beg + _M_zs,
                           _M_comp, __move_value(), __move_value(), __move_range(), __move_range());
 
             __cleanup_range()(_M_z_beg + _M_xs, _M_z_beg + _M_xe);
             __cleanup_range()(_M_z_beg + _M_ys, _M_z_beg + _M_ye);
         }
         return nullptr;
     }
 
     __task*
     process_ranges(__task* __self)
     {
-        _PSTL_ASSERT(_x_orig == _y_orig);
-        _PSTL_ASSERT(!_split);
+        _LIBCPP_ASSERT(_x_orig == _y_orig, "");
+        _LIBCPP_ASSERT(!_split, "");
 
         auto p = parent_merge(__self);
 
         if (!p)
         { //root merging task
 
             //optimization, just for sort algorithm, //{x} <= {y}
             if (!is_partial() && x_less_y()) //we have a solution
process_ranges(__task* __self)
 
         return merge_ranges(__self);
     }
 
     //splitting as merge task into 2 of the same level
     __task*
     split_merging(__task* __self)
     {
-        _PSTL_ASSERT(_x_orig == _y_orig);
+        _LIBCPP_ASSERT(_x_orig == _y_orig, "");
         const auto __nx = (_M_xe - _M_xs);
         const auto __ny = (_M_ye - _M_ys);
 
         _SizeType __xm{};
         _SizeType __ym{};
         if (__nx < __ny)
         {
             __ym = _M_ys + __ny / 2;
if (!parent_merge(__self))
             move_x_range();
         else
             move_y_range();
     }
     else
     {
         const _SizeType __nx = (_M_xe - _M_xs);
         const _SizeType __ny = (_M_ye - _M_ys);
-        _PSTL_ASSERT(__nx > 0);
-        _PSTL_ASSERT(__nx > 0);
+        _LIBCPP_ASSERT(__nx > 0, "");
+        _LIBCPP_ASSERT(__nx > 0, "");
 
         if (__nx < __ny)
             move_x_range();
         else
             move_y_range();
     }
 
     return process_ranges(__self);
typedef __merge_func<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, __utils::__serial_destroy,
         _MergeTaskType;
 
     const _SizeType __n = _M_xe - _M_xs;
     const _SizeType __nmerge = _M_nsort > 0 ? _M_nsort : __n;
     const _SizeType __sort_cut_off = _PSTL_STABLE_SORT_CUT_OFF;
     if (__n <= __sort_cut_off)
     {
         _M_leaf_sort(_M_xs, _M_xe, _M_comp);
-        _PSTL_ASSERT(!_M_root);
+        _LIBCPP_ASSERT(!_M_root, "");
         return nullptr;
     }
 
     const _RandomAccessIterator1 __xm = _M_xs + __n / 2;
     const _RandomAccessIterator2 __zm = _M_zs + (__xm - _M_xs);
     const _RandomAccessIterator2 __ze = _M_zs + __n;
     _MergeTaskType __m(_MergeTaskType(_M_xs - _M_x_beg, __xm - _M_x_beg, __xm - _M_x_beg, _M_xe - _M_x_beg,
                                       _M_zs - _M_z_beg, _M_comp, __utils::__serial_destroy(),

libcxx/include/__pstl/internal/parallel_backend_utils.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_PARALLEL_BACKEND_UTILS_H
 #define _PSTL_PARALLEL_BACKEND_UTILS_H
 
+#include <__assert>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 
 #include "utils.h"
 
 #include "pstl_config.h"
 
 namespace __pstl
 {
struct __serial_move_merge
     operator()(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
                _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _MoveValueX __move_value_x,
                _MoveValueY __move_value_y, _MoveSequenceX __move_sequence_x, _MoveSequenceY __move_sequence_y)
     {
         constexpr bool __same_move_val = std::is_same<_MoveValueX, _MoveValueY>::value;
         constexpr bool __same_move_seq = std::is_same<_MoveSequenceX, _MoveSequenceY>::value;
 
         auto __n = _M_nmerge;
-        _PSTL_ASSERT(__n > 0);
+        _LIBCPP_ASSERT(__n > 0, "");
 
         auto __nx = __xe - __xs;
         //auto __ny = __ye - __ys;
         _RandomAccessIterator3 __zs_beg = __zs;
 
         if (__xs != __xe)
         {
             if (__ys != __ye)

libcxx/include/__pstl/internal/pstl_config.h

 #ifndef _PSTL_CONFIG_H
 #define _PSTL_CONFIG_H
 
 #include <__config>
 
 // TODO: Make this a proper configuration option
 #define _PSTL_PAR_BACKEND_SERIAL
 
-#include <__assert>
-#define _PSTL_ASSERT(pred) _LIBCPP_ASSERT(pred, "")
-
 #define _PSTL_PRAGMA(x) _Pragma(#    x)
 
 // Enable SIMD for compilers that support OpenMP 4.0
 #if (defined(_OPENMP) && _OPENMP >= 201307)
 
 #  define _PSTL_UDR_PRESENT
 #  define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
 #  define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)