This is an archive of the discontinued LLVM Phabricator instance.

Differential D60521

[pstl] Move to single underscore-capital for macros and include guards
ClosedPublic

Authored by ldionne on Apr 10 2019, 10:38 AM.

Details

Reviewers
rodgert
Commits
rG3dee12e4a572: [pstl] Move to single underscore-capital for macros and include guards
rL358131: [pstl] Move to single underscore-capital for macros and include guards
rPSTL358131: [pstl] Move to single underscore-capital for macros and include guards
Summary

Per the LLVM convention.

Diff Detail

Repository
rPSTL pstl

Event Timeline

ldionne created this revision.Apr 10 2019, 10:38 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 10 2019, 10:38 AM
Herald added subscribers: libcxx-commits, jdoerfert, dexonsmith, jkorous. · View Herald Transcript
Harbormaster completed remote builds in B30325: Diff 194546.Apr 10 2019, 10:40 AM
ldionne updated this revision to Diff 194572.Apr 10 2019, 12:36 PM

Rebase on top of master

Harbormaster completed remote builds in B30334: Diff 194572.Apr 10 2019, 12:37 PM
ldionne updated this revision to Diff 194573.Apr 10 2019, 12:38 PM

Correctly rebase on top of master -- I pulled in a commit I shouldn't have.

Harbormaster completed remote builds in B30335: Diff 194573.Apr 10 2019, 12:38 PM
rodgert accepted this revision.Apr 10 2019, 12:45 PM
This revision is now accepted and ready to land.Apr 10 2019, 12:45 PM
Closed by commit rPSTL358131: [pstl] Move to single underscore-capital for macros and include guards (authored by ldionne). · Explain WhyApr 10 2019, 12:50 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
include/
pstl/
10 lines
22 lines
internal/
110 lines
154 lines
14 lines
8 lines
6 lines
6 lines
12 lines
6 lines
6 lines
6 lines
6 lines
6 lines
16 lines
26 lines
10 lines
18 lines
6 lines
6 lines
154 lines
148 lines
6 lines
10 lines
10 lines
test/
std/
algorithms/
alg.merge/
4 lines
2 lines
alg.modifying.operations/
alg.copy/
6 lines
alg.partitions/
4 lines
8 lines
4 lines
alg.reverse/
6 lines
4 lines
14 lines
12 lines
2 lines
4 lines
4 lines
6 lines
4 lines
alg.nonmodifying/
2 lines
2 lines
2 lines
2 lines
4 lines
6 lines
4 lines
6 lines
2 lines
4 lines
6 lines
alg.sorting/
alg.heap.operations/
4 lines
alg.lex.comparison/
2 lines
2 lines
4 lines
numerics/
numeric.ops/
4 lines
2 lines
2 lines
2 lines
utilities/
memory/
specialized.algorithms/
2 lines
6 lines
support/
42 lines
14 lines

Diff 194575

include/pstl/algorithm

// -*- C++ -*- // -*- C++ -*-
//===-- algorithm ---------------------------------------------------------===// //===-- algorithm ---------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_algorithm #ifndef _PSTL_ALGORITHM
#define __PSTL_algorithm #define _PSTL_ALGORITHM
#include "internal/pstl_config.h" #include "internal/pstl_config.h"
#if __PSTL_EXECUTION_POLICIES_DEFINED #if _PSTL_EXECUTION_POLICIES_DEFINED
// If <execution> has already been included, pull in implementations // If <execution> has already been included, pull in implementations
# include "internal/glue_algorithm_impl.h" # include "internal/glue_algorithm_impl.h"
#else #else
// Otherwise just pull in forward declarations // Otherwise just pull in forward declarations
# include "internal/glue_algorithm_defs.h" # include "internal/glue_algorithm_defs.h"
# define __PSTL_ALGORITHM_FORWARD_DECLARED 1 # define _PSTL_ALGORITHM_FORWARD_DECLARED 1
#endif #endif
#endif /* __PSTL_algorithm */ #endif /* _PSTL_ALGORITHM */

include/pstl/execution

// -*- C++ -*- // -*- C++ -*-
//===-- execution ---------------------------------------------------------===// //===-- execution ---------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_execution #ifndef _PSTL_EXECUTION
#define __PSTL_execution #define _PSTL_EXECUTION
#include "internal/pstl_config.h" #include "internal/pstl_config.h"
#include "internal/execution_defs.h" #include "internal/execution_defs.h"
#define __PSTL_EXECUTION_POLICIES_DEFINED 1 #define _PSTL_EXECUTION_POLICIES_DEFINED 1
#if __PSTL_ALGORITHM_FORWARD_DECLARED #if _PSTL_ALGORITHM_FORWARD_DECLARED
# include "internal/glue_algorithm_impl.h" # include "internal/glue_algorithm_impl.h"
#endif #endif
#if __PSTL_MEMORY_FORWARD_DECLARED #if _PSTL_MEMORY_FORWARD_DECLARED
# include "internal/glue_memory_impl.h" # include "internal/glue_memory_impl.h"
#endif #endif
#if __PSTL_NUMERIC_FORWARD_DECLARED #if _PSTL_NUMERIC_FORWARD_DECLARED
# include "internal/glue_numeric_impl.h" # include "internal/glue_numeric_impl.h"
#endif #endif
#if __PSTL_CPP17_EXECUTION_POLICIES_PRESENT #if _PSTL_CPP17_EXECUTION_POLICIES_PRESENT
__PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace __pstl::execution") _PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace __pstl::execution")
#else #else
# include "internal/glue_execution_defs.h" # include "internal/glue_execution_defs.h"
__PSTL_PRAGMA_MESSAGE_POLICIES( _PSTL_PRAGMA_MESSAGE_POLICIES(
"The <Parallel STL> execution policies are injected into the standard namespace std::execution") "The <Parallel STL> execution policies are injected into the standard namespace std::execution")
#endif #endif
//TODO: __pstl::execution namespace is injected into the pstl::execution namespace when the implementation is not a part of //TODO: __pstl::execution namespace is injected into the pstl::execution namespace when the implementation is not a part of
// standard C++ library // standard C++ library
namespace pstl namespace pstl
{ {
namespace execution namespace execution
{ {
using namespace __pstl::execution; using namespace __pstl::execution;
} }
} } // namespace pstl
#endif /* __PSTL_execution */ #endif /* _PSTL_EXECUTION */

include/pstl/internal/algorithm_fwd.h

// -*- C++ -*- // -*- C++ -*-
//===-- algorithm_fwd.h --------------------------------------------------===// //===-- algorithm_fwd.h --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_algorithm_fwd_H #ifndef _PSTL_ALGORITHM_FWD_H
#define __PSTL_algorithm_fwd_H #define _PSTL_ALGORITHM_FWD_H
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
namespace __pstl namespace __pstl
{ {
namespace __internal namespace __internal
{ {
Show All 12 Lines
__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, __brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
/*__is_vector=*/std::true_type) noexcept; /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool bool
__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool bool
__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
/*parallel=*/std::true_type); /*parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// walk1 (pseudo) // walk1 (pseudo)
Show All 9 Lines
void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function, void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
/*vector=*/std::true_type) noexcept; /*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
void void
__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
void void
__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
/*parallel=*/std::true_type); /*parallel=*/std::true_type);
#endif #endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void void
__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void void
__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
/*parallel=*/std::true_type); /*parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// walk1_n // walk1_n
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _Function> template <class _ForwardIterator, class _Size, class _Function>
_ForwardIterator __brick_walk1_n(_ForwardIterator, _Size, _Function, _ForwardIterator __brick_walk1_n(_ForwardIterator, _Size, _Function,
/*_IsVectorTag=*/std::false_type); /*_IsVectorTag=*/std::false_type);
template <class _RandomAccessIterator, class _DifferenceType, class _Function> template <class _RandomAccessIterator, class _DifferenceType, class _Function>
_RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function, _RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
/*vectorTag=*/std::true_type) noexcept; /*vectorTag=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector, __pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector, __pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
_ForwardIterator _ForwardIterator
__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick, __pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
_RandomAccessIterator _RandomAccessIterator
__pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick, __pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// walk2 (pseudo) // walk2 (pseudo)
Show All 17 Lines
_ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, _ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
/*vector=*/std::true_type) noexcept; /*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
/*parallel=*/std::true_type); /*parallel=*/std::true_type);
#endif #endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function,
class _IsVector> class _IsVector>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector, __pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2,
class _Function, class _IsVector> class _Function, class _IsVector>
_RandomAccessIterator2 _RandomAccessIterator2
__pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector, __pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector,
/*parallel=*/std::true_type); /*parallel=*/std::true_type);
#endif #endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick, __pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick> template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
_RandomAccessIterator2 _RandomAccessIterator2
__pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, __pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_Brick, _Brick,
/*parallel=*/std::true_type); /*parallel=*/std::true_type);
#endif #endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick, __pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick> template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
_RandomAccessIterator2 _RandomAccessIterator2
__pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick, __pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick,
/*parallel=*/std::true_type); /*parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// walk3 (pseudo) // walk3 (pseudo)
Show All 12 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
class _Function, class _IsVector> class _Function, class _IsVector>
_ForwardIterator3 _ForwardIterator3
__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, __pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3,
_Function, _IsVector, _Function, _IsVector,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
class _RandomAccessIterator3, class _Function, class _IsVector> class _RandomAccessIterator3, class _Function, class _IsVector>
_RandomAccessIterator3 _RandomAccessIterator3
__pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, __pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type); _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 9 Linesbool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
/* is_vector = */ std::true_type) noexcept; /* is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
bool bool
__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
_IsVector, /* is_parallel = */ std::false_type) noexcept; _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
bool bool
__pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, __pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_BinaryPredicate, _IsVector, /* is_parallel = */ std::true_type); _BinaryPredicate, _IsVector, /* is_parallel = */ std::true_type);
#endif #endif
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate,
/* is_vector = */ std::false_type) noexcept; /* is_vector = */ std::false_type) noexcept;
template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate> template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
_BinaryPredicate, /* is_vector = */ std::true_type) noexcept; _BinaryPredicate, /* is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
bool bool
__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, /* is_parallel = */ std::false_type) noexcept; _BinaryPredicate, _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
bool bool
__pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, __pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_RandomAccessIterator2, _BinaryPredicate, _IsVector, /* is_parallel = */ std::true_type); _RandomAccessIterator2, _BinaryPredicate, _IsVector, /* is_parallel = */ std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// find_if // find_if
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator, class _Predicate> template <class _ForwardIterator, class _Predicate>
_ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate, _ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
/*is_vector=*/std::false_type) noexcept; /*is_vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _Predicate> template <class _RandomAccessIterator, class _Predicate>
_RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate, _RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
/*is_vector=*/std::true_type) noexcept; /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// find_end // find_end
Show All 11 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::true_type) noexcept; /*is_parallel=*/std::true_type) noexcept;
#endif #endif
Show All 12 Lines_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
/*__is_vector=*/std::true_type) noexcept; /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept; _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept; _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept;
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 12 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::true_type) noexcept; /*is_parallel=*/std::true_type) noexcept;
#endif #endif
Show All 13 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate,
class IsVector> class IsVector>
_ForwardIterator _ForwardIterator
__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, __pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
IsVector, IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate,
class IsVector> class IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, __pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&,
_BinaryPredicate, IsVector, _BinaryPredicate, IsVector,
/*is_parallel=*/std::true_type) noexcept; /*is_parallel=*/std::true_type) noexcept;
#endif #endif
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
__brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*, __brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*,
/*vector=*/std::true_type) noexcept; /*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
_OutputIterator _OutputIterator
__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector, __pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector,
/*parallel=*/std::false_type) noexcept; /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate,
class _IsVector> class _IsVector>
_OutputIterator _OutputIterator
__pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate, __pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
_IsVector, /*parallel=*/std::true_type); _IsVector, /*parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 10 Linestypename std::iterator_traits<_ForwardIterator>::difference_type
__brick_count(_ForwardIterator, _ForwardIterator, _Predicate, __brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
/* is_vector = */ std::false_type) noexcept; /* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type typename std::iterator_traits<_ForwardIterator>::difference_type
__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, __pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
/* is_parallel */ std::false_type, _IsVector) noexcept; /* is_parallel */ std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type typename std::iterator_traits<_ForwardIterator>::difference_type
__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, __pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
/* is_parallel */ std::true_type, _IsVector); /* is_parallel */ std::true_type, _IsVector);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// unique // unique
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator, class _BinaryPredicate> template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, _ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
/*is_vector=*/std::false_type) noexcept; /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _BinaryPredicate> template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, _ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
/*is_vector=*/std::true_type) noexcept; /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, __pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, __pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::true_type) noexcept; /*is_parallel=*/std::true_type) noexcept;
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// unique_copy // unique_copy
Show All 18 Lines
__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, __brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
/*vector=*/std::false_type) noexcept; /*vector=*/std::false_type) noexcept;
template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate> template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
_DifferenceType _DifferenceType
__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, __brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
/*vector=*/std::true_type) noexcept; /*vector=*/std::true_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate,
class _IsVector> class _IsVector>
_OutputIterator _OutputIterator
__pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, __pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
_BinaryPredicate, _IsVector, /*parallel=*/std::true_type); _BinaryPredicate, _IsVector, /*parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 16 Lines
void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
/*is_vector=*/std::true_type) noexcept; /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
void void
__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
void void
__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// reverse_copy // reverse_copy
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _BidirectionalIterator, class _OutputIterator> template <class _BidirectionalIterator, class _OutputIterator>
_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
/*is_vector=*/std::false_type) noexcept; /*is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator, class _OutputIterator> template <class _BidirectionalIterator, class _OutputIterator>
_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
/*is_vector=*/std::true_type) noexcept; /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// rotate // rotate
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator> template <class _ForwardIterator>
_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, _ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
/*is_vector=*/std::false_type) noexcept; /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator> template <class _ForwardIterator>
_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, _ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
/*is_vector=*/std::true_type) noexcept; /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// rotate_copy // rotate_copy
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator> template <class _ForwardIterator, class _OutputIterator>
_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
/*__is_vector=*/std::false_type) noexcept; /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator> template <class _ForwardIterator, class _OutputIterator>
_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
/*__is_vector=*/std::true_type) noexcept; /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
_IsVector, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
_IsVector, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// is_partitioned // is_partitioned
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate> template <class _ForwardIterator, class _UnaryPredicate>
bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::false_type) noexcept; /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _UnaryPredicate> template <class _ForwardIterator, class _UnaryPredicate>
bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::true_type) noexcept; /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool bool
__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool bool
__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// partition // partition
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate> template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::false_type) noexcept; /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _UnaryPredicate> template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::true_type) noexcept; /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, __pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, __pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// stable_partition // stable_partition
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _BidirectionalIterator, class _UnaryPredicate> template <class _BidirectionalIterator, class _UnaryPredicate>
_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
/*__is_vector=*/std::false_type) noexcept; /*__is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator, class _UnaryPredicate> template <class _BidirectionalIterator, class _UnaryPredicate>
_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
/*__is_vector=*/std::true_type) noexcept; /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator _BidirectionalIterator
__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
_IsVector, _IsVector,
/*is_parallelization=*/std::false_type) noexcept; /*is_parallelization=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator _BidirectionalIterator
__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
_IsVector, _IsVector,
/*is_parallelization=*/std::true_type) noexcept; /*is_parallelization=*/std::true_type) noexcept;
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 12 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate, class _IsVector> class _UnaryPredicate, class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2> std::pair<_OutputIterator1, _OutputIterator2>
__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, __pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2,
_UnaryPredicate, _IsVector, _UnaryPredicate, _IsVector,
/*is_parallelization=*/std::false_type) noexcept; /*is_parallelization=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate, class _IsVector> class _UnaryPredicate, class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2> std::pair<_OutputIterator1, _OutputIterator2>
__pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, __pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator1,
_OutputIterator2, _UnaryPredicate, _IsVector, _OutputIterator2, _UnaryPredicate, _IsVector,
/*is_parallelization=*/std::true_type); /*is_parallelization=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// sort // sort
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector, template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector,
class _IsMoveConstructible> class _IsMoveConstructible>
void void
__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
/*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept; /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
/*is_parallel=*/std::true_type, /*is_parallel=*/std::true_type,
/*is_move_constructible=*/std::true_type); /*is_move_constructible=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// stable_sort // stable_sort
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
_IsVector /*is_vector*/, _IsVector /*is_vector*/,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
_IsVector /*is_vector*/, _IsVector /*is_vector*/,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// partial_sort // partial_sort
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
_Compare, _IsVector, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
_Compare, _IsVector, _Compare, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// partial_sort_copy // partial_sort_copy
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
_RandomAccessIterator, _Compare, _IsVector, _RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
_RandomAccessIterator, _Compare, _IsVector, _RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 10 Lines
__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, __brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
/* IsVector = */ std::false_type, bool) noexcept; /* IsVector = */ std::false_type, bool) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, __pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate,
/* is_parallel */ std::false_type, _IsVector, bool) noexcept; /* is_parallel */ std::false_type, _IsVector, bool) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate, __pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
/* is_parallel */ std::true_type, _IsVector, bool); /* is_parallel */ std::true_type, _IsVector, bool);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// nth_element // nth_element
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
_IsVector, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
_IsVector, _IsVector,
/*is_parallel=*/std::true_type) noexcept; /*is_parallel=*/std::true_type) noexcept;
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 9 Lines
__brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, __brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
/* __is_vector = */ std::false_type) noexcept; /* __is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
void void
__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, __pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
/*is_parallel=*/std::false_type, _IsVector) noexcept; /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, __pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
/*is_parallel=*/std::true_type, _IsVector); /*is_parallel=*/std::true_type, _IsVector);
#endif #endif
template <class _OutputIterator, class _Size, class _Tp> template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator _OutputIterator
__brick_fill_n(_OutputIterator, _Size, const _Tp&, __brick_fill_n(_OutputIterator, _Size, const _Tp&,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <class _OutputIterator, class _Size, class _Tp> template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator _OutputIterator
__brick_fill_n(_OutputIterator, _Size, const _Tp&, __brick_fill_n(_OutputIterator, _Size, const _Tp&,
/* __is_vector = */ std::false_type) noexcept; /* __is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector> template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator _OutputIterator
__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, __pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
/*is_parallel=*/std::false_type, _IsVector) noexcept; /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector> template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator _OutputIterator
__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, __pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
/*is_parallel=*/std::true_type, _IsVector); /*is_parallel=*/std::true_type, _IsVector);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// generate, generate_n // generate, generate_n
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _RandomAccessIterator, class _Generator> template <class _RandomAccessIterator, class _Generator>
void __brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator, void __brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator,
/* is_vector = */ std::true_type) noexcept; /* is_vector = */ std::true_type) noexcept;
template <class _ForwardIterator, class _Generator> template <class _ForwardIterator, class _Generator>
void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator, void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator,
/* is_vector = */ std::false_type) noexcept; /* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
void void
__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, __pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
/*is_parallel=*/std::false_type, _IsVector) noexcept; /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, __pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
/*is_parallel=*/std::true_type, _IsVector); /*is_parallel=*/std::true_type, _IsVector);
#endif #endif
template <class OutputIterator, class Size, class _Generator> template <class OutputIterator, class Size, class _Generator>
OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, OutputIterator __brick_generate_n(OutputIterator, Size, _Generator,
/* is_vector = */ std::true_type) noexcept; /* is_vector = */ std::true_type) noexcept;
template <class OutputIterator, class Size, class _Generator> template <class OutputIterator, class Size, class _Generator>
OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, OutputIterator __brick_generate_n(OutputIterator, Size, _Generator,
/* is_vector = */ std::false_type) noexcept; /* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector> template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
OutputIterator OutputIterator
__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, __pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
/*is_parallel=*/std::false_type, _IsVector) noexcept; /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector> template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
OutputIterator OutputIterator
__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, __pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
/*is_parallel=*/std::true_type, _IsVector); /*is_parallel=*/std::true_type, _IsVector);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// remove // remove
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate> template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator __brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _ForwardIterator __brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/* __is_vector = */ std::false_type) noexcept; /* __is_vector = */ std::false_type) noexcept;
template <class _RandomAccessIterator, class _UnaryPredicate> template <class _RandomAccessIterator, class _UnaryPredicate>
_RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate, _RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel*/ std::false_type) noexcept; /*is_parallel*/ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel*/ std::true_type) noexcept; /*is_parallel*/ std::true_type) noexcept;
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// merge // merge
Show All 10 Lines_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, __pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_RandomAccessIterator2, _OutputIterator, _Compare, _IsVector, _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector,
/* is_parallel = */ std::true_type); /* is_parallel = */ std::true_type);
#endif #endif
Show All 10 Linesvoid __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void void
__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
_Compare, _IsVector, _Compare, _IsVector,
/* is_parallel = */ std::false_type) noexcept; /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void void
__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
_Compare, _IsVector, _Compare, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// includes // includes
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool bool
__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_Compare, _IsVector, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool bool
__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_Compare, _IsVector, _Compare, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 11 Lines_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
/*__is_vector=*/std::true_type) noexcept; /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 12 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _OutputIterator, _Compare, _IsVector, _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); _ForwardIterator2, _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 11 Lines_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
/*__is_vector=*/std::true_type) noexcept; /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 12 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _OutputIterator, _Compare, _IsVector, _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _OutputIterator, _Compare, _IsVector, _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
Show All 9 Lines
_RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, _RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/* is_parallel = */ std::false_type) noexcept; /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/* is_parallel = */ std::true_type) noexcept; /* is_parallel = */ std::true_type) noexcept;
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// min_element // min_element
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <typename _ForwardIterator, typename _Compare> template <typename _ForwardIterator, typename _Compare>
_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, _ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::false_type) noexcept; /* __is_vector = */ std::false_type) noexcept;
template <typename _ForwardIterator, typename _Compare> template <typename _ForwardIterator, typename _Compare>
_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, _ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
_ForwardIterator _ForwardIterator
__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, __pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
/* is_parallel = */ std::false_type) noexcept; /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, __pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/* is_parallel = */ std::true_type); /* is_parallel = */ std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// minmax_element // minmax_element
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <typename _ForwardIterator, typename _Compare> template <typename _ForwardIterator, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::false_type) noexcept; /* __is_vector = */ std::false_type) noexcept;
template <typename _ForwardIterator, typename _Compare> template <typename _ForwardIterator, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator> std::pair<_ForwardIterator, _ForwardIterator>
__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
/* is_parallel = */ std::false_type) noexcept; /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator> std::pair<_ForwardIterator, _ForwardIterator>
__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
/* is_parallel = */ std::true_type); /* is_parallel = */ std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// mismatch // mismatch
Show All 10 Linesstd::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
std::pair<_ForwardIterator1, _ForwardIterator2> std::pair<_ForwardIterator1, _ForwardIterator2>
__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, __pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_Predicate, _IsVector, _Predicate, _IsVector,
/* is_parallel = */ std::false_type) noexcept; /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate,
class _IsVector> class _IsVector>
std::pair<_RandomAccessIterator1, _RandomAccessIterator2> std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
__pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, __pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_RandomAccessIterator2, _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept; _RandomAccessIterator2, _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept;
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 10 Linesbool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_Compare, _Compare,
/* __is_vector = */ std::true_type) noexcept; /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool bool
__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool bool
__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept; _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept;
#endif #endif
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_algorithm_fwd_H */ #endif /* _PSTL_ALGORITHM_FWD_H */

include/pstl/internal/algorithm_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- algorithm_impl.h --------------------------------------------------===// //===-- algorithm_impl.h --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_algorithm_impl_H #ifndef _PSTL_ALGORITHM_IMPL_H
#define __PSTL_algorithm_impl_H #define _PSTL_ALGORITHM_IMPL_H
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <functional> #include <functional>
#include <algorithm> #include <algorithm>
#include "execution_impl.h" #include "execution_impl.h"
#include "memory_impl.h" #include "memory_impl.h"
#include "parallel_backend_utils.h" #include "parallel_backend_utils.h"
#include "unseq_backend_simd.h" #include "unseq_backend_simd.h"
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
# include "parallel_backend.h" # include "parallel_backend.h"
# include "parallel_impl.h" # include "parallel_impl.h"
#endif #endif
namespace __pstl namespace __pstl
{ {
namespace __internal namespace __internal
{ {
Show All 21 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool bool
__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
_IsVector __is_vector, /*parallel=*/std::false_type) noexcept _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_any_of(__first, __last, __pred, __is_vector); return __internal::__brick_any_of(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool bool
__pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, __pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
_IsVector __is_vector, /*parallel=*/std::true_type) _IsVector __is_vector, /*parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
return __internal::__parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last, return __internal::__parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
Show All 39 Lines
void void
__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f, __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
_IsVector __is_vector, _IsVector __is_vector,
/*parallel=*/std::false_type) noexcept /*parallel=*/std::false_type) noexcept
{ {
__internal::__brick_walk1(__first, __last, __f, __is_vector); __internal::__brick_walk1(__first, __last, __f, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
void void
__pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f, __pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
_IsVector __is_vector, _IsVector __is_vector,
/*parallel=*/std::true_type) /*parallel=*/std::true_type)
{ {
__internal::__except_handler([&]() { __internal::__except_handler([&]() {
__par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
__internal::__brick_walk1(__i, __j, __f, __is_vector); __internal::__brick_walk1(__i, __j, __f, __is_vector);
}); });
}); });
} }
#endif #endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void void
__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
/*parallel=*/std::false_type) noexcept /*parallel=*/std::false_type) noexcept
{ {
__brick(__first, __last); __brick(__first, __last);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void void
__pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, __pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
/*parallel=*/std::true_type) /*parallel=*/std::true_type)
{ {
__internal::__except_handler([&]() { __internal::__except_handler([&]() {
__par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); }); [__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); });
Show All 23 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector, __pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_walk1_n(__first, __n, __f, __is_vector); return __internal::__brick_walk1_n(__first, __n, __f, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f, __pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f,
_IsVector __is_vector, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
__internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector, __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector,
std::true_type()); std::true_type());
return __first + __n; return __first + __n;
} }
#endif #endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
_ForwardIterator _ForwardIterator
__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick, __pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __brick(__first, __n); return __brick(__first, __n);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
_RandomAccessIterator _RandomAccessIterator
__pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick, __pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
__par_backend::__parallel_for( __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, std::forward<_ExecutionPolicy>(__exec), __first, __first + __n,
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_walk2(__first1, __last1, __first2, __f, __is_vector); return __internal::__brick_walk2(__first1, __last1, __first2, __f, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type) _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
__par_backend::__parallel_for( __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
Show All 27 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
_ForwardIterator2 _ForwardIterator2
__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept _ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept
{ {
return __brick(__first1, __last1, __first2); return __brick(__first1, __last1, __first2);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick> template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
_RandomAccessIterator2 _RandomAccessIterator2
__pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
__par_backend::__parallel_for( __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
[__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
__brick(__i, __j, __first2 + (__i - __first1)); __brick(__i, __j, __first2 + (__i - __first1));
}); });
return __first2 + (__last1 - __first1); return __first2 + (__last1 - __first1);
}); });
} }
#endif #endif
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick> template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
_RandomAccessIterator2 _RandomAccessIterator2
__pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n, __pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n,
_RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
__par_backend::__parallel_for( __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
Show All 40 Linestemplate <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
class _Function, class _IsVector> class _Function, class _IsVector>
_ForwardIterator3 _ForwardIterator3
__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector); return __internal::__brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
class _RandomAccessIterator3, class _Function, class _IsVector> class _RandomAccessIterator3, class _Function, class _IsVector>
_RandomAccessIterator3 _RandomAccessIterator3
__pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector, _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector,
/*parallel=*/std::true_type) /*parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
Show All 38 Lines
bool bool
__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ _ForwardIterator2 __last2, _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */
std::false_type) noexcept std::false_type) noexcept
{ {
return __internal::__brick_equal(__first1, __last1, __first2, __last2, __p, __is_vector); return __internal::__brick_equal(__first1, __last1, __first2, __last2, __p, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
bool bool
__pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __p, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __p,
_IsVector __is_vector, /*is_parallel=*/std::true_type) _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
if (__last1 - __first1 != __last2 - __first2) if (__last1 - __first1 != __last2 - __first2)
Show All 35 Linestemplate <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
bool bool
__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{ {
return __internal::__brick_equal(__first1, __last1, __first2, __p, __is_vector); return __internal::__brick_equal(__first1, __last1, __first2, __p, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
bool bool
__pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector, _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
Show All 32 Lines
_ForwardIterator _ForwardIterator
__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
_IsVector __is_vector, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_find_if(__first, __last, __pred, __is_vector); return __internal::__brick_find_if(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, __pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
_IsVector __is_vector, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
return __internal::__parallel_find( return __internal::__parallel_find(
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
_ForwardIterator1 _ForwardIterator1
__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector); return __internal::__brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, __pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
_IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
{ {
if (__last - __first == __s_last - __s_first) if (__last - __first == __s_last - __s_first)
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
_ForwardIterator1 _ForwardIterator1
__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
_IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector); return __internal::__brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, __pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
_IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
Show All 31 Lines
_ForwardIterator1 _ForwardIterator1
__pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, __pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector); return __internal::__brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector> class _IsVector>
_ForwardIterator1 _ForwardIterator1
__pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, __pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
_IsVector __is_vector, _IsVector __is_vector,
/*is_parallel=*/std::true_type) noexcept /*is_parallel=*/std::true_type) noexcept
{ {
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
_ForwardIterator _ForwardIterator
__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count, __pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_search_n(__first, __last, __count, __value, __pred, __is_vector); return __internal::__brick_search_n(__first, __last, __count, __value, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate,
class _IsVector> class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
/*is_parallel=*/std::true_type) noexcept /*is_parallel=*/std::true_type) noexcept
{ {
if (__last - __first == __count) if (__last - __first == __count)
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
return std::copy_if(__first, __last, __result, __pred); return std::copy_if(__first, __last, __result, __pred);
} }
template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate> template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
_OutputIterator _OutputIterator
__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, __brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
/*vector=*/std::true_type) noexcept /*vector=*/std::true_type) noexcept
{ {
#if (__PSTL_MONOTONIC_PRESENT) #if (_PSTL_MONOTONIC_PRESENT)
return __unseq_backend::__simd_copy_if(__first, __last - __first, __result, __pred); return __unseq_backend::__simd_copy_if(__first, __last - __first, __result, __pred);
#else #else
return std::copy_if(__first, __last, __result, __pred); return std::copy_if(__first, __last, __result, __pred);
#endif #endif
} }
// TODO: Try to use transform_reduce for combining __brick_copy_if_phase1 on IsVector. // TODO: Try to use transform_reduce for combining __brick_copy_if_phase1 on IsVector.
template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate> template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask,
} }
} }
template <class _ForwardIterator, class _OutputIterator, class _Assigner> template <class _ForwardIterator, class _OutputIterator, class _Assigner>
void void
__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, __brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
bool* __restrict __mask, _Assigner __assigner, /*vector=*/std::true_type) noexcept bool* __restrict __mask, _Assigner __assigner, /*vector=*/std::true_type) noexcept
{ {
#if (__PSTL_MONOTONIC_PRESENT) #if (_PSTL_MONOTONIC_PRESENT)
__unseq_backend::__simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner); __unseq_backend::__simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner);
#else #else
__internal::__brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type()); __internal::__brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type());
#endif #endif
} }
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2> template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
void void
Show All 15 Lines__brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
} }
} }
template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2> template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
void void
__brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true, __brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true,
_OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept
{ {
#if (__PSTL_MONOTONIC_PRESENT) #if (_PSTL_MONOTONIC_PRESENT)
__unseq_backend::__simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask); __unseq_backend::__simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask);
#else #else
__internal::__brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type()); __internal::__brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type());
#endif #endif
} }
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
_OutputIterator _OutputIterator
__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, __pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
_UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_copy_if(__first, __last, __result, __pred, __is_vector); return __internal::__brick_copy_if(__first, __last, __result, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate,
class _IsVector> class _IsVector>
_OutputIterator _OutputIterator
__pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type) _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type)
{ {
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
const _DifferenceType __n = __last - __first; const _DifferenceType __n = __last - __first;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type typename std::iterator_traits<_ForwardIterator>::difference_type
__pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, __pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
/* is_parallel */ std::false_type, _IsVector __is_vector) noexcept /* is_parallel */ std::false_type, _IsVector __is_vector) noexcept
{ {
return __internal::__brick_count(__first, __last, __pred, __is_vector); return __internal::__brick_count(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type typename std::iterator_traits<_ForwardIterator>::difference_type
__pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, __pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
/* is_parallel */ std::true_type, _IsVector __is_vector) /* is_parallel */ std::true_type, _IsVector __is_vector)
{ {
typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType; typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType;
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
return __par_backend::__parallel_reduce( return __par_backend::__parallel_reduce(
Show All 18 Lines__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
return std::unique(__first, __last, __pred); return std::unique(__first, __last, __pred);
} }
template <class _ForwardIterator, class _BinaryPredicate> template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator _ForwardIterator
__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, __brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
/*is_vector=*/std::true_type) noexcept /*is_vector=*/std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::unique(__first, __last, __pred); return std::unique(__first, __last, __pred);
} }
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, __pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
_IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_unique(__first, __last, __pred, __is_vector); return __internal::__brick_unique(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
// That function is shared between two algorithms - remove_if (__pattern_remove_if) and unique (pattern unique). But a mask calculation is different. // That function is shared between two algorithms - remove_if (__pattern_remove_if) and unique (pattern unique). But a mask calculation is different.
// So, a caller passes _CalcMask brick into remove_elements. // So, a caller passes _CalcMask brick into remove_elements.
template <class _ExecutionPolicy, class _ForwardIterator, class _CalcMask, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _CalcMask, class _IsVector>
_ForwardIterator _ForwardIterator
__remove_elements(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _CalcMask __calc_mask, __remove_elements(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _CalcMask __calc_mask,
_IsVector __is_vector) _IsVector __is_vector)
{ {
typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines return __internal::__except_handler([&]() {
[__result, __first, __is_vector](_Tp* __i, _Tp* __j) { [__result, __first, __is_vector](_Tp* __i, _Tp* __j) {
__internal::__brick_move(__i, __j, __first + (__i - __result), __is_vector); __internal::__brick_move(__i, __j, __first + (__i - __result), __is_vector);
}); });
return __first + __m; return __first + __m;
}); });
} }
#endif #endif
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, __pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
_IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
{ {
typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType;
if (__first == __last) if (__first == __last)
Show All 28 Lines__brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred,
return std::unique_copy(__first, __last, __result, __pred); return std::unique_copy(__first, __last, __result, __pred);
} }
template <class _RandomAccessIterator, class OutputIterator, class _BinaryPredicate> template <class _RandomAccessIterator, class OutputIterator, class _BinaryPredicate>
OutputIterator OutputIterator
__brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result, __brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result,
_BinaryPredicate __pred, /*vector=*/std::true_type) noexcept _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
{ {
#if (__PSTL_MONOTONIC_PRESENT) #if (_PSTL_MONOTONIC_PRESENT)
return __unseq_backend::__simd_unique_copy(__first, __last - __first, __result, __pred); return __unseq_backend::__simd_unique_copy(__first, __last - __first, __result, __pred);
#else #else
return std::unique_copy(__first, __last, __result, __pred); return std::unique_copy(__first, __last, __result, __pred);
#endif #endif
} }
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate, template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate,
class _IsVector> class _IsVector>
Show All 21 Lines
template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate> template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
_DifferenceType _DifferenceType
__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, __brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
_BinaryPredicate __pred, /*vector=*/std::true_type) noexcept _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
{ {
return __unseq_backend::__simd_calc_mask_2(__first, __last - __first, __mask, __pred); return __unseq_backend::__simd_calc_mask_2(__first, __last - __first, __mask, __pred);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate,
class _IsVector> class _IsVector>
_OutputIterator _OutputIterator
__pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector, _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector,
/*parallel=*/std::true_type) /*parallel=*/std::true_type)
{ {
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
void void
__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
_IsVector _is_vector, _IsVector _is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
__internal::__brick_reverse(__first, __last, _is_vector); __internal::__brick_reverse(__first, __last, _is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
void void
__pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, __pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
_IsVector __is_vector, /*is_parallel=*/std::true_type) _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
__par_backend::__parallel_for( __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2, std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2,
[__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) { [__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) {
Show All 29 Lines
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_reverse_copy(__first, __last, __d_first, __is_vector); return __internal::__brick_reverse_copy(__first, __last, __d_first, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, __pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type) _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
auto __len = __last - __first; auto __len = __last - __first;
__par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first, [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first,
Show All 9 Lines
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// rotate // rotate
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator> template <class _ForwardIterator>
_ForwardIterator _ForwardIterator
__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, __brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
/*is_vector=*/std::false_type) noexcept /*is_vector=*/std::false_type) noexcept
{ {
#if __PSTL_CPP11_STD_ROTATE_BROKEN #if _PSTL_CPP11_STD_ROTATE_BROKEN
std::rotate(__first, __middle, __last); std::rotate(__first, __middle, __last);
return std::next(__first, std::distance(__middle, __last)); return std::next(__first, std::distance(__middle, __last));
#else #else
return std::rotate(__first, __middle, __last); return std::rotate(__first, __middle, __last);
#endif #endif
} }
template <class _ForwardIterator> template <class _ForwardIterator>
Show All 40 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
_IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_rotate(__first, __middle, __last, __is_vector); return __internal::__brick_rotate(__first, __middle, __last, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, __pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _IsVector __is_vector, /*is_parallel=*/std::true_type) _ForwardIterator __last, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp; typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
auto __n = __last - __first; auto __n = __last - __first;
auto __m = __middle - __first; auto __m = __middle - __first;
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
_OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_rotate_copy(__first, __middle, __last, __result, __is_vector); return __internal::__brick_rotate_copy(__first, __middle, __last, __result, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, __pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector, _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
__par_backend::__parallel_for( __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first, __last, std::forward<_ExecutionPolicy>(__exec), __first, __last,
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool bool
__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
_IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_is_partitioned(__first, __last, __pred, __is_vector); return __internal::__brick_is_partitioned(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool bool
__pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, __pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
_UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type) _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
if (__first == __last) if (__first == __last)
{ {
return true; return true;
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
return std::partition(__first, __last, __pred); return std::partition(__first, __last, __pred);
} }
template <class _ForwardIterator, class _UnaryPredicate> template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator _ForwardIterator
__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, __brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
/*is_vector=*/std::true_type) noexcept /*is_vector=*/std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::partition(__first, __last, __pred); return std::partition(__first, __last, __pred);
} }
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, __pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
_IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_partition(__first, __last, __pred, __is_vector); return __internal::__brick_partition(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, __pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
_UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type) _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
// partitioned range: elements before pivot satisfy pred (true part), // partitioned range: elements before pivot satisfy pred (true part),
// elements after pivot don't satisfy pred (false part) // elements after pivot don't satisfy pred (false part)
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred,
return std::stable_partition(__first, __last, __pred); return std::stable_partition(__first, __last, __pred);
} }
template <class _BidirectionalIterator, class _UnaryPredicate> template <class _BidirectionalIterator, class _UnaryPredicate>
_BidirectionalIterator _BidirectionalIterator
__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, __brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred,
/*__is_vector=*/std::true_type) noexcept /*__is_vector=*/std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::stable_partition(__first, __last, __pred); return std::stable_partition(__first, __last, __pred);
} }
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator _BidirectionalIterator
__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
_UnaryPredicate __pred, _IsVector __is_vector, _UnaryPredicate __pred, _IsVector __is_vector,
/*is_parallelization=*/std::false_type) noexcept /*is_parallelization=*/std::false_type) noexcept
{ {
return __internal::__brick_stable_partition(__first, __last, __pred, __is_vector); return __internal::__brick_stable_partition(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator _BidirectionalIterator
__pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, __pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
_UnaryPredicate __pred, _IsVector __is_vector, _UnaryPredicate __pred, _IsVector __is_vector,
/*is_parallelization=*/std::true_type) noexcept /*is_parallelization=*/std::true_type) noexcept
{ {
// partitioned range: elements before pivot satisfy pred (true part), // partitioned range: elements before pivot satisfy pred (true part),
// elements after pivot don't satisfy pred (false part) // elements after pivot don't satisfy pred (false part)
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
return std::partition_copy(__first, __last, __out_true, __out_false, __pred); return std::partition_copy(__first, __last, __out_true, __out_false, __pred);
} }
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate> template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
std::pair<_OutputIterator1, _OutputIterator2> std::pair<_OutputIterator1, _OutputIterator2>
__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, __brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
_OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept
{ {
#if (__PSTL_MONOTONIC_PRESENT) #if (_PSTL_MONOTONIC_PRESENT)
return __unseq_backend::__simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred); return __unseq_backend::__simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred);
#else #else
return std::partition_copy(__first, __last, __out_true, __out_false, __pred); return std::partition_copy(__first, __last, __out_true, __out_false, __pred);
#endif #endif
} }
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate, class _IsVector> class _UnaryPredicate, class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2> std::pair<_OutputIterator1, _OutputIterator2>
__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, __pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
_OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
_IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept
{ {
return __internal::__brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); return __internal::__brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate, class _IsVector> class _UnaryPredicate, class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2> std::pair<_OutputIterator1, _OutputIterator2>
__pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
_IsVector __is_vector, /*is_parallelization=*/std::true_type) _IsVector __is_vector, /*is_parallelization=*/std::true_type)
{ {
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
Show All 37 Linestemplate <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector,
class _IsMoveConstructible> class _IsMoveConstructible>
void void
__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
_IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept _IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept
{ {
std::sort(__first, __last, __comp); std::sort(__first, __last, __comp);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, __pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
_IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type) _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type)
{ {
__internal::__except_handler([&]() { __internal::__except_handler([&]() {
__par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
[](_RandomAccessIterator __first, _RandomAccessIterator __last, [](_RandomAccessIterator __first, _RandomAccessIterator __last,
Show All 10 Lines
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
_IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept
{ {
std::stable_sort(__first, __last, __comp); std::stable_sort(__first, __last, __comp);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type) _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type)
{ {
__internal::__except_handler([&]() { __internal::__except_handler([&]() {
__par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
[](_RandomAccessIterator __first, _RandomAccessIterator __last, [](_RandomAccessIterator __first, _RandomAccessIterator __last,
Show All 10 Lines
void void
__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle, __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp, _IsVector, _RandomAccessIterator __last, _Compare __comp, _IsVector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
std::partial_sort(__first, __middle, __last, __comp); std::partial_sort(__first, __middle, __last, __comp);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, __pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type) _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type)
{ {
const auto __n = __middle - __first; const auto __n = __middle - __first;
__internal::__except_handler([&]() { __internal::__except_handler([&]() {
__par_backend::__parallel_stable_sort( __par_backend::__parallel_stable_sort(
Show All 17 Lines
_RandomAccessIterator _RandomAccessIterator
__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
_RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp); return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, __pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
_RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp,
_IsVector __is_vector, /*is_parallel=*/std::true_type) _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
if (__last == __first || __d_last == __d_first) if (__last == __first || __d_last == __d_first)
{ {
return __d_first; return __d_first;
} }
auto __n1 = __last - __first; auto __n1 = __last - __first;
auto __n2 = __d_last - __d_first; auto __n2 = __d_last - __d_first;
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
if (__n2 >= __n1) if (__n2 >= __n1)
{ {
__par_backend::__parallel_stable_sort( __par_backend::__parallel_stable_sort(
std::forward<_ExecutionPolicy>(__exec), __d_first, __d_first + __n1, __comp, std::forward<_ExecutionPolicy>(__exec), __d_first, __d_first + __n1, __comp,
[__first, __d_first, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j, [__first, __d_first, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j,
_Compare __comp) { _Compare __comp) {
_ForwardIterator __i1 = __first + (__i - __d_first); _ForwardIterator __i1 = __first + (__i - __d_first);
_ForwardIterator __j1 = __first + (__j - __d_first); _ForwardIterator __j1 = __first + (__j - __d_first);
// 1. Copy elements from input to output // 1. Copy elements from input to output
# if !__PSTL_ICC_18_OMP_SIMD_BROKEN # if !_PSTL_ICC_18_OMP_SIMD_BROKEN
__internal::__brick_copy(__i1, __j1, __i, __is_vector); __internal::__brick_copy(__i1, __j1, __i, __is_vector);
# else # else
std::copy(__i1, __j1, __i); std::copy(__i1, __j1, __i);
# endif # endif
// 2. Sort elements in output sequence // 2. Sort elements in output sequence
std::sort(__i, __j, __comp); std::sort(__i, __j, __comp);
}, },
__n1); __n1);
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, __pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
/* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept /* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept
{ {
return __internal::__brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic); return __internal::__brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector, _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector,
bool __or_semantic) bool __or_semantic)
{ {
if (__last - __first < 2) if (__last - __first < 2)
return __last; return __last;
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
void void
__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth, __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp, _IsVector, _RandomAccessIterator __last, _Compare __comp, _IsVector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
std::nth_element(__first, __nth, __last, __comp); std::nth_element(__first, __nth, __last, __comp);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void void
__pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, __pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector,
/*is_parallel=*/std::true_type) noexcept /*is_parallel=*/std::true_type) noexcept
{ {
if (__first == __last || __nth == __last) if (__first == __last || __nth == __last)
{ {
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
void void
__pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, __pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
/*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
{ {
__internal::__brick_fill(__first, __last, __value, __is_vector); __internal::__brick_fill(__first, __last, __value, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, __pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
/*is_parallel=*/std::true_type, _IsVector __is_vector) /*is_parallel=*/std::true_type, _IsVector __is_vector)
{ {
return __internal::__except_handler([&__exec, __first, __last, &__value, __is_vector]() { return __internal::__except_handler([&__exec, __first, __last, &__value, __is_vector]() {
__par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
[&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
void void
__pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, __pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
/*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
{ {
__internal::__brick_generate(__first, __last, __g, __is_vector); __internal::__brick_generate(__first, __last, __g, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, __pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
/*is_parallel=*/std::true_type, _IsVector __is_vector) /*is_parallel=*/std::true_type, _IsVector __is_vector)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
__par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
Show All 21 Lines
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector> template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g, __pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g,
/*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
{ {
return __internal::__brick_generate_n(__first, __count, __g, __is_vector); return __internal::__brick_generate_n(__first, __count, __g, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector> template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector>
_OutputIterator _OutputIterator
__pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g, __pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g,
/*is_parallel=*/std::true_type, _IsVector __is_vector) /*is_parallel=*/std::true_type, _IsVector __is_vector)
{ {
static_assert(__is_random_access_iterator<_OutputIterator>::value, static_assert(__is_random_access_iterator<_OutputIterator>::value,
"Pattern-brick error. Should be a random access iterator."); "Pattern-brick error. Should be a random access iterator.");
return __internal::__pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g, return __internal::__pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g,
Show All 13 Lines__brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
return std::remove_if(__first, __last, __pred); return std::remove_if(__first, __last, __pred);
} }
template <class _RandomAccessIterator, class _UnaryPredicate> template <class _RandomAccessIterator, class _UnaryPredicate>
_RandomAccessIterator _RandomAccessIterator
__brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred, __brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred,
/* __is_vector = */ std::true_type) noexcept /* __is_vector = */ std::true_type) noexcept
{ {
#if __PSTL_MONOTONIC_PRESENT #if _PSTL_MONOTONIC_PRESENT
return __unseq_backend::__simd_remove_if(__first, __last - __first, __pred); return __unseq_backend::__simd_remove_if(__first, __last - __first, __pred);
#else #else
return std::remove_if(__first, __last, __pred); return std::remove_if(__first, __last, __pred);
#endif #endif
} }
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
_IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept _IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept
{ {
return __internal::__brick_remove_if(__first, __last, __pred, __is_vector); return __internal::__brick_remove_if(__first, __last, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator _ForwardIterator
__pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, __pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
_UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept
{ {
typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType;
if (__first == __last || __first + 1 == __last) if (__first == __last || __first + 1 == __last)
Show All 26 Lines
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator _OutputIterator
__brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp,
/* __is_vector = */ std::true_type) noexcept /* __is_vector = */ std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp); return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp);
} }
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector, _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector,
/* is_parallel = */ std::false_type) noexcept /* is_parallel = */ std::false_type) noexcept
{ {
return __internal::__brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector); return __internal::__brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first,
_Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
{ {
__par_backend::__parallel_merge( __par_backend::__parallel_merge(
Show All 17 Lines__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
std::inplace_merge(__first, __middle, __last, __comp); std::inplace_merge(__first, __middle, __last, __comp);
} }
template <class _BidirectionalIterator, class _Compare> template <class _BidirectionalIterator, class _Compare>
void void
__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, __brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
_Compare __comp, /* __is_vector = */ std::true_type) noexcept _Compare __comp, /* __is_vector = */ std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial") _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial")
std::inplace_merge(__first, __middle, __last, __comp); std::inplace_merge(__first, __middle, __last, __comp);
} }
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void void
__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle, __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle,
_BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
/* is_parallel = */ std::false_type) noexcept /* is_parallel = */ std::false_type) noexcept
{ {
__internal::__brick_inplace_merge(__first, __middle, __last, __comp, __is_vector); __internal::__brick_inplace_merge(__first, __middle, __last, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void void
__pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, __pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
_BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
if (__first == __last || __first == __middle || __middle == __last) if (__first == __last || __first == __middle || __middle == __last)
{ {
Show All 40 Lines
bool bool
__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return std::includes(__first1, __last1, __first2, __last2, __comp); return std::includes(__first1, __last1, __first2, __last2, __comp);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool bool
__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
if (__first2 >= __last2) if (__first2 >= __last2)
return true; return true;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines return __internal::__except_handler([&]() {
return !std::includes(__b, __last1, __i, __j, __comp); return !std::includes(__b, __last1, __i, __j, __comp);
}); });
}); });
} }
#endif #endif
constexpr auto __set_algo_cut_off = 1000; constexpr auto __set_algo_cut_off = 1000;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector, class _SizeFunction, class _SetOP> class _Compare, class _IsVector, class _SizeFunction, class _SetOP>
_OutputIterator _OutputIterator
__parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
_SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector) _SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector)
{ {
typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines return __internal::__except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector,
__scan(0, 0, __total); __scan(0, 0, __total);
__m = __total.__pos + __total.__len; __m = __total.__pos + __total.__len;
}); });
return __result + __m; return __result + __m;
}); });
} }
#endif #endif
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
//a shared parallel pattern for '__pattern_set_union' and '__pattern_set_symmetric_difference' //a shared parallel pattern for '__pattern_set_union' and '__pattern_set_symmetric_difference'
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _SetUnionOp, class _IsVector> class _Compare, class _SetUnionOp, class _IsVector>
_OutputIterator _OutputIterator
__parallel_set_union_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __parallel_set_union_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
_Compare __comp, _SetUnionOp __set_union_op, _IsVector __is_vector) _Compare __comp, _SetUnionOp __set_union_op, _IsVector __is_vector)
{ {
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator _OutputIterator
__brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
/*__is_vector=*/std::true_type) noexcept /*__is_vector=*/std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
} }
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
_IsVector __is_vector, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); return __internal::__brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
_IsVector __is_vector, /*__is_parallel=*/std::true_type) _IsVector __is_vector, /*__is_parallel=*/std::true_type)
{ {
Show All 28 Lines
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator _OutputIterator
__brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
/*__is_vector=*/std::true_type) noexcept /*__is_vector=*/std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
} }
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
_Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); return __internal::__brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
_Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
typedef typename std::iterator_traits<_OutputIterator>::value_type _T; typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator _OutputIterator
__brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
/*__is_vector=*/std::true_type) noexcept /*__is_vector=*/std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
} }
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
_Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); return __internal::__brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
_Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
typedef typename std::iterator_traits<_OutputIterator>::value_type _T; typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
} }
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator _OutputIterator
__brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
/*__is_vector=*/std::true_type) noexcept /*__is_vector=*/std::true_type) noexcept
{ {
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
} }
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
_Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp, return __internal::__brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp,
__is_vector); __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector> class _Compare, class _IsVector>
_OutputIterator _OutputIterator
__pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
_Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
__is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp, __is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
/* __is_vector = */ std::true_type) noexcept /* __is_vector = */ std::true_type) noexcept
{ {
return __unseq_backend::__simd_first( return __unseq_backend::__simd_first(
__first, __begin, __end, __first, __begin, __end,
[&__comp](_RandomAccessIterator __it, _DifferenceType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); }); [&__comp](_RandomAccessIterator __it, _DifferenceType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); });
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
{ {
if (__last - __first < 2) if (__last - __first < 2)
return __last; return __last;
Show All 20 Lines__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
return std::min_element(__first, __last, __comp); return std::min_element(__first, __last, __comp);
} }
template <typename _ForwardIterator, typename _Compare> template <typename _ForwardIterator, typename _Compare>
_ForwardIterator _ForwardIterator
__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, __brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
/* __is_vector = */ std::true_type) noexcept /* __is_vector = */ std::true_type) noexcept
{ {
#if __PSTL_UDR_PRESENT #if _PSTL_UDR_PRESENT
return __unseq_backend::__simd_min_element(__first, __last - __first, __comp); return __unseq_backend::__simd_min_element(__first, __last - __first, __comp);
#else #else
return std::min_element(__first, __last, __comp); return std::min_element(__first, __last, __comp);
#endif #endif
} }
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
_ForwardIterator _ForwardIterator
__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, __pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
_IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{ {
return __internal::__brick_min_element(__first, __last, __comp, __is_vector); return __internal::__brick_min_element(__first, __last, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector>
_RandomAccessIterator _RandomAccessIterator
__pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
{ {
if (__first == __last) if (__first == __last)
return __last; return __last;
Show All 25 Lines__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
return std::minmax_element(__first, __last, __comp); return std::minmax_element(__first, __last, __comp);
} }
template <typename _ForwardIterator, typename _Compare> template <typename _ForwardIterator, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator> std::pair<_ForwardIterator, _ForwardIterator>
__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, __brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
/* __is_vector = */ std::true_type) noexcept /* __is_vector = */ std::true_type) noexcept
{ {
#if __PSTL_UDR_PRESENT #if _PSTL_UDR_PRESENT
return __unseq_backend::__simd_minmax_element(__first, __last - __first, __comp); return __unseq_backend::__simd_minmax_element(__first, __last - __first, __comp);
#else #else
return std::minmax_element(__first, __last, __comp); return std::minmax_element(__first, __last, __comp);
#endif #endif
} }
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator> std::pair<_ForwardIterator, _ForwardIterator>
__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
_IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{ {
return __internal::__brick_minmax_element(__first, __last, __comp, __is_vector); return __internal::__brick_minmax_element(__first, __last, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector> template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator> std::pair<_ForwardIterator, _ForwardIterator>
__pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, __pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
_IsVector __is_vector, /* is_parallel = */ std::true_type) _IsVector __is_vector, /* is_parallel = */ std::true_type)
{ {
if (__first == __last) if (__first == __last)
return std::make_pair(__first, __first); return std::make_pair(__first, __first);
Show All 20 Lines
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// mismatch // mismatch
//------------------------------------------------------------------------ //------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
std::pair<_ForwardIterator1, _ForwardIterator2> std::pair<_ForwardIterator1, _ForwardIterator2>
__mismatch_serial(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, __mismatch_serial(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __pred) _ForwardIterator2 __last2, _BinaryPredicate __pred)
{ {
#if __PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT #if _PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT
return std::mismatch(__first1, __last1, __first2, __last2, __pred); return std::mismatch(__first1, __last1, __first2, __last2, __pred);
#else #else
for (; __first1 != __last1 && __first2 != __last2 && __pred(*__first1, *__first2); ++__first1, ++__first2) for (; __first1 != __last1 && __first2 != __last2 && __pred(*__first1, *__first2); ++__first1, ++__first2)
{ {
} }
return std::make_pair(__first1, __first2); return std::make_pair(__first1, __first2);
#endif #endif
} }
Show All 19 Lines
std::pair<_ForwardIterator1, _ForwardIterator2> std::pair<_ForwardIterator1, _ForwardIterator2>
__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector,
/* is_parallel = */ std::false_type) noexcept /* is_parallel = */ std::false_type) noexcept
{ {
return __internal::__brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector); return __internal::__brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate,
class _IsVector> class _IsVector>
std::pair<_RandomAccessIterator1, _RandomAccessIterator2> std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
__pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred,
_IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
bool bool
__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
_IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{ {
return __internal::__brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector); return __internal::__brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool bool
__pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
_IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
{ {
if (__first2 == __last2) if (__first2 == __last2)
{ // if second sequence is empty { // if second sequence is empty
Show All 32 Lines else
} }
} }
} }
#endif #endif
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_algorithm_impl_H */ #endif /* _PSTL_ALGORITHM_IMPL_H */

include/pstl/internal/execution_defs.h

// -*- C++ -*- // -*- C++ -*-
//===-- execution_defs.h --------------------------------------------------===// //===-- execution_defs.h --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_execution_policy_defs_H #ifndef _PSTL_EXECUTION_POLICY_DEFS_H
#define __PSTL_execution_policy_defs_H #define _PSTL_EXECUTION_POLICY_DEFS_H
#include <type_traits> #include <type_traits>
namespace __pstl namespace __pstl
{ {
namespace execution namespace execution
{ {
inline namespace v1 inline namespace v1
Show All 16 Lines public:
} }
static constexpr std::false_type static constexpr std::false_type
__allow_parallel() __allow_parallel()
{ {
return std::false_type{}; return std::false_type{};
} }
}; };
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
// 2.5, Parallel execution policy // 2.5, Parallel execution policy
class parallel_policy class parallel_policy
{ {
public: public:
// For internal use only // For internal use only
static constexpr std::false_type static constexpr std::false_type
__allow_unsequenced() __allow_unsequenced()
{ {
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines public:
__allow_parallel() __allow_parallel()
{ {
return std::false_type{}; return std::false_type{};
} }
}; };
// 2.8, Execution policy objects // 2.8, Execution policy objects
constexpr sequenced_policy seq{}; constexpr sequenced_policy seq{};
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
constexpr parallel_policy par{}; constexpr parallel_policy par{};
constexpr parallel_unsequenced_policy par_unseq{}; constexpr parallel_unsequenced_policy par_unseq{};
#endif #endif
constexpr unsequenced_policy unseq{}; constexpr unsequenced_policy unseq{};
// 2.3, Execution policy type trait // 2.3, Execution policy type trait
template <class T> template <class T>
struct is_execution_policy : std::false_type struct is_execution_policy : std::false_type
{ {
}; };
template <> template <>
struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type
{ {
}; };
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <> template <>
struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type
{ {
}; };
template <> template <>
struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type
{ {
}; };
#endif #endif
template <> template <>
struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type
{ {
}; };
#if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT #if _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
template <class T> template <class T>
constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<T>::value; constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<T>::value;
#endif #endif
} // namespace v1 } // namespace v1
} // namespace execution } // namespace execution
namespace __internal namespace __internal
{ {
template <class ExecPolicy, class T> template <class ExecPolicy, class T>
using __enable_if_execution_policy = using __enable_if_execution_policy =
typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<ExecPolicy>::type>::value, typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<ExecPolicy>::type>::value,
T>::type; T>::type;
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_execution_policy_defs_H */ #endif /* _PSTL_EXECUTION_POLICY_DEFS_H */

include/pstl/internal/execution_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- execution_impl.h --------------------------------------------------===// //===-- execution_impl.h --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_execution_impl_H #ifndef _PSTL_EXECUTION_IMPL_H
#define __PSTL_execution_impl_H #define _PSTL_EXECUTION_IMPL_H
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include "execution_defs.h" #include "execution_defs.h"
namespace __pstl namespace __pstl
{ {
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
template <> template <>
struct __policy_traits<unsequenced_policy> struct __policy_traits<unsequenced_policy>
{ {
typedef std::false_type allow_parallel; typedef std::false_type allow_parallel;
typedef std::true_type allow_unsequenced; typedef std::true_type allow_unsequenced;
typedef std::true_type allow_vector; typedef std::true_type allow_vector;
}; };
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <> template <>
struct __policy_traits<parallel_policy> struct __policy_traits<parallel_policy>
{ {
typedef std::true_type allow_parallel; typedef std::true_type allow_parallel;
typedef std::false_type allow_unsequenced; typedef std::false_type allow_unsequenced;
typedef std::false_type allow_vector; typedef std::false_type allow_vector;
}; };
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesstruct __prefer_parallel_tag
static constexpr bool value = __internal::__allow_parallel<policy>::value && static constexpr bool value = __internal::__allow_parallel<policy>::value &&
__internal::__is_random_access_iterator<_IteratorTypes...>::value; __internal::__is_random_access_iterator<_IteratorTypes...>::value;
typedef std::integral_constant<bool, value> type; typedef std::integral_constant<bool, value> type;
}; };
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_execution_impl_H */ #endif /* _PSTL_EXECUTION_IMPL_H */

include/pstl/internal/glue_algorithm_defs.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_algorithm_defs.h ---------------------------------------------===// //===-- glue_algorithm_defs.h ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_algorithm_defs_H #ifndef _PSTL_GLUE_ALGORITHM_DEFS_H
#define __PSTL_glue_algorithm_defs_H #define _PSTL_GLUE_ALGORITHM_DEFS_H
#include <functional> #include <functional>
#include <iterator> #include <iterator>
#include "execution_defs.h" #include "execution_defs.h"
namespace std namespace std
{ {
▲ Show 20 Lines • Show All 524 Lines • ▼ Show 20 Lineslexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp); _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2); _ForwardIterator2 __first2, _ForwardIterator2 __last2);
} // namespace std } // namespace std
#endif /* __PSTL_glue_algorithm_defs_H */ #endif /* _PSTL_GLUE_ALGORITHM_DEFS_H */

include/pstl/internal/glue_algorithm_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_algorithm_impl.h ---------------------------------------------===// //===-- glue_algorithm_impl.h ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_algorithm_impl_H #ifndef _PSTL_GLUE_ALGORITHM_IMPL_H
#define __PSTL_glue_algorithm_impl_H #define _PSTL_GLUE_ALGORITHM_IMPL_H
#include <functional> #include <functional>
#include "execution_defs.h" #include "execution_defs.h"
#include "utils.h" #include "utils.h"
#include "algorithm_fwd.h" #include "algorithm_fwd.h"
#include "numeric_fwd.h" /* count and count_if use __pattern_transform_reduce */ #include "numeric_fwd.h" /* count and count_if use __pattern_transform_reduce */
▲ Show 20 Lines • Show All 1,156 Lines • ▼ Show 20 Lineslexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2) _ForwardIterator2 __first2, _ForwardIterator2 __last2)
{ {
return std::lexicographical_compare(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, return std::lexicographical_compare(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2,
__pstl::__internal::__pstl_less()); __pstl::__internal::__pstl_less());
} }
} // namespace std } // namespace std
#endif /* __PSTL_glue_algorithm_impl_H */ #endif /* _PSTL_GLUE_ALGORITHM_IMPL_H */

include/pstl/internal/glue_execution_defs.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_execution_defs.h ---------------------------------------------===// //===-- glue_execution_defs.h ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_execution_defs_H #ifndef _PSTL_GLUE_EXECUTION_DEFS_H
#define __PSTL_glue_execution_defs_H #define _PSTL_GLUE_EXECUTION_DEFS_H
#include <type_traits> #include <type_traits>
#include "execution_defs.h" #include "execution_defs.h"
namespace std namespace std
{ {
// Type trait // Type trait
using __pstl::execution::is_execution_policy; using __pstl::execution::is_execution_policy;
#if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT #if _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
# if __INTEL_COMPILER # if __INTEL_COMPILER
template <class T> template <class T>
constexpr bool is_execution_policy_v = is_execution_policy<T>::value; constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
# else # else
using __pstl::execution::is_execution_policy_v; using __pstl::execution::is_execution_policy_v;
# endif # endif
#endif #endif
namespace execution namespace execution
{ {
// Standard C++ policy classes // Standard C++ policy classes
using __pstl::execution::sequenced_policy; using __pstl::execution::sequenced_policy;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
using __pstl::execution::parallel_policy; using __pstl::execution::parallel_policy;
using __pstl::execution::parallel_unsequenced_policy; using __pstl::execution::parallel_unsequenced_policy;
#endif #endif
// Standard predefined policy instances // Standard predefined policy instances
using __pstl::execution::seq; using __pstl::execution::seq;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
using __pstl::execution::par; using __pstl::execution::par;
using __pstl::execution::par_unseq; using __pstl::execution::par_unseq;
#endif #endif
// Implementation-defined names // Implementation-defined names
// Unsequenced policy is not yet standard, but for consistency // Unsequenced policy is not yet standard, but for consistency
// we include it into namespace std::execution as well // we include it into namespace std::execution as well
using __pstl::execution::unseq; using __pstl::execution::unseq;
using __pstl::execution::unsequenced_policy; using __pstl::execution::unsequenced_policy;
} // namespace execution } // namespace execution
} // namespace std } // namespace std
#include "algorithm_impl.h" #include "algorithm_impl.h"
#include "numeric_impl.h" #include "numeric_impl.h"
#include "parallel_backend.h" #include "parallel_backend.h"
#endif /* __PSTL_glue_execution_defs_H */ #endif /* _PSTL_GLUE_EXECUTION_DEFS_H */

include/pstl/internal/glue_memory_defs.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_memory_defs.h ------------------------------------------------===// //===-- glue_memory_defs.h ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_memory_defs_H #ifndef _PSTL_GLUE_MEMORY_DEFS_H
#define __PSTL_glue_memory_defs_H #define _PSTL_GLUE_MEMORY_DEFS_H
#include "execution_defs.h" #include "execution_defs.h"
namespace std namespace std
{ {
// [uninitialized.copy] // [uninitialized.copy]
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size> template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
} // namespace std } // namespace std
#endif /* __PSTL_glue_memory_defs_H */ #endif /* _PSTL_GLUE_MEMORY_DEFS_H */

include/pstl/internal/glue_memory_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_memory_impl.h ------------------------------------------------===// //===-- glue_memory_impl.h ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_memory_impl_H #ifndef _PSTL_GLUE_MEMORY_IMPL_H
#define __PSTL_glue_memory_impl_H #define _PSTL_GLUE_MEMORY_IMPL_H
#include "execution_defs.h" #include "execution_defs.h"
#include "utils.h" #include "utils.h"
#include "algorithm_fwd.h" #include "algorithm_fwd.h"
#include "execution_impl.h" #include "execution_impl.h"
namespace std namespace std
▲ Show 20 Lines • Show All 333 Lines • ▼ Show 20 Lines return __internal::__invoke_if_else(
return __internal::__pattern_walk1_n( return __internal::__pattern_walk1_n(
std::forward<_ExecutionPolicy>(__exec), __first, __n, std::forward<_ExecutionPolicy>(__exec), __first, __n,
[](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, __is_vector, __is_parallel); [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, __is_vector, __is_parallel);
}); });
} }
} // namespace std } // namespace std
#endif /* __PSTL_glue_memory_imple_H */ #endif /* _PSTL_GLUE_MEMORY_IMPL_H */

include/pstl/internal/glue_numeric_defs.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_numeric_defs.h -----------------------------------------------===// //===-- glue_numeric_defs.h -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_numeric_defs_H #ifndef _PSTL_GLUE_NUMERIC_DEFS_H
#define __PSTL_glue_numeric_defs_H #define _PSTL_GLUE_NUMERIC_DEFS_H
#include <iterator> #include <iterator>
#include "execution_defs.h" #include "execution_defs.h"
namespace std namespace std
{ {
// [reduce] // [reduce]
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Linesadjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __d_first, _BinaryOperation op); _ForwardIterator2 __d_first, _BinaryOperation op);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2> template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __d_first); _ForwardIterator2 __d_first);
} // namespace std } // namespace std
#endif /* __PSTL_glue_numeric_defs_H */ #endif /* _PSTL_GLUE_NUMERIC_DEFS_H */

include/pstl/internal/glue_numeric_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_numeric_impl.h -----------------------------------------------===// //===-- glue_numeric_impl.h -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_numeric_impl_H #ifndef _PSTL_GLUE_NUMERIC_IMPL_H
#define __PSTL_glue_numeric_impl_H #define _PSTL_GLUE_NUMERIC_IMPL_H
#include <functional> #include <functional>
#include "utils.h" #include "utils.h"
#include "numeric_fwd.h" #include "numeric_fwd.h"
#include "execution_impl.h" #include "execution_impl.h"
namespace std namespace std
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Lines
{ {
typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType;
return adjacent_difference(std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, return adjacent_difference(std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first,
std::minus<_ValueType>()); std::minus<_ValueType>());
} }
} // namespace std } // namespace std
#endif /* __PSTL_glue_numeric_impl_H_ */ #endif /* _PSTL_GLUE_NUMERIC_IMPL_H_ */

include/pstl/internal/memory_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- memory_impl.h -----------------------------------------------------===// //===-- memory_impl.h -----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_memory_impl_H #ifndef _PSTL_MEMORY_IMPL_H
#define __PSTL_memory_impl_H #define _PSTL_MEMORY_IMPL_H
#include <iterator> #include <iterator>
#include "unseq_backend_simd.h" #include "unseq_backend_simd.h"
namespace __pstl namespace __pstl
{ {
namespace __internal namespace __internal
Show All 28 Lines__brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
return __unseq_backend::__simd_walk_2( return __unseq_backend::__simd_walk_2(
__first, __last - __first, __result, __first, __last - __first, __result,
[](_ReferenceType1 __x, _ReferenceType2 __y) { ::new (std::addressof(__y)) __ValueType2(std::move(__x)); }); [](_ReferenceType1 __x, _ReferenceType2 __y) { ::new (std::addressof(__y)) __ValueType2(std::move(__x)); });
} }
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_memory_impl_H */ #endif /* _PSTL_MEMORY_IMPL_H */

include/pstl/internal/numeric_fwd.h

// -*- C++ -*- // -*- C++ -*-
//===-- numeric_fwd.h --------------------------------------------------===// //===-- numeric_fwd.h --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_numeric_fwd_H #ifndef _PSTL_NUMERIC_FWD_H
#define __PSTL_numeric_fwd_H #define _PSTL_NUMERIC_FWD_H
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
namespace __pstl namespace __pstl
{ {
namespace __internal namespace __internal
{ {
Show All 14 Lines
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
class _BinaryOperation2, class _IsVector> class _BinaryOperation2, class _IsVector>
_Tp _Tp
__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp,
_BinaryOperation1, _BinaryOperation2, _IsVector, _BinaryOperation1, _BinaryOperation2, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp,
class _BinaryOperation1, class _BinaryOperation2, class _IsVector> class _BinaryOperation1, class _BinaryOperation2, class _IsVector>
_Tp _Tp
__pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, __pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_Tp, _BinaryOperation1, _BinaryOperation2, _IsVector __is_vector, _Tp, _BinaryOperation1, _BinaryOperation2, _IsVector __is_vector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
Show All 11 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
class _IsVector> class _IsVector>
_Tp _Tp
__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation,
_UnaryOperation, _IsVector, _UnaryOperation, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
class _IsVector> class _IsVector>
_Tp _Tp
__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation,
_UnaryOperation, _IsVector, _UnaryOperation, _IsVector,
/*is_parallel=*/std::true_type); /*is_parallel=*/std::true_type);
#endif #endif
Show All 15 Lines
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector> class _BinaryOperation, class _Inclusive, class _IsVector>
_OutputIterator _OutputIterator
__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp, __pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp,
_BinaryOperation, _Inclusive, _IsVector, _BinaryOperation, _Inclusive, _IsVector,
/*is_parallel=*/std::false_type) noexcept; /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector> class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type
__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, __pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
_UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type); _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
#endif #endif
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector> class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type
__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, __pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
_UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type); _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
#endif #endif
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 9 Lines_OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
/*is_vector*/ std::true_type) noexcept; /*is_vector*/ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation, template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation,
class _IsVector> class _IsVector>
_OutputIterator _OutputIterator
__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, __pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
_IsVector, /*is_parallel*/ std::false_type) noexcept; _IsVector, /*is_parallel*/ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation, template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation,
class _IsVector> class _IsVector>
_OutputIterator _OutputIterator
__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, __pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
_IsVector, /*is_parallel*/ std::true_type); _IsVector, /*is_parallel*/ std::true_type);
#endif #endif
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_numeric_fwd_H */ #endif /* _PSTL_NUMERIC_FWD_H */

include/pstl/internal/numeric_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- numeric_impl.h ----------------------------------------------------===// //===-- numeric_impl.h ----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_numeric_impl_H #ifndef _PSTL_NUMERIC_IMPL_H
#define __PSTL_numeric_impl_H #define _PSTL_NUMERIC_IMPL_H
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <numeric> #include <numeric>
#include "execution_impl.h" #include "execution_impl.h"
#include "unseq_backend_simd.h" #include "unseq_backend_simd.h"
#include "algorithm_fwd.h" #include "algorithm_fwd.h"
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
# include "parallel_backend.h" # include "parallel_backend.h"
#endif #endif
namespace __pstl namespace __pstl
{ {
namespace __internal namespace __internal
{ {
Show All 28 Lines
__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
_BinaryOperation2 __binary_op2, _IsVector __is_vector, _BinaryOperation2 __binary_op2, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector); return __brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp, template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp,
class _BinaryOperation1, class _BinaryOperation2, class _IsVector> class _BinaryOperation1, class _BinaryOperation2, class _IsVector>
_Tp _Tp
__pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, __pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
_RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
_BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type) _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
_Tp _Tp
__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
_BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
/*is_parallel=*/std::false_type) noexcept /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector); return __internal::__brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
class _IsVector> class _IsVector>
_Tp _Tp
__pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, __pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
_BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
return __internal::__except_handler([&]() { return __internal::__except_handler([&]() {
Show All 18 Lines
std::pair<_OutputIterator, _Tp> std::pair<_OutputIterator, _Tp>
__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
_UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
/*Inclusive*/ std::false_type, /*is_vector=*/std::false_type) noexcept /*Inclusive*/ std::false_type, /*is_vector=*/std::false_type) noexcept
{ {
for (; __first != __last; ++__first, ++__result) for (; __first != __last; ++__first, ++__result)
{ {
*__result = __init; *__result = __init;
__PSTL_PRAGMA_FORCEINLINE _PSTL_PRAGMA_FORCEINLINE
__init = __binary_op(__init, __unary_op(*__first)); __init = __binary_op(__init, __unary_op(*__first));
} }
return std::make_pair(__result, __init); return std::make_pair(__result, __init);
} }
// Inclusive form // Inclusive form
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation> template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
std::pair<_OutputIterator, _Tp> std::pair<_OutputIterator, _Tp>
__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
_UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
/*Inclusive*/ std::true_type, /*is_vector=*/std::false_type) noexcept /*Inclusive*/ std::true_type, /*is_vector=*/std::false_type) noexcept
{ {
for (; __first != __last; ++__first, ++__result) for (; __first != __last; ++__first, ++__result)
{ {
__PSTL_PRAGMA_FORCEINLINE _PSTL_PRAGMA_FORCEINLINE
__init = __binary_op(__init, __unary_op(*__first)); __init = __binary_op(__init, __unary_op(*__first));
*__result = __init; *__result = __init;
} }
return std::make_pair(__result, __init); return std::make_pair(__result, __init);
} }
// type is arithmetic and binary operation is a user defined operation. // type is arithmetic and binary operation is a user defined operation.
template <typename _Tp, typename _BinaryOperation> template <typename _Tp, typename _BinaryOperation>
using is_arithmetic_udop = std::integral_constant<bool, std::is_arithmetic<_Tp>::value && using is_arithmetic_udop = std::integral_constant<bool, std::is_arithmetic<_Tp>::value &&
!std::is_same<_BinaryOperation, std::plus<_Tp>>::value>; !std::is_same<_BinaryOperation, std::plus<_Tp>>::value>;
// [restriction] - T shall be DefaultConstructible. // [restriction] - T shall be DefaultConstructible.
// [violation] - default ctor of T shall set the identity value for binary_op. // [violation] - default ctor of T shall set the identity value for binary_op.
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation, template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
class _Inclusive> class _Inclusive>
typename std::enable_if<!is_arithmetic_udop<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type typename std::enable_if<!is_arithmetic_udop<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
_UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
/*is_vector=*/std::true_type) noexcept /*is_vector=*/std::true_type) noexcept
{ {
#if (__PSTL_UDS_PRESENT) #if (_PSTL_UDS_PRESENT)
return __unseq_backend::__simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op, return __unseq_backend::__simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op,
_Inclusive()); _Inclusive());
#else #else
// We need to call serial brick here to call function for inclusive and exclusive scan that depends on _Inclusive() value // We need to call serial brick here to call function for inclusive and exclusive scan that depends on _Inclusive() value
return __internal::__brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), return __internal::__brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
/*is_vector=*/std::false_type()); /*is_vector=*/std::false_type());
#endif #endif
} }
Show All 16 Lines__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
_Inclusive, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{ {
return __internal::__brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), return __internal::__brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
__is_vector) __is_vector)
.first; .first;
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector> class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type
__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
_Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
Show All 15 Lines return __internal::__except_handler([&]() {
__init, __binary_op, _Inclusive(), __is_vector) __init, __binary_op, _Inclusive(), __is_vector)
.second; .second;
}); });
return __result + (__last - __first); return __result + (__last - __first);
}); });
} }
#endif #endif
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector> class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type
__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, __pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
_Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{ {
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
Show All 10 Lines return __internal::__except_handler([&]() {
return __internal::__brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i, return __internal::__brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i,
__unary_op, _Tp{}, __binary_op, _Inclusive(), __is_vector) __unary_op, _Tp{}, __binary_op, _Inclusive(), __is_vector)
.second; .second;
}, },
__binary_op, __binary_op,
[__result, &__binary_op](_DifferenceType __i, _DifferenceType __len, _Tp __initial) { [__result, &__binary_op](_DifferenceType __i, _DifferenceType __len, _Tp __initial) {
return *(std::transform(__result + __i, __result + __i + __len, __result + __i, return *(std::transform(__result + __i, __result + __i + __len, __result + __i,
[&__initial, &__binary_op](const _Tp& __x) { [&__initial, &__binary_op](const _Tp& __x) {
__PSTL_PRAGMA_FORCEINLINE _PSTL_PRAGMA_FORCEINLINE
return __binary_op(__initial, __x); return __binary_op(__initial, __x);
}) - }) -
1); 1);
}, },
[](_Tp __res) {}); [](_Tp __res) {});
return __result + (__last - __first); return __result + (__last - __first);
}); });
} }
Show All 33 Lines
_OutputIterator _OutputIterator
__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, __pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
_OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector, _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector,
/*is_parallel*/ std::false_type) noexcept /*is_parallel*/ std::false_type) noexcept
{ {
return __internal::__brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector); return __internal::__brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector);
} }
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation, template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation,
class _IsVector> class _IsVector>
_ForwardIterator2 _ForwardIterator2
__pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, __pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector, _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector,
/*is_parallel=*/std::true_type) /*is_parallel=*/std::true_type)
{ {
assert(__first != __last); assert(__first != __last);
Show All 12 Lines __par_backend::__parallel_for(
}); });
return __d_first + (__last - __first); return __d_first + (__last - __first);
} }
#endif #endif
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_numeric_impl_H */ #endif /* _PSTL_NUMERIC_IMPL_H */

include/pstl/internal/parallel_backend.h

// -*- C++ -*- // -*- C++ -*-
//===-- parallel_backend.h ------------------------------------------------===// //===-- parallel_backend.h ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_parallel_backend_H #ifndef _PSTL_PARALLEL_BACKEND_H
#define __PSTL_parallel_backend_H #define _PSTL_PARALLEL_BACKEND_H
#if __PSTL_PAR_BACKEND_TBB #if _PSTL_PAR_BACKEND_TBB
# include "parallel_backend_tbb.h" # include "parallel_backend_tbb.h"
#else #else
__PSTL_PRAGMA_MESSAGE("Parallel backend was not specified"); _PSTL_PRAGMA_MESSAGE("Parallel backend was not specified");
#endif #endif
#endif /* __PSTL_parallel_backend_H */ #endif /* _PSTL_PARALLEL_BACKEND_H */

include/pstl/internal/parallel_backend_tbb.h

// -*- C++ -*- // -*- C++ -*-
//===-- parallel_backend_tbb.h --------------------------------------------===// //===-- parallel_backend_tbb.h --------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_parallel_backend_tbb_H #ifndef _PSTL_PARALLEL_BACKEND_TBB_H
#define __PSTL_parallel_backend_tbb_H #define _PSTL_PARALLEL_BACKEND_TBB_H
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <type_traits> #include <type_traits>
#include "parallel_backend_utils.h" #include "parallel_backend_utils.h"
// Bring in minimal required subset of Intel TBB // Bring in minimal required subset of Intel TBB
▲ Show 20 Lines • Show All 407 Lines • ▼ Show 20 Lines __merge_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
_RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _Cleanup __cleanup, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _Cleanup __cleanup,
_LeafMerge __leaf_merge) _LeafMerge __leaf_merge)
: _M_xs(__xs), _M_xe(__xe), _M_ys(__ys), _M_ye(__ye), _M_zs(__zs), _M_comp(__comp), _M_cleanup(__cleanup), : _M_xs(__xs), _M_xe(__xe), _M_ys(__ys), _M_ye(__ye), _M_zs(__zs), _M_comp(__comp), _M_cleanup(__cleanup),
_M_leaf_merge(__leaf_merge) _M_leaf_merge(__leaf_merge)
{ {
} }
}; };
#define __PSTL_MERGE_CUT_OFF 2000 #define _PSTL_MERGE_CUT_OFF 2000
template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3, template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
typename __M_Compare, typename _Cleanup, typename _LeafMerge> typename __M_Compare, typename _Cleanup, typename _LeafMerge>
tbb::task* tbb::task*
__merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _Cleanup, __merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _Cleanup,
_LeafMerge>::execute() _LeafMerge>::execute()
{ {
typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1; typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2; typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType; typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
const _SizeType __n = (_M_xe - _M_xs) + (_M_ye - _M_ys); const _SizeType __n = (_M_xe - _M_xs) + (_M_ye - _M_ys);
const _SizeType __merge_cut_off = __PSTL_MERGE_CUT_OFF; const _SizeType __merge_cut_off = _PSTL_MERGE_CUT_OFF;
if (__n <= __merge_cut_off) if (__n <= __merge_cut_off)
{ {
_M_leaf_merge(_M_xs, _M_xe, _M_ys, _M_ye, _M_zs, _M_comp); _M_leaf_merge(_M_xs, _M_xe, _M_ys, _M_ye, _M_zs, _M_comp);
//we clean the buffer one time on last step of the sort //we clean the buffer one time on last step of the sort
_M_cleanup(_M_xs, _M_xe); _M_cleanup(_M_xs, _M_xe);
_M_cleanup(_M_ys, _M_ye); _M_cleanup(_M_ys, _M_ye);
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
struct __binary_no_op struct __binary_no_op
{ {
template <typename _T> template <typename _T>
void operator()(_T, _T) void operator()(_T, _T)
{ {
} }
}; };
#define __PSTL_STABLE_SORT_CUT_OFF 500 #define _PSTL_STABLE_SORT_CUT_OFF 500
template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort> template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort>
tbb::task* tbb::task*
__stable_sort_task<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::execute() __stable_sort_task<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::execute()
{ {
const _SizeType __n = _M_xe - _M_xs; const _SizeType __n = _M_xe - _M_xs;
const _SizeType __nmerge = _M_nsort > 0 ? _M_nsort : __n; const _SizeType __nmerge = _M_nsort > 0 ? _M_nsort : __n;
const _SizeType __sort_cut_off = __PSTL_STABLE_SORT_CUT_OFF; const _SizeType __sort_cut_off = _PSTL_STABLE_SORT_CUT_OFF;
if (__n <= __sort_cut_off) if (__n <= __sort_cut_off)
{ {
_M_leaf_sort(_M_xs, _M_xe, _M_comp); _M_leaf_sort(_M_xs, _M_xe, _M_comp);
if (_M_inplace != 2) if (_M_inplace != 2)
__par_backend::__init_buf(_M_xs, _M_xe, _M_zs, _M_inplace == 0); __par_backend::__init_buf(_M_xs, _M_xe, _M_zs, _M_inplace == 0);
return NULL; return NULL;
} }
else else
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines__parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
tbb::this_task_arena::isolate([=, &__nsort]() { tbb::this_task_arena::isolate([=, &__nsort]() {
//sorting based on task tree and parallel merge //sorting based on task tree and parallel merge
typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType;
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
const _DifferenceType __n = __xe - __xs; const _DifferenceType __n = __xe - __xs;
if (__nsort == 0) if (__nsort == 0)
__nsort = __n; __nsort = __n;
const _DifferenceType __sort_cut_off = __PSTL_STABLE_SORT_CUT_OFF; const _DifferenceType __sort_cut_off = _PSTL_STABLE_SORT_CUT_OFF;
if (__n > __sort_cut_off) if (__n > __sort_cut_off)
{ {
assert(__nsort > 0 && __nsort <= __n); assert(__nsort > 0 && __nsort <= __n);
__buffer<_ValueType> __buf(__n); __buffer<_ValueType> __buf(__n);
using tbb::task; using tbb::task;
task::spawn_root_and_wait(*new (task::allocate_root()) task::spawn_root_and_wait(*new (task::allocate_root())
__stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>( __stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>(
__xs, __xe, (_ValueType*)__buf.get(), 2, __comp, __leaf_sort, __nsort)); __xs, __xe, (_ValueType*)__buf.get(), 2, __comp, __leaf_sort, __nsort));
Show All 14 Lines
__parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, __parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe,
_RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp,
_LeafMerge __leaf_merge) _LeafMerge __leaf_merge)
{ {
typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1; typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2; typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType; typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
const _SizeType __n = (__xe - __xs) + (__ye - __ys); const _SizeType __n = (__xe - __xs) + (__ye - __ys);
const _SizeType __merge_cut_off = __PSTL_MERGE_CUT_OFF; const _SizeType __merge_cut_off = _PSTL_MERGE_CUT_OFF;
if (__n <= __merge_cut_off) if (__n <= __merge_cut_off)
{ {
// Fall back on serial merge // Fall back on serial merge
__leaf_merge(__xs, __xe, __ys, __ye, __zs, __comp); __leaf_merge(__xs, __xe, __ys, __ye, __zs, __comp);
} }
else else
{ {
tbb::this_task_arena::isolate([=]() { tbb::this_task_arena::isolate([=]() {
Show All 15 Lines
{ {
//TODO: a version of tbb::this_task_arena::isolate with variadic arguments pack should be added in the future //TODO: a version of tbb::this_task_arena::isolate with variadic arguments pack should be added in the future
tbb::this_task_arena::isolate([&]() { tbb::parallel_invoke(std::forward<_F1>(__f1), std::forward<_F2>(__f2)); }); tbb::this_task_arena::isolate([&]() { tbb::parallel_invoke(std::forward<_F1>(__f1), std::forward<_F2>(__f2)); });
} }
} // namespace __par_backend } // namespace __par_backend
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_parallel_backend_tbb_H */ #endif /* _PSTL_PARALLEL_BACKEND_TBB_H */

include/pstl/internal/parallel_backend_utils.h

// -*- C++ -*- // -*- C++ -*-
//===-- parallel_backend_utils.h ------------------------------------------===// //===-- parallel_backend_utils.h ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_parallel_backend_utils_H #ifndef _PSTL_PARALLEL_BACKEND_UTILS_H
#define __PSTL_parallel_backend_utils_H #define _PSTL_PARALLEL_BACKEND_UTILS_H
#include <iterator> #include <iterator>
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include "utils.h" #include "utils.h"
namespace __pstl namespace __pstl
{ {
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines pop()
--_M_ptr; --_M_ptr;
(*_M_ptr).~_ValueType(); (*_M_ptr).~_ValueType();
} }
}; };
} // namespace __par_backend } // namespace __par_backend
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_parallel_backend_utils_H */ #endif /* _PSTL_PARALLEL_BACKEND_UTILS_H */

include/pstl/internal/parallel_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- parallel_impl.h ---------------------------------------------------===// //===-- parallel_impl.h ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_parallel_impl_H #ifndef _PSTL_PARALLEL_IMPL_H
#define __PSTL_parallel_impl_H #define _PSTL_PARALLEL_IMPL_H
#include <atomic> #include <atomic>
// This header defines the minimum set of parallel routines required to support Parallel STL, // This header defines the minimum set of parallel routines required to support Parallel STL,
// implemented on top of Intel(R) Threading Building Blocks (Intel(R) TBB) library // implemented on top of Intel(R) Threading Building Blocks (Intel(R) TBB) library
namespace __pstl namespace __pstl
{ {
namespace __internal namespace __internal
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
} }
}); });
return __found; return __found;
} }
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_parallel_impl_H */ #endif /* _PSTL_PARALLEL_IMPL_H */

include/pstl/internal/pstl_config.h

// -*- C++ -*- // -*- C++ -*-
//===-- pstl_config.h -----------------------------------------------------===// //===-- pstl_config.h -----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_config_H #ifndef _PSTL_CONFIG_H
#define __PSTL_config_H #define _PSTL_CONFIG_H
#define PSTL_VERSION 203 #define PSTL_VERSION 203
#define PSTL_VERSION_MAJOR (PSTL_VERSION / 100) #define PSTL_VERSION_MAJOR (PSTL_VERSION / 100)
#define PSTL_VERSION_MINOR (PSTL_VERSION - PSTL_VERSION_MAJOR * 100) #define PSTL_VERSION_MINOR (PSTL_VERSION - PSTL_VERSION_MAJOR * 100)
// Check the user-defined macro for parallel policies // Check the user-defined macro for parallel policies
#if defined(PSTL_USE_PARALLEL_POLICIES) #if defined(PSTL_USE_PARALLEL_POLICIES)
# undef __PSTL_USE_PAR_POLICIES # undef _PSTL_USE_PAR_POLICIES
# define __PSTL_USE_PAR_POLICIES PSTL_USE_PARALLEL_POLICIES # define _PSTL_USE_PAR_POLICIES PSTL_USE_PARALLEL_POLICIES
// Check the internal macro for parallel policies // Check the internal macro for parallel policies
#elif !defined(__PSTL_USE_PAR_POLICIES) #elif !defined(_PSTL_USE_PAR_POLICIES)
# define __PSTL_USE_PAR_POLICIES 1 # define _PSTL_USE_PAR_POLICIES 1
#endif #endif
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
# if !defined(__PSTL_PAR_BACKEND_TBB) # if !defined(_PSTL_PAR_BACKEND_TBB)
# define __PSTL_PAR_BACKEND_TBB 1 # define _PSTL_PAR_BACKEND_TBB 1
# endif # endif
#else #else
# undef __PSTL_PAR_BACKEND_TBB # undef _PSTL_PAR_BACKEND_TBB
#endif #endif
// Check the user-defined macro for warnings // Check the user-defined macro for warnings
#if defined(PSTL_USAGE_WARNINGS) #if defined(PSTL_USAGE_WARNINGS)
# undef __PSTL_USAGE_WARNINGS # undef _PSTL_USAGE_WARNINGS
# define __PSTL_USAGE_WARNINGS PSTL_USAGE_WARNINGS # define _PSTL_USAGE_WARNINGS PSTL_USAGE_WARNINGS
// Check the internal macro for warnings // Check the internal macro for warnings
#elif !defined(__PSTL_USAGE_WARNINGS) #elif !defined(_PSTL_USAGE_WARNINGS)
# define __PSTL_USAGE_WARNINGS 0 # define _PSTL_USAGE_WARNINGS 0
#endif #endif
// Portability "#pragma" definition // Portability "#pragma" definition
#ifdef _MSC_VER #ifdef _MSC_VER
# define __PSTL_PRAGMA(x) __pragma(x) # define _PSTL_PRAGMA(x) __pragma(x)
#else #else
# define __PSTL_PRAGMA(x) _Pragma(# x) # define _PSTL_PRAGMA(x) _Pragma(# x)
#endif #endif
#define __PSTL_STRING_AUX(x) #x #define _PSTL_STRING_AUX(x) #x
#define __PSTL_STRING(x) __PSTL_STRING_AUX(x) #define _PSTL_STRING(x) _PSTL_STRING_AUX(x)
#define __PSTL_STRING_CONCAT(x, y) x #y #define _PSTL_STRING_CONCAT(x, y) x #y
// note that when ICC or Clang is in use, __PSTL_GCC_VERSION might not fully match // note that when ICC or Clang is in use, _PSTL_GCC_VERSION might not fully match
// the actual GCC version on the system. // the actual GCC version on the system.
#define __PSTL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) #define _PSTL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#if __clang__ #if __clang__
// according to clang documentation, version can be vendor specific // according to clang documentation, version can be vendor specific
# define __PSTL_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) # define _PSTL_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
#endif #endif
// Enable SIMD for compilers that support OpenMP 4.0 // Enable SIMD for compilers that support OpenMP 4.0
#if (_OPENMP >= 201307) || (__INTEL_COMPILER >= 1600) || (!defined(__INTEL_COMPILER) && __PSTL_GCC_VERSION >= 40900) #if (_OPENMP >= 201307) || (__INTEL_COMPILER >= 1600) || (!defined(__INTEL_COMPILER) && _PSTL_GCC_VERSION >= 40900)
# define __PSTL_PRAGMA_SIMD __PSTL_PRAGMA(omp simd) # define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
# define __PSTL_PRAGMA_DECLARE_SIMD __PSTL_PRAGMA(omp declare simd) # define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
# define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) __PSTL_PRAGMA(omp simd reduction(PRM)) # define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
#elif !defined(_MSC_VER) //#pragma simd #elif !defined(_MSC_VER) //#pragma simd
# define __PSTL_PRAGMA_SIMD __PSTL_PRAGMA(simd) # define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(simd)
# define __PSTL_PRAGMA_DECLARE_SIMD # define _PSTL_PRAGMA_DECLARE_SIMD
# define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) __PSTL_PRAGMA(simd reduction(PRM)) # define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(simd reduction(PRM))
#else //no simd #else //no simd
# define __PSTL_PRAGMA_SIMD # define _PSTL_PRAGMA_SIMD
# define __PSTL_PRAGMA_DECLARE_SIMD # define _PSTL_PRAGMA_DECLARE_SIMD
# define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) # define _PSTL_PRAGMA_SIMD_REDUCTION(PRM)
#endif //Enable SIMD #endif //Enable SIMD
#if (__INTEL_COMPILER) #if (__INTEL_COMPILER)
# define __PSTL_PRAGMA_FORCEINLINE __PSTL_PRAGMA(forceinline) # define _PSTL_PRAGMA_FORCEINLINE _PSTL_PRAGMA(forceinline)
#else #else
# define __PSTL_PRAGMA_FORCEINLINE # define _PSTL_PRAGMA_FORCEINLINE
#endif #endif
#if (__INTEL_COMPILER >= 1900) #if (__INTEL_COMPILER >= 1900)
# define __PSTL_PRAGMA_SIMD_SCAN(PRM) __PSTL_PRAGMA(omp simd reduction(inscan, PRM)) # define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM))
# define __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) __PSTL_PRAGMA(omp scan inclusive(PRM)) # define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
# define __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) __PSTL_PRAGMA(omp scan exclusive(PRM)) # define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
#else #else
# define __PSTL_PRAGMA_SIMD_SCAN(PRM) # define _PSTL_PRAGMA_SIMD_SCAN(PRM)
# define __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) # define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
# define __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) # define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
#endif #endif
// Should be defined to 1 for environments with a vendor implementation of C++17 execution policies // Should be defined to 1 for environments with a vendor implementation of C++17 execution policies
#define __PSTL_CPP17_EXECUTION_POLICIES_PRESENT (_MSC_VER >= 1912) #define _PSTL_CPP17_EXECUTION_POLICIES_PRESENT (_MSC_VER >= 1912)
#define __PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT \ #define _PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT \
(_MSC_VER >= 1900 || __cplusplus >= 201300L || __cpp_lib_robust_nonmodifying_seq_ops == 201304) (_MSC_VER >= 1900 || __cplusplus >= 201300L || __cpp_lib_robust_nonmodifying_seq_ops == 201304)
#define __PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT \ #define _PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT \
(_MSC_VER >= 1900 || __cplusplus >= 201402L || __cpp_lib_make_reverse_iterator == 201402) (_MSC_VER >= 1900 || __cplusplus >= 201402L || __cpp_lib_make_reverse_iterator == 201402)
#define __PSTL_CPP14_INTEGER_SEQUENCE_PRESENT (_MSC_VER >= 1900 || __cplusplus >= 201402L) #define _PSTL_CPP14_INTEGER_SEQUENCE_PRESENT (_MSC_VER >= 1900 || __cplusplus >= 201402L)
#define __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT \ #define _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT \
(!__INTEL_COMPILER || __INTEL_COMPILER >= 1700) && (_MSC_FULL_VER >= 190023918 || __cplusplus >= 201402L) (!__INTEL_COMPILER || __INTEL_COMPILER >= 1700) && (_MSC_FULL_VER >= 190023918 || __cplusplus >= 201402L)
#define __PSTL_EARLYEXIT_PRESENT (__INTEL_COMPILER >= 1800) #define _PSTL_EARLYEXIT_PRESENT (__INTEL_COMPILER >= 1800)
#define __PSTL_MONOTONIC_PRESENT (__INTEL_COMPILER >= 1800) #define _PSTL_MONOTONIC_PRESENT (__INTEL_COMPILER >= 1800)
#if (__INTEL_COMPILER >= 1900 || !defined(__INTEL_COMPILER) && __PSTL_GCC_VERSION >= 40900 || _OPENMP >= 201307) #if (__INTEL_COMPILER >= 1900 || !defined(__INTEL_COMPILER) && _PSTL_GCC_VERSION >= 40900 || _OPENMP >= 201307)
# define __PSTL_UDR_PRESENT 1 # define _PSTL_UDR_PRESENT 1
#else #else
# define __PSTL_UDR_PRESENT 0 # define _PSTL_UDR_PRESENT 0
#endif #endif
#define __PSTL_UDS_PRESENT (__INTEL_COMPILER >= 1900 && __INTEL_COMPILER_BUILD_DATE >= 20180626) #define _PSTL_UDS_PRESENT (__INTEL_COMPILER >= 1900 && __INTEL_COMPILER_BUILD_DATE >= 20180626)
#if __PSTL_EARLYEXIT_PRESENT #if _PSTL_EARLYEXIT_PRESENT
# define __PSTL_PRAGMA_SIMD_EARLYEXIT __PSTL_PRAGMA(omp simd early_exit) # define _PSTL_PRAGMA_SIMD_EARLYEXIT _PSTL_PRAGMA(omp simd early_exit)
#else #else
# define __PSTL_PRAGMA_SIMD_EARLYEXIT # define _PSTL_PRAGMA_SIMD_EARLYEXIT
#endif #endif
#if __PSTL_MONOTONIC_PRESENT #if _PSTL_MONOTONIC_PRESENT
# define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) __PSTL_PRAGMA(omp ordered simd monotonic(PRM)) # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) _PSTL_PRAGMA(omp ordered simd monotonic(PRM))
# define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) __PSTL_PRAGMA(omp ordered simd monotonic(PRM1, PRM2)) # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) _PSTL_PRAGMA(omp ordered simd monotonic(PRM1, PRM2))
#else #else
# define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM)
# define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) # define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2)
#endif #endif
// Declaration of reduction functor, where // Declaration of reduction functor, where
// NAME - the name of the functor // NAME - the name of the functor
// OP - type of the callable object with the reduction operation // OP - type of the callable object with the reduction operation
// omp_in - refers to the local partial result // omp_in - refers to the local partial result
// omp_out - refers to the final value of the combiner operator // omp_out - refers to the final value of the combiner operator
// omp_priv - refers to the private copy of the initial value // omp_priv - refers to the private copy of the initial value
// omp_orig - refers to the original variable to be reduced // omp_orig - refers to the original variable to be reduced
#define __PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP) \ #define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP) \
__PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig)) _PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
#if (__INTEL_COMPILER >= 1600) #if (__INTEL_COMPILER >= 1600)
# define __PSTL_PRAGMA_VECTOR_UNALIGNED __PSTL_PRAGMA(vector unaligned) # define _PSTL_PRAGMA_VECTOR_UNALIGNED _PSTL_PRAGMA(vector unaligned)
#else #else
# define __PSTL_PRAGMA_VECTOR_UNALIGNED # define _PSTL_PRAGMA_VECTOR_UNALIGNED
#endif #endif
// Check the user-defined macro to use non-temporal stores // Check the user-defined macro to use non-temporal stores
#if defined(PSTL_USE_NONTEMPORAL_STORES) && (__INTEL_COMPILER >= 1600) #if defined(PSTL_USE_NONTEMPORAL_STORES) && (__INTEL_COMPILER >= 1600)
# define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED __PSTL_PRAGMA(vector nontemporal) # define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED _PSTL_PRAGMA(vector nontemporal)
#else #else
# define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED # define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
#endif #endif
#if _MSC_VER || __INTEL_COMPILER //the preprocessors don't type a message location #if _MSC_VER || __INTEL_COMPILER //the preprocessors don't type a message location
# define __PSTL_PRAGMA_LOCATION __FILE__ ":" __PSTL_STRING(__LINE__) ": [Parallel STL message]: " # define _PSTL_PRAGMA_LOCATION __FILE__ ":" _PSTL_STRING(__LINE__) ": [Parallel STL message]: "
#else #else
# define __PSTL_PRAGMA_LOCATION " [Parallel STL message]: " # define _PSTL_PRAGMA_LOCATION " [Parallel STL message]: "
#endif #endif
#define __PSTL_PRAGMA_MESSAGE_IMPL(x) __PSTL_PRAGMA(message(__PSTL_STRING_CONCAT(__PSTL_PRAGMA_LOCATION, x))) #define _PSTL_PRAGMA_MESSAGE_IMPL(x) _PSTL_PRAGMA(message(_PSTL_STRING_CONCAT(_PSTL_PRAGMA_LOCATION, x)))
#if __PSTL_USAGE_WARNINGS #if _PSTL_USAGE_WARNINGS
# define __PSTL_PRAGMA_MESSAGE(x) __PSTL_PRAGMA_MESSAGE_IMPL(x) # define _PSTL_PRAGMA_MESSAGE(x) _PSTL_PRAGMA_MESSAGE_IMPL(x)
# define __PSTL_PRAGMA_MESSAGE_POLICIES(x) __PSTL_PRAGMA_MESSAGE_IMPL(x) # define _PSTL_PRAGMA_MESSAGE_POLICIES(x) _PSTL_PRAGMA_MESSAGE_IMPL(x)
#else #else
# define __PSTL_PRAGMA_MESSAGE(x) # define _PSTL_PRAGMA_MESSAGE(x)
# define __PSTL_PRAGMA_MESSAGE_POLICIES(x) # define _PSTL_PRAGMA_MESSAGE_POLICIES(x)
#endif #endif
// broken macros // broken macros
#define __PSTL_CPP11_STD_ROTATE_BROKEN ((__GLIBCXX__ && __GLIBCXX__ < 20150716) || (_MSC_VER && _MSC_VER < 1800)) #define _PSTL_CPP11_STD_ROTATE_BROKEN ((__GLIBCXX__ && __GLIBCXX__ < 20150716) || (_MSC_VER && _MSC_VER < 1800))
#define __PSTL_ICC_18_OMP_SIMD_BROKEN (__INTEL_COMPILER == 1800) #define _PSTL_ICC_18_OMP_SIMD_BROKEN (__INTEL_COMPILER == 1800)
#endif /* __PSTL_config_H */ #endif /* _PSTL_CONFIG_H */

include/pstl/internal/unseq_backend_simd.h

// -*- C++ -*- // -*- C++ -*-
//===-- unseq_backend_simd.h ----------------------------------------------===// //===-- unseq_backend_simd.h ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_unseq_backend_simd_H #ifndef _PSTL_UNSEQ_BACKEND_SIMD_H
#define __PSTL_unseq_backend_simd_H #define _PSTL_UNSEQ_BACKEND_SIMD_H
#include <type_traits> #include <type_traits>
#include "utils.h" #include "utils.h"
// This header defines the minimum set of vector routines required // This header defines the minimum set of vector routines required
// to support parallel STL. // to support parallel STL.
namespace __pstl namespace __pstl
{ {
namespace __unseq_backend namespace __unseq_backend
{ {
// Expect vector width up to 64 (or 512 bit) // Expect vector width up to 64 (or 512 bit)
const std::size_t __lane_size = 64; const std::size_t __lane_size = 64;
template <class _Iterator, class _DifferenceType, class _Function> template <class _Iterator, class _DifferenceType, class _Function>
_Iterator _Iterator
__simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept __simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept
{ {
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
__f(__first[__i]); __f(__first[__i]);
return __first + __n; return __first + __n;
} }
template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function> template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function>
_Iterator2 _Iterator2
__simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept __simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept
{ {
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
__f(__first1[__i], __first2[__i]); __f(__first1[__i], __first2[__i]);
return __first2 + __n; return __first2 + __n;
} }
template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function> template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function>
_Iterator3 _Iterator3
__simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3, __simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3,
_Function __f) noexcept _Function __f) noexcept
{ {
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
__f(__first1[__i], __first2[__i], __first3[__i]); __f(__first1[__i], __first2[__i], __first3[__i]);
return __first3 + __n; return __first3 + __n;
} }
// TODO: check whether __simd_first() can be used here // TODO: check whether __simd_first() can be used here
template <class _Index, class _DifferenceType, class _Pred> template <class _Index, class _DifferenceType, class _Pred>
bool bool
__simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept __simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
{ {
#if __PSTL_EARLYEXIT_PRESENT #if _PSTL_EARLYEXIT_PRESENT
_DifferenceType __i; _DifferenceType __i;
__PSTL_PRAGMA_VECTOR_UNALIGNED _PSTL_PRAGMA_VECTOR_UNALIGNED
__PSTL_PRAGMA_SIMD_EARLYEXIT _PSTL_PRAGMA_SIMD_EARLYEXIT
for (__i = 0; __i < __n; ++__i) for (__i = 0; __i < __n; ++__i)
if (__pred(__first[__i])) if (__pred(__first[__i]))
break; break;
return __i < __n; return __i < __n;
#else #else
_DifferenceType __block_size = 4 < __n ? 4 : __n; _DifferenceType __block_size = 4 < __n ? 4 : __n;
const _Index __last = __first + __n; const _Index __last = __first + __n;
while (__last != __first) while (__last != __first)
{ {
int32_t __flag = 1; int32_t __flag = 1;
__PSTL_PRAGMA_SIMD_REDUCTION(& : __flag) _PSTL_PRAGMA_SIMD_REDUCTION(& : __flag)
for (_DifferenceType __i = 0; __i < __block_size; ++__i) for (_DifferenceType __i = 0; __i < __block_size; ++__i)
if (__pred(*(__first + __i))) if (__pred(*(__first + __i)))
__flag = 0; __flag = 0;
if (!__flag) if (!__flag)
return true; return true;
__first += __block_size; __first += __block_size;
if (__last - __first >= __block_size << 1) if (__last - __first >= __block_size << 1)
Show All 9 Lines#else
return false; return false;
#endif #endif
} }
template <class _Index, class _DifferenceType, class _Compare> template <class _Index, class _DifferenceType, class _Compare>
_Index _Index
__simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept __simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
{ {
#if __PSTL_EARLYEXIT_PRESENT #if _PSTL_EARLYEXIT_PRESENT
_DifferenceType __i = __begin; _DifferenceType __i = __begin;
__PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
__PSTL_PRAGMA_SIMD_EARLYEXIT for (; __i < __end; ++__i) _PSTL_PRAGMA_SIMD_EARLYEXIT for (; __i < __end; ++__i)
{ {
if (__comp(__first, __i)) if (__comp(__first, __i))
{ {
break; break;
} }
} }
return __first + __i; return __first + __i;
#else #else
// Experiments show good block sizes like this // Experiments show good block sizes like this
const _DifferenceType __block_size = 8; const _DifferenceType __block_size = 8;
alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
while (__end - __begin >= __block_size) while (__end - __begin >= __block_size)
{ {
_DifferenceType __found = 0; _DifferenceType __found = 0;
__PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
__PSTL_PRAGMA_SIMD_REDUCTION(| _PSTL_PRAGMA_SIMD_REDUCTION(|
: __found) for (_DifferenceType __i = __begin; __i < __begin + __block_size; : __found) for (_DifferenceType __i = __begin; __i < __begin + __block_size;
++__i) ++__i)
{ {
const _DifferenceType __t = __comp(__first, __i); const _DifferenceType __t = __comp(__first, __i);
__lane[__i - __begin] = __t; __lane[__i - __begin] = __t;
__found |= __t; __found |= __t;
} }
if (__found) if (__found)
{ {
_DifferenceType __i; _DifferenceType __i;
Show All 15 Lines#else
{ {
if (__comp(__first, __begin)) if (__comp(__first, __begin))
{ {
return __first + __begin; return __first + __begin;
} }
++__begin; ++__begin;
} }
return __first + __end; return __first + __end;
#endif //__PSTL_EARLYEXIT_PRESENT #endif //_PSTL_EARLYEXIT_PRESENT
} }
template <class _Index1, class _DifferenceType, class _Index2, class _Pred> template <class _Index1, class _DifferenceType, class _Index2, class _Pred>
std::pair<_Index1, _Index2> std::pair<_Index1, _Index2>
__simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept __simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
{ {
#if __PSTL_EARLYEXIT_PRESENT #if _PSTL_EARLYEXIT_PRESENT
_DifferenceType __i = 0; _DifferenceType __i = 0;
__PSTL_PRAGMA_VECTOR_UNALIGNED _PSTL_PRAGMA_VECTOR_UNALIGNED
__PSTL_PRAGMA_SIMD_EARLYEXIT _PSTL_PRAGMA_SIMD_EARLYEXIT
for (; __i < __n; ++__i) for (; __i < __n; ++__i)
if (__pred(__first1[__i], __first2[__i])) if (__pred(__first1[__i], __first2[__i]))
break; break;
return std::make_pair(__first1 + __i, __first2 + __i); return std::make_pair(__first1 + __i, __first2 + __i);
#else #else
const _Index1 __last1 = __first1 + __n; const _Index1 __last1 = __first1 + __n;
const _Index2 __last2 = __first2 + __n; const _Index2 __last2 = __first2 + __n;
// Experiments show good block sizes like this // Experiments show good block sizes like this
const _DifferenceType __block_size = 8; const _DifferenceType __block_size = 8;
alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
while (__last1 - __first1 >= __block_size) while (__last1 - __first1 >= __block_size)
{ {
_DifferenceType __found = 0; _DifferenceType __found = 0;
_DifferenceType __i; _DifferenceType __i;
__PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
__PSTL_PRAGMA_SIMD_REDUCTION(| _PSTL_PRAGMA_SIMD_REDUCTION(|
: __found) for (__i = 0; __i < __block_size; ++__i) : __found) for (__i = 0; __i < __block_size; ++__i)
{ {
const _DifferenceType __t = __pred(__first1[__i], __first2[__i]); const _DifferenceType __t = __pred(__first1[__i], __first2[__i]);
__lane[__i] = __t; __lane[__i] = __t;
__found |= __t; __found |= __t;
} }
if (__found) if (__found)
{ {
_DifferenceType __i; _DifferenceType __i;
Show All 10 Lines#else
} }
//Keep remainder scalar //Keep remainder scalar
for (; __last1 != __first1; ++__first1, ++__first2) for (; __last1 != __first1; ++__first1, ++__first2)
if (__pred(*(__first1), *(__first2))) if (__pred(*(__first1), *(__first2)))
return std::make_pair(__first1, __first2); return std::make_pair(__first1, __first2);
return std::make_pair(__last1, __last2); return std::make_pair(__last1, __last2);
#endif //__PSTL_EARLYEXIT_PRESENT #endif //_PSTL_EARLYEXIT_PRESENT
} }
template <class _Index, class _DifferenceType, class _Pred> template <class _Index, class _DifferenceType, class _Pred>
_DifferenceType _DifferenceType
__simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept __simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
{ {
_DifferenceType __count = 0; _DifferenceType __count = 0;
__PSTL_PRAGMA_SIMD_REDUCTION(+ : __count) _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
if (__pred(*(__index + __i))) if (__pred(*(__index + __i)))
++__count; ++__count;
return __count; return __count;
} }
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _BinaryPredicate> template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _BinaryPredicate>
_OutputIterator _OutputIterator
__simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, __simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result,
_BinaryPredicate __pred) noexcept _BinaryPredicate __pred) noexcept
{ {
if (__n == 0) if (__n == 0)
return __result; return __result;
_DifferenceType __cnt = 1; _DifferenceType __cnt = 1;
__result[0] = __first[0]; __result[0] = __first[0];
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 1; __i < __n; ++__i) for (_DifferenceType __i = 1; __i < __n; ++__i)
{ {
__PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
if (!__pred(__first[__i], __first[__i - 1])) if (!__pred(__first[__i], __first[__i - 1]))
{ {
__result[__cnt] = __first[__i]; __result[__cnt] = __first[__i];
++__cnt; ++__cnt;
} }
} }
return __result + __cnt; return __result + __cnt;
} }
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner> template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
_OutputIterator _OutputIterator
__simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept __simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept
{ {
__PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
__assigner(__first + __i, __result + __i); __assigner(__first + __i, __result + __i);
return __result + __n; return __result + __n;
} }
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _UnaryPredicate> template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _UnaryPredicate>
_OutputIterator _OutputIterator
__simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept __simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
{ {
_DifferenceType __cnt = 0; _DifferenceType __cnt = 0;
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
{ {
__PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
if (__pred(__first[__i])) if (__pred(__first[__i]))
{ {
__result[__cnt] = __first[__i]; __result[__cnt] = __first[__i];
++__cnt; ++__cnt;
} }
} }
return __result + __cnt; return __result + __cnt;
} }
template <class _InputIterator, class _DifferenceType, class _BinaryPredicate> template <class _InputIterator, class _DifferenceType, class _BinaryPredicate>
_DifferenceType _DifferenceType
__simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept __simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept
{ {
_DifferenceType __count = 0; _DifferenceType __count = 0;
__PSTL_PRAGMA_SIMD_REDUCTION(+ : __count) _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
{ {
__mask[__i] = !__pred(__first[__i], __first[__i - 1]); __mask[__i] = !__pred(__first[__i], __first[__i - 1]);
__count += __mask[__i]; __count += __mask[__i];
} }
return __count; return __count;
} }
template <class _InputIterator, class _DifferenceType, class _UnaryPredicate> template <class _InputIterator, class _DifferenceType, class _UnaryPredicate>
_DifferenceType _DifferenceType
__simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept __simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept
{ {
_DifferenceType __count = 0; _DifferenceType __count = 0;
__PSTL_PRAGMA_SIMD_REDUCTION(+ : __count) _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
{ {
__mask[__i] = __pred(__first[__i]); __mask[__i] = __pred(__first[__i]);
__count += __mask[__i]; __count += __mask[__i];
} }
return __count; return __count;
} }
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner> template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
void void
__simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask, __simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
_Assigner __assigner) noexcept _Assigner __assigner) noexcept
{ {
_DifferenceType __cnt = 0; _DifferenceType __cnt = 0;
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
{ {
if (__mask[__i]) if (__mask[__i])
{ {
__PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
{ {
__assigner(__first + __i, __result + __cnt); __assigner(__first + __i, __result + __cnt);
++__cnt; ++__cnt;
} }
} }
} }
} }
template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2> template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2>
void void
__simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true, __simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
_OutputIterator2 __out_false, bool* __mask) noexcept _OutputIterator2 __out_false, bool* __mask) noexcept
{ {
_DifferenceType __cnt_true = 0, __cnt_false = 0; _DifferenceType __cnt_true = 0, __cnt_false = 0;
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
{ {
__PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1) _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
if (__mask[__i]) if (__mask[__i])
{ {
__out_true[__cnt_true] = __first[__i]; __out_true[__cnt_true] = __first[__i];
++__cnt_true; ++__cnt_true;
} }
else else
{ {
__out_false[__cnt_false] = __first[__i]; __out_false[__cnt_false] = __first[__i];
++__cnt_false; ++__cnt_false;
} }
} }
} }
template <class _Index, class _DifferenceType, class _Tp> template <class _Index, class _DifferenceType, class _Tp>
_Index _Index
__simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept __simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept
{ {
__PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
__first[__i] = __value; __first[__i] = __value;
return __first + __n; return __first + __n;
} }
template <class _Index, class _DifferenceType, class _Generator> template <class _Index, class _DifferenceType, class _Generator>
_Index _Index
__simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept __simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept
{ {
__PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __size; ++__i) for (_DifferenceType __i = 0; __i < __size; ++__i)
__first[__i] = __g(); __first[__i] = __g();
return __first + __size; return __first + __size;
} }
template <class _Index, class _BinaryPredicate> template <class _Index, class _BinaryPredicate>
_Index _Index
__simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept __simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
{ {
if (__last - __first < 2) if (__last - __first < 2)
return __last; return __last;
typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType; typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
_DifferenceType __i = 0; _DifferenceType __i = 0;
#if __PSTL_EARLYEXIT_PRESENT #if _PSTL_EARLYEXIT_PRESENT
//Some compiler versions fail to compile the following loop when iterators are used. Indices are used instead //Some compiler versions fail to compile the following loop when iterators are used. Indices are used instead
const _DifferenceType __n = __last - __first - 1; const _DifferenceType __n = __last - __first - 1;
__PSTL_PRAGMA_VECTOR_UNALIGNED _PSTL_PRAGMA_VECTOR_UNALIGNED
__PSTL_PRAGMA_SIMD_EARLYEXIT _PSTL_PRAGMA_SIMD_EARLYEXIT
for (; __i < __n; ++__i) for (; __i < __n; ++__i)
if (__pred(__first[__i], __first[__i + 1])) if (__pred(__first[__i], __first[__i + 1]))
break; break;
return __i < __n ? __first + __i : __last; return __i < __n ? __first + __i : __last;
#else #else
// Experiments show good block sizes like this // Experiments show good block sizes like this
//TODO: to consider tuning block_size for various data types //TODO: to consider tuning block_size for various data types
const _DifferenceType __block_size = 8; const _DifferenceType __block_size = 8;
alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
while (__last - __first >= __block_size) while (__last - __first >= __block_size)
{ {
_DifferenceType __found = 0; _DifferenceType __found = 0;
__PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
__PSTL_PRAGMA_SIMD_REDUCTION(| _PSTL_PRAGMA_SIMD_REDUCTION(|
: __found) for (__i = 0; __i < __block_size - 1; ++__i) : __found) for (__i = 0; __i < __block_size - 1; ++__i)
{ {
//TODO: to improve SIMD vectorization //TODO: to improve SIMD vectorization
const _DifferenceType __t = __pred(*(__first + __i), *(__first + __i + 1)); const _DifferenceType __t = __pred(*(__first + __i), *(__first + __i + 1));
__lane[__i] = __t; __lane[__i] = __t;
__found |= __t; __found |= __t;
} }
//Process a pair of elements on a boundary of a data block //Process a pair of elements on a boundary of a data block
Show All 26 Lines
template <typename _Tp, typename _BinaryOperation> template <typename _Tp, typename _BinaryOperation>
using is_arithmetic_plus = std::integral_constant<bool, std::is_arithmetic<_Tp>::value && using is_arithmetic_plus = std::integral_constant<bool, std::is_arithmetic<_Tp>::value &&
std::is_same<_BinaryOperation, std::plus<_Tp>>::value>; std::is_same<_BinaryOperation, std::plus<_Tp>>::value>;
template <typename _DifferenceType, typename _Tp, typename _BinaryOperation, typename _UnaryOperation> template <typename _DifferenceType, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
__simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept __simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept
{ {
__PSTL_PRAGMA_SIMD_REDUCTION(+ : __init) _PSTL_PRAGMA_SIMD_REDUCTION(+ : __init)
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
__init += __f(__i); __init += __f(__i);
return __init; return __init;
} }
template <typename _Size, typename _Tp, typename _BinaryOperation, typename _UnaryOperation> template <typename _Size, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
__simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept __simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
{ {
const _Size __block_size = __lane_size / sizeof(_Tp); const _Size __block_size = __lane_size / sizeof(_Tp);
if (__n > 2 * __block_size && __block_size > 1) if (__n > 2 * __block_size && __block_size > 1)
{ {
alignas(__lane_size) char __lane_[__lane_size]; alignas(__lane_size) char __lane_[__lane_size];
_Tp* __lane = reinterpret_cast<_Tp*>(__lane_); _Tp* __lane = reinterpret_cast<_Tp*>(__lane_);
// initializer // initializer
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_Size __i = 0; __i < __block_size; ++__i) for (_Size __i = 0; __i < __block_size; ++__i)
{ {
::new (__lane + __i) _Tp(__binary_op(__f(__i), __f(__block_size + __i))); ::new (__lane + __i) _Tp(__binary_op(__f(__i), __f(__block_size + __i)));
} }
// main loop // main loop
_Size __i = 2 * __block_size; _Size __i = 2 * __block_size;
const _Size last_iteration = __block_size * (__n / __block_size); const _Size last_iteration = __block_size * (__n / __block_size);
for (; __i < last_iteration; __i += __block_size) for (; __i < last_iteration; __i += __block_size)
{ {
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_Size __j = 0; __j < __block_size; ++__j) for (_Size __j = 0; __j < __block_size; ++__j)
{ {
__lane[__j] = __binary_op(__lane[__j], __f(__i + __j)); __lane[__j] = __binary_op(__lane[__j], __f(__i + __j));
} }
} }
// remainder // remainder
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_Size __j = 0; __j < __n - last_iteration; ++__j) for (_Size __j = 0; __j < __n - last_iteration; ++__j)
{ {
__lane[__j] = __binary_op(__lane[__j], __f(last_iteration + __j)); __lane[__j] = __binary_op(__lane[__j], __f(last_iteration + __j));
} }
// combiner // combiner
for (_Size __i = 0; __i < __block_size; ++__i) for (_Size __i = 0; __i < __block_size; ++__i)
{ {
__init = __binary_op(__init, __lane[__i]); __init = __binary_op(__init, __lane[__i]);
} }
// destroyer // destroyer
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_Size __i = 0; __i < __block_size; ++__i) for (_Size __i = 0; __i < __block_size; ++__i)
{ {
__lane[__i].~_Tp(); __lane[__i].~_Tp();
} }
} }
else else
{ {
for (_Size __i = 0; __i < __n; ++__i) for (_Size __i = 0; __i < __n; ++__i)
{ {
__init = __binary_op(__init, __f(__i)); __init = __binary_op(__init, __f(__i));
} }
} }
return __init; return __init;
} }
// Exclusive scan for "+" and arithmetic types // Exclusive scan for "+" and arithmetic types
template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation> class _BinaryOperation>
typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
_BinaryOperation, /*Inclusive*/ std::false_type) _BinaryOperation, /*Inclusive*/ std::false_type)
{ {
__PSTL_PRAGMA_SIMD_SCAN(+ : __init) _PSTL_PRAGMA_SIMD_SCAN(+ : __init)
for (_Size __i = 0; __i < __n; ++__i) for (_Size __i = 0; __i < __n; ++__i)
{ {
__result[__i] = __init; __result[__i] = __init;
__PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init) _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init)
__init += __unary_op(__first[__i]); __init += __unary_op(__first[__i]);
} }
return std::make_pair(__result + __n, __init); return std::make_pair(__result + __n, __init);
} }
// As soon as we cannot call __binary_op in "combiner" we create a wrapper over _Tp to encapsulate __binary_op // As soon as we cannot call __binary_op in "combiner" we create a wrapper over _Tp to encapsulate __binary_op
template <typename _Tp, typename _BinaryOp> template <typename _Tp, typename _BinaryOp>
struct _Combiner struct _Combiner
Show All 17 Linestemplate <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation> class _BinaryOperation>
typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
_BinaryOperation __binary_op, /*Inclusive*/ std::false_type) _BinaryOperation __binary_op, /*Inclusive*/ std::false_type)
{ {
typedef _Combiner<_Tp, _BinaryOperation> _CombinerType; typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
_CombinerType __init_{__init, &__binary_op}; _CombinerType __init_{__init, &__binary_op};
__PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType) _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
__PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_) _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
for (_Size __i = 0; __i < __n; ++__i) for (_Size __i = 0; __i < __n; ++__i)
{ {
__result[__i] = __init_.__value; __result[__i] = __init_.__value;
__PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init_) _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init_)
__PSTL_PRAGMA_FORCEINLINE _PSTL_PRAGMA_FORCEINLINE
__init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i])); __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
} }
return std::make_pair(__result + __n, __init_.__value); return std::make_pair(__result + __n, __init_.__value);
} }
// Inclusive scan for "+" and arithmetic types // Inclusive scan for "+" and arithmetic types
template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation> class _BinaryOperation>
typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
_BinaryOperation, /*Inclusive*/ std::true_type) _BinaryOperation, /*Inclusive*/ std::true_type)
{ {
__PSTL_PRAGMA_SIMD_SCAN(+ : __init) _PSTL_PRAGMA_SIMD_SCAN(+ : __init)
for (_Size __i = 0; __i < __n; ++__i) for (_Size __i = 0; __i < __n; ++__i)
{ {
__init += __unary_op(__first[__i]); __init += __unary_op(__first[__i]);
__PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init) _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init)
__result[__i] = __init; __result[__i] = __init;
} }
return std::make_pair(__result + __n, __init); return std::make_pair(__result + __n, __init);
} }
// Inclusive scan for other binary operations and types // Inclusive scan for other binary operations and types
template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp, template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation> class _BinaryOperation>
typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
_BinaryOperation __binary_op, std::true_type) _BinaryOperation __binary_op, std::true_type)
{ {
typedef _Combiner<_Tp, _BinaryOperation> _CombinerType; typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
_CombinerType __init_{__init, &__binary_op}; _CombinerType __init_{__init, &__binary_op};
__PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType) _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
__PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_) _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
for (_Size __i = 0; __i < __n; ++__i) for (_Size __i = 0; __i < __n; ++__i)
{ {
__PSTL_PRAGMA_FORCEINLINE _PSTL_PRAGMA_FORCEINLINE
__init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i])); __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
__PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init_) _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init_)
__result[__i] = __init_.__value; __result[__i] = __init_.__value;
} }
return std::make_pair(__result + __n, __init_.__value); return std::make_pair(__result + __n, __init_.__value);
} }
// [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible. // [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.
// complexity [violation] - We will have at most (__n-1 + number_of_lanes) comparisons instead of at most __n-1. // complexity [violation] - We will have at most (__n-1 + number_of_lanes) comparisons instead of at most __n-1.
template <typename _ForwardIterator, typename _Size, typename _Compare> template <typename _ForwardIterator, typename _Size, typename _Compare>
Show All 17 Lines struct _ComplexType
: __min_val(val), __min_ind(0), __min_comp(const_cast<_Compare*>(comp)) : __min_val(val), __min_ind(0), __min_comp(const_cast<_Compare*>(comp))
{ {
} }
_ComplexType(const _ComplexType& __obj) _ComplexType(const _ComplexType& __obj)
: __min_val(__obj.__min_val), __min_ind(__obj.__min_ind), __min_comp(__obj.__min_comp) : __min_val(__obj.__min_val), __min_ind(__obj.__min_ind), __min_comp(__obj.__min_comp)
{ {
} }
__PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA_DECLARE_SIMD
void void
operator()(const _ComplexType& __obj) operator()(const _ComplexType& __obj)
{ {
if (!(*__min_comp)(__min_val, __obj.__min_val) && if (!(*__min_comp)(__min_val, __obj.__min_val) &&
((*__min_comp)(__obj.__min_val, __min_val) || __obj.__min_ind - __min_ind < 0)) ((*__min_comp)(__obj.__min_val, __min_val) || __obj.__min_ind - __min_ind < 0))
{ {
__min_val = __obj.__min_val; __min_val = __obj.__min_val;
__min_ind = __obj.__min_ind; __min_ind = __obj.__min_ind;
} }
} }
}; };
_ComplexType __init{*__first, &__comp}; _ComplexType __init{*__first, &__comp};
__PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType) _PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType)
__PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init) _PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init)
for (_Size __i = 1; __i < __n; ++__i) for (_Size __i = 1; __i < __n; ++__i)
{ {
const _ValueType __min_val = __init.__min_val; const _ValueType __min_val = __init.__min_val;
const _ValueType __current = __first[__i]; const _ValueType __current = __first[__i];
if (__comp(__current, __min_val)) if (__comp(__current, __min_val))
{ {
__init.__min_val = __current; __init.__min_val = __current;
__init.__min_ind = __i; __init.__min_ind = __i;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines struct _ComplexType
__max_val = __obj.__max_val; __max_val = __obj.__max_val;
__max_ind = (__max_ind - __obj.__max_ind < 0) ? __obj.__max_ind : __max_ind; __max_ind = (__max_ind - __obj.__max_ind < 0) ? __obj.__max_ind : __max_ind;
} }
} }
}; };
_ComplexType __init{*__first, *__first, &__comp}; _ComplexType __init{*__first, *__first, &__comp};
__PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType); _PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType);
__PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init) _PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init)
for (_Size __i = 1; __i < __n; ++__i) for (_Size __i = 1; __i < __n; ++__i)
{ {
auto __min_val = __init.__min_val; auto __min_val = __init.__min_val;
auto __max_val = __init.__max_val; auto __max_val = __init.__max_val;
auto __current = __first + __i; auto __current = __first + __i;
if (__comp(*__current, __min_val)) if (__comp(*__current, __min_val))
{ {
__init.__min_val = *__current; __init.__min_val = *__current;
Show All 11 Lines
template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2, template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate> class _UnaryPredicate>
std::pair<_OutputIterator1, _OutputIterator2> std::pair<_OutputIterator1, _OutputIterator2>
__simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true, __simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
_OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept
{ {
_DifferenceType __cnt_true = 0, __cnt_false = 0; _DifferenceType __cnt_true = 0, __cnt_false = 0;
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i) for (_DifferenceType __i = 0; __i < __n; ++__i)
{ {
__PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1) _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
if (__pred(__first[__i])) if (__pred(__first[__i]))
{ {
__out_true[__cnt_true] = __first[__i]; __out_true[__cnt_true] = __first[__i];
++__cnt_true; ++__cnt_true;
} }
else else
{ {
__out_false[__cnt_false] = __first[__i]; __out_false[__cnt_false] = __first[__i];
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines__simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
// if we have in sequence only one element that pred(__current[1]) != false we can exit the function // if we have in sequence only one element that pred(__current[1]) != false we can exit the function
if (__n < 2) if (__n < 2)
{ {
return __current; return __current;
} }
_DifferenceType __cnt = 0; _DifferenceType __cnt = 0;
__PSTL_PRAGMA_SIMD _PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 1; __i < __n; ++__i) for (_DifferenceType __i = 1; __i < __n; ++__i)
{ {
__PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
if (!__pred(__current[__i])) if (!__pred(__current[__i]))
{ {
__current[__cnt] = std::move(__current[__i]); __current[__cnt] = std::move(__current[__i]);
++__cnt; ++__cnt;
} }
} }
return __current + __cnt; return __current + __cnt;
} }
} // namespace __unseq_backend } // namespace __unseq_backend
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_unseq_backend_simd_H */ #endif /* _PSTL_UNSEQ_BACKEND_SIMD_H */

include/pstl/internal/utils.h

// -*- C++ -*- // -*- C++ -*-
//===-- utils.h -----------------------------------------------------------===// //===-- utils.h -----------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_utils_H #ifndef _PSTL_UTILS_H
#define __PSTL_utils_H #define _PSTL_UTILS_H
#include <new> #include <new>
#include <iterator> #include <iterator>
namespace __pstl namespace __pstl
{ {
namespace __internal namespace __internal
{ {
▲ Show 20 Lines • Show All 194 Lines • ▼ Show 20 Lines__cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp)
{ {
return __comp(*__a, *__b) ? __a : __b; return __comp(*__a, *__b) ? __a : __b;
} }
} }
} // namespace __internal } // namespace __internal
} // namespace __pstl } // namespace __pstl
#endif /* __PSTL_utils_H */ #endif /* _PSTL_UTILS_H */

include/pstl/memory

// -*- C++ -*- // -*- C++ -*-
//===-- memory ------------------------------------------------------------===// //===-- memory ------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_memory #ifndef _PSTL_MEMORY
#define __PSTL_memory #define _PSTL_MEMORY
#include "internal/pstl_config.h" #include "internal/pstl_config.h"
#if __PSTL_EXECUTION_POLICIES_DEFINED #if _PSTL_EXECUTION_POLICIES_DEFINED
// If <execution> has already been included, pull in implementations // If <execution> has already been included, pull in implementations
# include "internal/glue_memory_impl.h" # include "internal/glue_memory_impl.h"
#else #else
// Otherwise just pull in forward declarations // Otherwise just pull in forward declarations
# include "internal/glue_memory_defs.h" # include "internal/glue_memory_defs.h"
# define __PSTL_MEMORY_FORWARD_DECLARED 1 # define _PSTL_MEMORY_FORWARD_DECLARED 1
#endif #endif
#endif /* __PSTL_memory */ #endif /* _PSTL_MEMORY */

include/pstl/numeric

// -*- C++ -*- // -*- C++ -*-
//===-- numeric -----------------------------------------------------------===// //===-- numeric -----------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_numeric #ifndef _PSTL_NUMERIC
#define __PSTL_numeric #define _PSTL_NUMERIC
#include "internal/pstl_config.h" #include "internal/pstl_config.h"
#if __PSTL_EXECUTION_POLICIES_DEFINED #if _PSTL_EXECUTION_POLICIES_DEFINED
// If <execution> has already been included, pull in implementations // If <execution> has already been included, pull in implementations
# include "internal/glue_numeric_impl.h" # include "internal/glue_numeric_impl.h"
#else #else
// Otherwise just pull in forward declarations // Otherwise just pull in forward declarations
# include "internal/glue_numeric_defs.h" # include "internal/glue_numeric_defs.h"
# define __PSTL_NUMERIC_FORWARD_DECLARED 1 # define _PSTL_NUMERIC_FORWARD_DECLARED 1
#endif #endif
#endif /* __PSTL_numeric */ #endif /* _PSTL_NUMERIC */

test/std/algorithms/alg.merge/inplace_merge.pass.cpp

Show All 19 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
void void
operator()(pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2, operator()(pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2,
Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
{ {
} }
template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

test/std/algorithms/alg.merge/merge.pass.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test_merge_by_type<int32_t>([](size_t v) { return (v % 2 == 0 ? v : -v) * 3; }, [](size_t v) { return v * 2; }); test_merge_by_type<int32_t>([](size_t v) { return (v % 2 == 0 ? v : -v) * 3; }, [](size_t v) { return v * 2; });
test_merge_by_type<float64_t>([](size_t v) { return float64_t(v); }, [](size_t v) { return float64_t(v - 100); }); test_merge_by_type<float64_t>([](size_t v) { return float64_t(v); }, [](size_t v) { return float64_t(v - 100); });
#if !__PSTL_ICC_16_17_TEST_64_TIMEOUT #if !_PSTL_ICC_16_17_TEST_64_TIMEOUT
test_merge_by_type<Wrapper<int16_t>>([](size_t v) { return Wrapper<int16_t>(v % 100); }, test_merge_by_type<Wrapper<int16_t>>([](size_t v) { return Wrapper<int16_t>(v % 100); },
[](size_t v) { return Wrapper<int16_t>(v % 10); }); [](size_t v) { return Wrapper<int16_t>(v % 10); });
#endif #endif
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

Show All 18 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct run_copy_if struct run_copy_if
{ {
#if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
void void
operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
Predicate pred, T trash) Predicate pred, T trash)
{ {
} }
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
main() main()
{ {
test<float64_t>(-666.0, [](const float64_t& x) { return x * x <= 1024; }, test<float64_t>(-666.0, [](const float64_t& x) { return x * x <= 1024; },
[](size_t j) { return ((j + 1) % 7 & 2) != 0 ? float64_t(j % 32) : float64_t(j % 33 + 34); }); [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? float64_t(j % 32) : float64_t(j % 33 + 34); });
test<int32_t>(-666, [](const int32_t& x) { return x != 42; }, test<int32_t>(-666, [](const int32_t& x) { return x != 42; },
[](size_t j) { return ((j + 1) % 5 & 2) != 0 ? int32_t(j + 1) : 42; }); [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? int32_t(j + 1) : 42; });
#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN #if !_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN
test<Number>(Number(42, OddTag()), IsMultiple(3, OddTag()), [](int32_t j) { return Number(j, OddTag()); }); test<Number>(Number(42, OddTag()), IsMultiple(3, OddTag()), [](int32_t j) { return Number(j, OddTag()); });
#endif #endif
#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN
test<int32_t>(-666, [](const int32_t& x) { return true; }, [](size_t j) { return j; }, false); test<int32_t>(-666, [](const int32_t& x) { return true; }, [](size_t j) { return j; }, false);
#endif #endif
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp

Show All 18 Lines
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_one_policy struct test_one_policy
{ {
//dummy specialization by policy type, in case of broken configuration //dummy specialization by policy type, in case of broken configuration
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
template <typename Iterator1, typename Predicate> template <typename Iterator1, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred) operator()(pstl::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
{ {
} }
template <typename Iterator1, typename Predicate> template <typename Iterator1, typename Predicate>
void void
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test<float64_t>([](const float64_t x) { return x < 0; }); test<float64_t>([](const float64_t x) { return x < 0; });
test<int32_t>([](const int32_t x) { return x > 1000; }); test<int32_t>([](const int32_t x) { return x > 1000; });
test<uint16_t>([](const uint16_t x) { return x % 5 < 3; }); test<uint16_t>([](const uint16_t x) { return x % 5 < 3; });
#if !__PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN && !__PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN #if !_PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN && !_PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN
test<LocalWrapper<float64_t>>([](const LocalWrapper<float64_t>& x) { return true; }); test<LocalWrapper<float64_t>>([](const LocalWrapper<float64_t>& x) { return true; });
#endif #endif
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
typename std::enable_if<!std::is_trivial<typename std::iterator_traits<Iterator>::value_type>::value, bool>::type typename std::enable_if<!std::is_trivial<typename std::iterator_traits<Iterator>::value_type>::value, bool>::type
is_equal(Iterator first, Iterator last, Iterator d_first) is_equal(Iterator first, Iterator last, Iterator d_first)
{ {
return true; return true;
} }
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specializations to skip testing in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specializations to skip testing in case of broken configuration
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
void void
operator()(pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, operator()(pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
Size n, UnaryOp unary_op, Generator generator) Size n, UnaryOp unary_op, Generator generator)
{ {
} }
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
void void
operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator) BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
{ {
} }
#elif __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specializations to skip testing in case of broken configuration #elif _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specializations to skip testing in case of broken configuration
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
void void
operator()(pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, operator()(pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
Size n, UnaryOp unary_op, Generator generator) Size n, UnaryOp unary_op, Generator generator)
{ {
} }
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines operator()(Policy&& exec, Iterator iter)
stable_partition(exec, iter, iter, non_const(is_even)); stable_partition(exec, iter, iter, non_const(is_even));
}); });
} }
}; };
int32_t int32_t
main() main()
{ {
#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN
test_by_type<int32_t>([](int32_t i) { return i; }, [](int32_t) { return true; }); test_by_type<int32_t>([](int32_t i) { return i; }, [](int32_t) { return true; });
#endif #endif
test_by_type<float64_t>([](int32_t i) { return -i; }, [](const float64_t x) { return x < 0; }); test_by_type<float64_t>([](int32_t i) { return -i; }, [](const float64_t x) { return x < 0; });
test_by_type<int64_t>([](int32_t i) { return i + 1; }, [](int64_t x) { return x % 3 == 0; }); test_by_type<int64_t>([](int32_t i) { return i + 1; }, [](int64_t x) { return x % 3 == 0; });
test_by_type<DataType<float32_t>>([](int32_t i) { return DataType<float32_t>(2 * i + 1); }, test_by_type<DataType<float32_t>>([](int32_t i) { return DataType<float32_t>(2 * i + 1); },
[](const DataType<float32_t>& x) { return x.get_val() < 0; }); [](const DataType<float32_t>& x) { return x.get_val() < 0; });
test_algo_basic_single<int32_t>(run_for_rnd_bi<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_bi<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp

Show All 38 Lines operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator true_first,
EXPECT_TRUE(std::distance(true_first, actual_ret.first) == std::count_if(first, last, unary_op), EXPECT_TRUE(std::distance(true_first, actual_ret.first) == std::count_if(first, last, unary_op),
"partition_copy has wrong effect from true sequence"); "partition_copy has wrong effect from true sequence");
EXPECT_TRUE(std::distance(false_first, actual_ret.second) == EXPECT_TRUE(std::distance(false_first, actual_ret.second) ==
std::count_if(first, last, __pstl::__internal::__not_pred<UnaryOp>(unary_op)), std::count_if(first, last, __pstl::__internal::__not_pred<UnaryOp>(unary_op)),
"partition_copy has wrong effect from false sequence"); "partition_copy has wrong effect from false sequence");
} }
//dummy specialization by iterator type and policy type, in case of broken configuration //dummy specialization by iterator type and policy type, in case of broken configuration
#if __PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN #if _PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp>
void void
operator()(pstl::execution::unsequenced_policy, std::reverse_iterator<InputIterator> first, operator()(pstl::execution::unsequenced_policy, std::reverse_iterator<InputIterator> first,
std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first, std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first,
std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first, std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first,
OutputIterator2 false_last, UnaryOp unary_op) OutputIterator2 false_last, UnaryOp unary_op)
{ {
} }
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesstruct test_non_const
} }
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>([](const int32_t value) { return value % 2; }); test<int32_t>([](const int32_t value) { return value % 2; });
#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN
test<int32_t>([](const int32_t value) { return true; }); test<int32_t>([](const int32_t value) { return true; });
#endif #endif
test<float64_t>([](const float64_t value) { return value > 2 << 6; }); test<float64_t>([](const float64_t value) { return value > 2 << 6; });
test<Wrapper<float64_t>>([](const Wrapper<float64_t>& value) -> bool { return value.get_my_field() != nullptr; }); test<Wrapper<float64_t>>([](const Wrapper<float64_t>& value) -> bool { return value.get_my_field() != nullptr; });
test_algo_basic_double<int32_t>(run_for_rnd_bi<test_non_const>()); test_algo_basic_double<int32_t>(run_for_rnd_bi<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp

Show All 19 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN || __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN || _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
Iterator2 actual_e) Iterator2 actual_e)
{ {
} }
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>(); test<int32_t>();
test<uint16_t>(); test<uint16_t>();
test<float64_t>(); test<float64_t>();
#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN #if !_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN
test<wrapper<float64_t>>(); test<wrapper<float64_t>>();
#endif #endif
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
// due to the caller invoke_on_all_policies does forcing modification passed iterator type to cover additional usage cases. // due to the caller invoke_on_all_policies does forcing modification passed iterator type to cover additional usage cases.
template <typename Iterator> template <typename Iterator>
struct test_one_policy struct test_one_policy
{ {
Iterator data_b; Iterator data_b;
Iterator data_e; Iterator data_e;
test_one_policy(Iterator b, Iterator e) : data_b(b), data_e(e) {} test_one_policy(Iterator b, Iterator e) : data_b(b), data_e(e) {}
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1> template <typename Iterator1>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e) operator()(pstl::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
{ {
} }
template <typename Iterator1> template <typename Iterator1>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e) operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/std/algorithms/alg.modifying.operations/copy_move.pass.cpp

Show All 20 Lines
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct run_copy struct run_copy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
Size n, T trash) Size n, T trash)
{ {
} }
Show All 35 Lines operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
EXPECT_TRUE(out_last == k, "wrong return value from copy_n"); EXPECT_TRUE(out_last == k, "wrong return value from copy_n");
} }
}; };
template <typename T> template <typename T>
struct run_move struct run_move
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
Size n, T trash) Size n, T trash)
{ {
} }
Show All 25 Lines operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
EXPECT_TRUE(out_last == k, "wrong return value from move"); EXPECT_TRUE(out_last == k, "wrong return value from move");
} }
}; };
template <typename T> template <typename T>
struct run_move<Wrapper<T>> struct run_move<Wrapper<T>>
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
Size n, Wrapper<T> trash) Size n, Wrapper<T> trash)
{ {
} }
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
} }
int32_t int32_t
main() main()
{ {
test<int32_t>(-666, [](size_t j) { return int32_t(j); }); test<int32_t>(-666, [](size_t j) { return int32_t(j); });
test<Wrapper<float64_t>>(Wrapper<float64_t>(-666.0), [](int32_t j) { return Wrapper<float64_t>(j); }); test<Wrapper<float64_t>>(Wrapper<float64_t>(-666.0), [](int32_t j) { return Wrapper<float64_t>(j); });
#if !__PSTL_ICC_16_17_TEST_64_TIMEOUT #if !_PSTL_ICC_16_17_TEST_64_TIMEOUT
test<float64_t>(-666.0, [](size_t j) { return float64_t(j); }); test<float64_t>(-666.0, [](size_t j) { return float64_t(j); });
test<Number>(Number(42, OddTag()), [](int32_t j) { return Number(j, OddTag()); }); test<Number>(Number(42, OddTag()), [](int32_t j) { return Number(j, OddTag()); });
#endif #endif
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/remove.pass.cpp

Show All 18 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct run_remove struct run_remove
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename Size, typename T> template <typename InputIterator, typename OutputIterator, typename Size, typename T>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
const T& value) const T& value)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename Size, typename T> template <typename InputIterator, typename OutputIterator, typename Size, typename T>
Show All 20 Lines operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator k = remove(exec, out_first, out_last, value); OutputIterator k = remove(exec, out_first, out_last, value);
EXPECT_TRUE(std::distance(expected_first, i) == std::distance(out_first, k), "wrong return value from remove"); EXPECT_TRUE(std::distance(expected_first, i) == std::distance(out_first, k), "wrong return value from remove");
EXPECT_EQ_N(expected_first, out_first, std::distance(expected_first, i), "wrong remove effect"); EXPECT_EQ_N(expected_first, out_first, std::distance(expected_first, i), "wrong remove effect");
} }
}; };
struct run_remove_if struct run_remove_if
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate> template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
Predicate pred) Predicate pred)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate> template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines operator()(Policy&& exec, Iterator iter)
invoke_if(exec, [&]() { remove_if(exec, iter, iter, non_const(is_even)); }); invoke_if(exec, [&]() { remove_if(exec, iter, iter, non_const(is_even)); });
} }
}; };
int32_t int32_t
main() main()
{ {
#if !__PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN #if !_PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN
test<int32_t>(666, 42, [](int32_t val) { return true; }, [](size_t j) { return j; }); test<int32_t>(666, 42, [](int32_t val) { return true; }, [](size_t j) { return j; });
#endif #endif
test<int32_t>(666, 2001, [](const int32_t& val) { return val != 2001; }, test<int32_t>(666, 2001, [](const int32_t& val) { return val != 2001; },
[](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 2001 : -1 - int32_t(j); }); [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 2001 : -1 - int32_t(j); });
test<float64_t>(-666.0, 8.5, [](const float64_t& val) { return val != 8.5; }, test<float64_t>(-666.0, 8.5, [](const float64_t& val) { return val != 8.5; },
[](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); }); [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); });
#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN #if !_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN
test<Number>(Number(-666, OddTag()), Number(42, OddTag()), IsMultiple(3, OddTag()), test<Number>(Number(-666, OddTag()), Number(42, OddTag()), IsMultiple(3, OddTag()),
[](int32_t j) { return Number(j, OddTag()); }); [](int32_t j) { return Number(j, OddTag()); });
#endif #endif
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/replace_copy.pass.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
{ {
test<float64_t>(-666.0, 8.5, 0.33, [](const float64_t& x) { return x * x <= 1024; }, test<float64_t>(-666.0, 8.5, 0.33, [](const float64_t& x) { return x * x <= 1024; },
[](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); }); [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); });
test<int32_t>(-666, 42, 99, [](const int32_t& x) { return x != 42; }, test<int32_t>(-666, 42, 99, [](const int32_t& x) { return x != 42; },
[](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 42 : -1 - int32_t(j); }); [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 42 : -1 - int32_t(j); });
#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN #if !_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN
test<Number>(Number(42, OddTag()), Number(2001, OddTag()), Number(2017, OddTag()), IsMultiple(3, OddTag()), test<Number>(Number(42, OddTag()), Number(2001, OddTag()), Number(2017, OddTag()), IsMultiple(3, OddTag()),
[](int32_t j) { return ((j + 1) % 3 & 2) != 0 ? Number(2001, OddTag()) : Number(j, OddTag()); }); [](int32_t j) { return ((j + 1) % 3 & 2) != 0 ? Number(2001, OddTag()) : Number(j, OddTag()); });
#endif #endif
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/rotate.pass.cpp

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines operator()(const wrapper<T>& a, const wrapper<T>& b)
return a.t == b.t; return a.t == b.t;
} }
}; };
#include <typeinfo> #include <typeinfo>
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specializations to skip testing in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specializations to skip testing in case of broken configuration
template <typename Iterator, typename Size> template <typename Iterator, typename Size>
void void
operator()(pstl::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b, operator()(pstl::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
Iterator actual_e, Size shift) Iterator actual_e, Size shift)
{ {
} }
template <typename Iterator, typename Size> template <typename Iterator, typename Size>
void void
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/std/algorithms/alg.modifying.operations/rotate_copy.pass.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines operator()(T1 a, T2 b)
T temp = a; T temp = a;
return compare(temp, b); return compare(temp, b);
} }
}; };
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
Iterator2 actual_e, std::size_t shift) Iterator2 actual_e, std::size_t shift)
{ {
} }
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/std/algorithms/alg.modifying.operations/unique.pass.cpp

Show All 18 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct run_unique struct run_unique
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename ForwardIt, typename Generator> template <typename ForwardIt, typename Generator>
void void
operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
ForwardIt last2, Generator generator) ForwardIt last2, Generator generator)
{ {
} }
template <typename ForwardIt, typename Generator> template <typename ForwardIt, typename Generator>
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Linesstruct test_non_const
{ {
invoke_if(exec, [&]() { unique(exec, iter, iter, non_const(std::equal_to<T>())); }); invoke_if(exec, [&]() { unique(exec, iter, iter, non_const(std::equal_to<T>())); });
} }
}; };
int32_t int32_t
main() main()
{ {
#if !__PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN #if !_PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN
test<int32_t>([](size_t j) { return j / 3; }, test<int32_t>([](size_t j) { return j / 3; },
[](const int32_t& val1, const int32_t& val2) { return val1 * val1 == val2 * val2; }); [](const int32_t& val1, const int32_t& val2) { return val1 * val1 == val2 * val2; });
test<float64_t>([](size_t) { return float64_t(1); }, test<float64_t>([](size_t) { return float64_t(1); },
[](const float64_t& val1, const float64_t& val2) { return val1 != val2; }); [](const float64_t& val1, const float64_t& val2) { return val1 != val2; });
#endif #endif
test<LocalWrapper<uint32_t>>([](size_t j) { return LocalWrapper<uint32_t>(j); }, test<LocalWrapper<uint32_t>>([](size_t j) { return LocalWrapper<uint32_t>(j); },
[](const LocalWrapper<uint32_t>& val1, const LocalWrapper<uint32_t>& val2) { [](const LocalWrapper<uint32_t>& val1, const LocalWrapper<uint32_t>& val2) {
return val1.my_val != val2.my_val; return val1.my_val != val2.my_val;
}); });
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp

Show All 18 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct run_unique_copy struct run_unique_copy
{ {
#if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
void void
operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
Predicate pred, T trash) Predicate pred, T trash)
{ {
} }
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
int32_t int32_t
main(int32_t argc, char* argv[]) main(int32_t argc, char* argv[])
{ {
test<Number>(Number(42, OddTag()), std::equal_to<Number>(), test<Number>(Number(42, OddTag()), std::equal_to<Number>(),
[](int32_t j) { return Number(3 * j / 13 ^ (j & 8), OddTag()); }); [](int32_t j) { return Number(3 * j / 13 ^ (j & 8), OddTag()); });
test<float32_t>(float32_t(42), std::equal_to<float32_t>(), test<float32_t>(float32_t(42), std::equal_to<float32_t>(),
[](int32_t j) { return float32_t(5 * j / 23 ^ (j / 7)); }); [](int32_t j) { return float32_t(5 * j / 23 ^ (j / 7)); });
#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN
test<float32_t>(float32_t(42), [](float32_t x, float32_t y) { return false; }, test<float32_t>(float32_t(42), [](float32_t x, float32_t y) { return false; },
[](int32_t j) { return float32_t(j); }, false); [](int32_t j) { return float32_t(j); }, false);
#endif #endif
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/all_of.pass.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>(8 * sizeof(int32_t)); test<int32_t>(8 * sizeof(int32_t));
test<uint16_t>(8 * sizeof(uint16_t)); test<uint16_t>(8 * sizeof(uint16_t));
test<float64_t>(53); test<float64_t>(53);
#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN
test<bool>(1); test<bool>(1);
#endif #endif
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/any_of.pass.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>(8 * sizeof(int32_t)); test<int32_t>(8 * sizeof(int32_t));
test<uint16_t>(8 * sizeof(uint16_t)); test<uint16_t>(8 * sizeof(uint16_t));
test<float64_t>(53); test<float64_t>(53);
#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN
test<bool>(1); test<bool>(1);
#endif #endif
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/count.pass.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines operator()(Policy&& exec, Iterator iter)
count_if(exec, iter, iter, non_const(is_even)); count_if(exec, iter, iter, non_const(is_even));
} }
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>(42, IsEqual<int32_t>(50, OddTag()), [](int32_t j) { return j; }); test<int32_t>(42, IsEqual<int32_t>(50, OddTag()), [](int32_t j) { return j; });
#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN
test<int32_t>(42, [](const int32_t& x) { return true; }, [](int32_t j) { return j; }); test<int32_t>(42, [](const int32_t& x) { return true; }, [](int32_t j) { return j; });
#endif #endif
test<float64_t>(42, IsEqual<float64_t>(50, OddTag()), [](int32_t j) { return float64_t(j); }); test<float64_t>(42, IsEqual<float64_t>(50, OddTag()), [](int32_t j) { return float64_t(j); });
test<Number>(Number(42, OddTag()), IsEqual<Number>(Number(50, OddTag()), OddTag()), test<Number>(Number(42, OddTag()), IsEqual<Number>(Number(50, OddTag()), OddTag()),
[](int32_t j) { return Number(j, OddTag()); }); [](int32_t j) { return Number(j, OddTag()); });
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/equal.pass.cpp

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
int32_t int32_t
main() main()
{ {
test<int32_t>(8 * sizeof(int32_t)); test<int32_t>(8 * sizeof(int32_t));
test<uint16_t>(8 * sizeof(uint16_t)); test<uint16_t>(8 * sizeof(uint16_t));
test<float64_t>(53); test<float64_t>(53);
#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN
test<bool>(1); test<bool>(1);
#endif #endif
test<UserType>(256); test<UserType>(256);
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/find.pass.cpp

Show All 18 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_find struct test_find
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Value> template <typename Iterator, typename Value>
void void
operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Value value) operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Value value)
{ {
} }
template <typename Iterator, typename Value> template <typename Iterator, typename Value>
void void
operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value) operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value)
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/std/algorithms/alg.nonmodifying/find_end.pass.cpp

Show All 17 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2, typename Predicate> template <typename Iterator1, typename Iterator2, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
Predicate pred) Predicate pred)
{ {
} }
template <typename Iterator1, typename Iterator2, typename Predicate> template <typename Iterator1, typename Iterator2, typename Predicate>
void void
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>(8 * sizeof(int32_t)); test<int32_t>(8 * sizeof(int32_t));
test<uint16_t>(8 * sizeof(uint16_t)); test<uint16_t>(8 * sizeof(uint16_t));
test<float64_t>(53); test<float64_t>(53);
#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN
test<bool>(1); test<bool>(1);
#endif #endif
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/find_first_of.pass.cpp

Show All 17 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2, typename Predicate> template <typename Iterator1, typename Iterator2, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
Predicate pred) Predicate pred)
{ {
} }
template <typename Iterator1, typename Iterator2, typename Predicate> template <typename Iterator1, typename Iterator2, typename Predicate>
void void
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/std/algorithms/alg.nonmodifying/find_if.pass.cpp

Show All 18 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_find_if struct test_find_if
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Predicate, typename NotPredicate> template <typename Iterator, typename Predicate, typename NotPredicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred, operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred,
NotPredicate not_pred) NotPredicate not_pred)
{ {
} }
template <typename Iterator, typename Predicate, typename NotPredicate> template <typename Iterator, typename Predicate, typename NotPredicate>
void void
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines operator()(Policy&& exec, Iterator iter)
find_if_not(exec, iter, iter, non_const(is_even)); find_if_not(exec, iter, iter, non_const(is_even));
}); });
} }
}; };
int32_t int32_t
main() main()
{ {
#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN #if !_PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN
// Note that the "hit" and "miss" functions here avoid overflow issues. // Note that the "hit" and "miss" functions here avoid overflow issues.
test<Number>(IsMultiple(5, OddTag()), [](int32_t j) { return Number(j - j % 5, OddTag()); }, // hit test<Number>(IsMultiple(5, OddTag()), [](int32_t j) { return Number(j - j % 5, OddTag()); }, // hit
[](int32_t j) { return Number(j % 5 == 0 ? j ^ 1 : j, OddTag()); }); // miss [](int32_t j) { return Number(j % 5 == 0 ? j ^ 1 : j, OddTag()); }); // miss
#endif #endif
// Try type for which algorithm can really be vectorized. // Try type for which algorithm can really be vectorized.
test<float32_t>([](float32_t x) { return x >= 0; }, [](float32_t j) { return j * j; }, test<float32_t>([](float32_t x) { return x >= 0; }, [](float32_t j) { return j * j; },
[](float32_t j) { return -1 - j * j; }); [](float32_t j) { return -1 - j * j; });
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/none_of.pass.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>(8 * sizeof(int32_t)); test<int32_t>(8 * sizeof(int32_t));
test<uint16_t>(8 * sizeof(uint16_t)); test<uint16_t>(8 * sizeof(uint16_t));
test<float64_t>(53); test<float64_t>(53);
#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN
test<bool>(1); test<bool>(1);
#endif #endif
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.nonmodifying/nth_element.pass.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
bool bool
is_equal(const T& x, const T& y) is_equal(const T& x, const T& y)
{ {
return x == y; return x == y;
} }
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2, operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
{ {
} }
template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

test/std/algorithms/alg.nonmodifying/search_n.pass.cpp

Show All 17 Lines
#endif // PSTL_STANDALONE_TESTS #endif // PSTL_STANDALONE_TESTS
#include "support/utils.h" #include "support/utils.h"
using namespace TestUtils; using namespace TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Size, typename T, typename Predicate> template <typename Iterator, typename Size, typename T, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred) operator()(pstl::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred)
{ {
} }
template <typename Iterator, typename Size, typename T, typename Predicate> template <typename Iterator, typename Size, typename T, typename Predicate>
void void
operator()(pstl::execution::parallel_unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, operator()(pstl::execution::parallel_unsequenced_policy, Iterator b, Iterator e, Size count, const T& value,
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
}; };
int32_t int32_t
main() main()
{ {
test<int32_t>(); test<int32_t>();
test<uint16_t>(); test<uint16_t>();
test<float64_t>(); test<float64_t>();
#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN #if !_PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN
test<bool>(); test<bool>();
#endif #endif
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp

Show All 32 Linesstruct WithCmpOp
operator<(const WithCmpOp& rhs) const operator<(const WithCmpOp& rhs) const
{ {
return this->_first < rhs._first; return this->_first < rhs._first;
} }
}; };
struct test_is_heap struct test_is_heap
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Predicate> template <typename Iterator, typename Predicate>
typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred) operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred)
{ {
} }
template <typename Iterator, typename Predicate> template <typename Iterator, typename Predicate>
typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred) operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred)
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp

Show First 20 Lines • Show All 159 Lines • ▼ Show 20 Linesstruct test_non_const
} }
}; };
int32_t int32_t
main() main()
{ {
test<uint16_t, float64_t>(std::less<float64_t>()); test<uint16_t, float64_t>(std::less<float64_t>());
test<float32_t, int32_t>(std::greater<float32_t>()); test<float32_t, int32_t>(std::greater<float32_t>());
#if !__PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN #if !_PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN
test<float64_t, int32_t>([](const float64_t x, const int32_t y) { return x * x < y * y; }); test<float64_t, int32_t>([](const float64_t x, const int32_t y) { return x * x < y * y; });
#endif #endif
test<LocalWrapper<int32_t>, LocalWrapper<int32_t>>( test<LocalWrapper<int32_t>, LocalWrapper<int32_t>>(
[](const LocalWrapper<int32_t>& x, const LocalWrapper<int32_t>& y) { return x < y; }); [](const LocalWrapper<int32_t>& x, const LocalWrapper<int32_t>& y) { return x < y; });
test_string([](const char x, const char y) { return x < y; }); test_string([](const char x, const char y) { return x < y; });
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.sorting/partial_sort.pass.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines operator()(Policy&& exec, InputIterator first, InputIterator last, InputIterator exp_first, InputIterator exp_last,
count_comp = 0; count_comp = 0;
std::partial_sort(exec, first, m1, last, compare); std::partial_sort(exec, first, m1, last, compare);
EXPECT_EQ_N(exp_first, first, p, "wrong effect from partial_sort"); EXPECT_EQ_N(exp_first, first, p, "wrong effect from partial_sort");
//checking upper bound number of comparisons; O(p*(last-first)log(middle-first)); where p - number of threads; //checking upper bound number of comparisons; O(p*(last-first)log(middle-first)); where p - number of threads;
if (m1 - first > 1) if (m1 - first > 1)
{ {
auto complex = std::ceil(n * std::log(float32_t(m1 - first))); auto complex = std::ceil(n * std::log(float32_t(m1 - first)));
#if defined(__PSTL_PAR_BACKEND_TBB) #if defined(_PSTL_PAR_BACKEND_TBB)
auto p = tbb::this_task_arena::max_concurrency(); auto p = tbb::this_task_arena::max_concurrency();
#else #else
auto p = 1; auto p = 1;
#endif #endif
#ifdef _DEBUG #ifdef _DEBUG
if (count_comp > complex * p) if (count_comp > complex * p)
{ {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/std/algorithms/alg.sorting/partial_sort_copy.pass.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesstruct test_one_policy
RandomAccessIterator d_last; RandomAccessIterator d_last;
RandomAccessIterator exp_first; RandomAccessIterator exp_first;
RandomAccessIterator exp_last; RandomAccessIterator exp_last;
// This ctor is needed because output shouldn't be transformed to any iterator type (only random access iterators are allowed) // This ctor is needed because output shouldn't be transformed to any iterator type (only random access iterators are allowed)
test_one_policy(RandomAccessIterator b1, RandomAccessIterator e1, RandomAccessIterator b2, RandomAccessIterator e2) test_one_policy(RandomAccessIterator b1, RandomAccessIterator e1, RandomAccessIterator b2, RandomAccessIterator e2)
: d_first(b1), d_last(e1), exp_first(b2), exp_last(e2) : d_first(b1), d_last(e1), exp_first(b2), exp_last(e2)
{ {
} }
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename Size, typename T, typename Compare> template <typename InputIterator, typename Size, typename T, typename Compare>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
const T& trash, Compare compare) const T& trash, Compare compare)
{ {
} }
template <typename InputIterator, typename Size, typename T, typename Compare> template <typename InputIterator, typename Size, typename T, typename Compare>
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

test/std/numerics/numeric.ops/adjacent_difference.pass.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
typename std::enable_if<std::is_floating_point<T>::value, bool>::type typename std::enable_if<std::is_floating_point<T>::value, bool>::type
compute_and_check(Iterator1 first, Iterator1 last, Iterator2 d_first, T, Function) compute_and_check(Iterator1 first, Iterator1 last, Iterator2 d_first, T, Function)
{ {
return true; return true;
} }
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2, typename T, typename Function> template <typename Iterator1, typename Iterator2, typename T, typename Function>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
Iterator2 actual_e, T trash, Function f) Iterator2 actual_e, T trash, Function f)
{ {
} }
template <typename Iterator1, typename Iterator2, typename T, typename Function> template <typename Iterator1, typename Iterator2, typename T, typename Function>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/std/numerics/numeric.ops/reduce.pass.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
invoke_on_all_policies(test_long_forms_for_one_policy(), in.begin(), in.end(), init, binary_op, expected); invoke_on_all_policies(test_long_forms_for_one_policy(), in.begin(), in.end(), init, binary_op, expected);
invoke_on_all_policies(test_long_forms_for_one_policy(), in.cbegin(), in.cend(), init, binary_op, expected); invoke_on_all_policies(test_long_forms_for_one_policy(), in.cbegin(), in.cend(), init, binary_op, expected);
} }
} }
struct test_two_short_forms struct test_two_short_forms
{ {
#if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specialization by policy type, in case of broken configuration #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator> template <typename Iterator>
void void
operator()(pstl::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected) operator()(pstl::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected)
{ {
} }
template <typename Iterator> template <typename Iterator>
void void
operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected) operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/std/numerics/numeric.ops/scan.pass.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
} }
int32_t int32_t
main() main()
{ {
for (int32_t mode = 0; mode < 2; ++mode) for (int32_t mode = 0; mode < 2; ++mode)
{ {
inclusive = mode != 0; inclusive = mode != 0;
#if !__PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN #if !_PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN
// Test with highly restricted type and associative but not commutative operation // Test with highly restricted type and associative but not commutative operation
test_matrix<Matrix2x2<int32_t>, Matrix2x2<int32_t>>(Matrix2x2<int32_t>(), multiply_matrix<int32_t>, test_matrix<Matrix2x2<int32_t>, Matrix2x2<int32_t>>(Matrix2x2<int32_t>(), multiply_matrix<int32_t>,
Matrix2x2<int32_t>(-666, 666)); Matrix2x2<int32_t>(-666, 666));
#endif #endif
// Since the implict "+" forms of the scan delegate to the generic forms, // Since the implict "+" forms of the scan delegate to the generic forms,
// there's little point in using a highly restricted type, so just use double. // there's little point in using a highly restricted type, so just use double.
test_with_plus<float64_t>(inclusive ? 0.0 : -1.0, -666.0, test_with_plus<float64_t>(inclusive ? 0.0 : -1.0, -666.0,
[](uint32_t k) { return float64_t((k % 991 + 1) ^ (k % 997 + 2)); }); [](uint32_t k) { return float64_t((k % 991 + 1) ^ (k % 997 + 2)); });
} }
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/numerics/numeric.ops/transform_scan.pass.cpp

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
} }
int32_t int32_t
main() main()
{ {
for (int32_t mode = 0; mode < 2; ++mode) for (int32_t mode = 0; mode < 2; ++mode)
{ {
inclusive = mode != 0; inclusive = mode != 0;
#if !__PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN #if !_PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN
test_matrix<Matrix2x2<int32_t>, Matrix2x2<int32_t>>([](const Matrix2x2<int32_t> x) { return x; }, test_matrix<Matrix2x2<int32_t>, Matrix2x2<int32_t>>([](const Matrix2x2<int32_t> x) { return x; },
Matrix2x2<int32_t>(), multiply_matrix<int32_t>, Matrix2x2<int32_t>(), multiply_matrix<int32_t>,
Matrix2x2<int32_t>(-666, 666)); Matrix2x2<int32_t>(-666, 666));
#endif #endif
test<int32_t, uint32_t>([](int32_t x) { return x++; }, -123, [](int32_t x, int32_t y) { return x + y; }, 666); test<int32_t, uint32_t>([](int32_t x) { return x++; }, -123, [](int32_t x, int32_t y) { return x + y; }, 666);
} }
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/utilities/memory/specialized.algorithms/uninitialized_construct.pass.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Linestest_uninit_construct_by_type()
} }
} }
int32_t int32_t
main() main()
{ {
// for user-defined types // for user-defined types
#if !__PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN #if !_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN
test_uninit_construct_by_type<Wrapper<int32_t>>(); test_uninit_construct_by_type<Wrapper<int32_t>>();
test_uninit_construct_by_type<Wrapper<std::vector<std::string>>>(); test_uninit_construct_by_type<Wrapper<std::vector<std::string>>>();
#endif #endif
// for trivial types // for trivial types
test_uninit_construct_by_type<int8_t>(); test_uninit_construct_by_type<int8_t>();
test_uninit_construct_by_type<float64_t>(); test_uninit_construct_by_type<float64_t>();
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/std/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, size_t n,
// destroy objects for testing new algorithms on same memory // destroy objects for testing new algorithms on same memory
std::destroy_n(exec, out_first, n); std::destroy_n(exec, out_first, n);
std::uninitialized_move_n(exec, first, n, out_first); std::uninitialized_move_n(exec, first, n, out_first);
EXPECT_TRUE(T::MoveCount() == n, "wrong uninitialized_move_n"); EXPECT_TRUE(T::MoveCount() == n, "wrong uninitialized_move_n");
std::destroy_n(exec, out_first, n); std::destroy_n(exec, out_first, n);
} }
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
size_t n, /*is_trivial<T>=*/std::true_type) size_t n, /*is_trivial<T>=*/std::true_type)
{ {
} }
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
void void
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
main() main()
{ {
// for trivial types // for trivial types
test_uninitialized_copy_move_by_type<int16_t>(); test_uninitialized_copy_move_by_type<int16_t>();
test_uninitialized_copy_move_by_type<float64_t>(); test_uninitialized_copy_move_by_type<float64_t>();
// for user-defined types // for user-defined types
#if !__PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN && !__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN && \ #if !_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN && !_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN && \
!__PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN !_PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN
test_uninitialized_copy_move_by_type<Wrapper<int8_t>>(); test_uninitialized_copy_move_by_type<Wrapper<int8_t>>();
#endif #endif
std::cout << done() << std::endl; std::cout << done() << std::endl;
return 0; return 0;
} }

test/support/pstl_test_config.h

// -*- C++ -*- // -*- C++ -*-
//===-- pstl_test_config.h ------------------------------------------------===// //===-- pstl_test_config.h ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_TEST_config_H #ifndef _PSTL_TEST_config_H
#define __PSTL_TEST_config_H #define _PSTL_TEST_config_H
#if defined(_MSC_VER) && defined(_DEBUG) #if defined(_MSC_VER) && defined(_DEBUG)
#define _SCL_SECURE_NO_WARNINGS //to prevent the compilation warning. Microsoft STL implementation has specific checking of an iterator range in DEBUG mode for the containers from the standard library. #define _SCL_SECURE_NO_WARNINGS //to prevent the compilation warning. Microsoft STL implementation has specific checking of an iterator range in DEBUG mode for the containers from the standard library.
#endif #endif
#define __PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN \ #define _PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN \
(__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER <= 1700 && !__APPLE__) (__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER <= 1700 && !__APPLE__)
#define __PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN \ #define _PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN \
(!_DEBUG && __INTEL_COMPILER && \ (!_DEBUG && __INTEL_COMPILER && \
(__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1))) (__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1)))
#define __PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN \ #define _PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN \
(__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1) (__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1)
#define __PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN \ #define _PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN \
(__i386__ && !_DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && __APPLE__) (__i386__ && !_DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && __APPLE__)
#define __PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN \ #define _PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN \
(!_DEBUG && __INTEL_COMPILER >= 1800 && __INTEL_COMPILER < 1900 && _MSC_VER == 1910) (!_DEBUG && __INTEL_COMPILER >= 1800 && __INTEL_COMPILER < 1900 && _MSC_VER == 1910)
#define __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN \ #define _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN \
(_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && _MSC_VER >= 1900) (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && _MSC_VER >= 1900)
#define __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN \ #define _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN \
(_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1600 && __INTEL_COMPILER < 1700 && _MSC_VER == 1900) (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1600 && __INTEL_COMPILER < 1700 && _MSC_VER == 1900)
#define __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN \ #define _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN \
(__PSTL_USE_PAR_POLICIES && ((_M_X64 && _MSC_VER == 1900) || __x86_64) && !_DEBUG && __INTEL_COMPILER < 1700) (_PSTL_USE_PAR_POLICIES && ((_M_X64 && _MSC_VER == 1900) || __x86_64) && !_DEBUG && __INTEL_COMPILER < 1700)
#define __PSTL_ICC_16_17_TEST_64_TIMEOUT (__x86_64 && __INTEL_COMPILER && __INTEL_COMPILER < 1800 && !__APPLE__) #define _PSTL_ICC_16_17_TEST_64_TIMEOUT (__x86_64 && __INTEL_COMPILER && __INTEL_COMPILER < 1800 && !__APPLE__)
#define __PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN (!_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800) #define _PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN (!_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800)
#define __PSTL_CLANG_TEST_BIG_OBJ_DEBUG_32_BROKEN \ #define _PSTL_CLANG_TEST_BIG_OBJ_DEBUG_32_BROKEN \
(__i386__ && PSTL_USE_DEBUG && __clang__ && __PSTL_CLANG_VERSION <= 90000) (__i386__ && PSTL_USE_DEBUG && __clang__ && _PSTL_CLANG_VERSION <= 90000)
#define __PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN \ #define _PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN \
(!_DEBUG && __INTEL_COMPILER && \ (!_DEBUG && __INTEL_COMPILER && \
(__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 3))) (__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 3)))
#define __PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN \ #define _PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN \
(!_DEBUG && __INTEL_COMPILER == 1800 && __AVX__ && !__AVX2__ && !__AVX512__) (!_DEBUG && __INTEL_COMPILER == 1800 && __AVX__ && !__AVX2__ && !__AVX512__)
#define __PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN \ #define _PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN \
(!PSTL_USE_DEBUG && (__linux__ || __APPLE__) && __INTEL_COMPILER == 1900) (!PSTL_USE_DEBUG && (__linux__ || __APPLE__) && __INTEL_COMPILER == 1900)
#define __PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN \ #define _PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN \
(__INTEL_COMPILER == 1900 && _MSC_VER >= 1900 && _MSC_VER <= 1910) (__INTEL_COMPILER == 1900 && _MSC_VER >= 1900 && _MSC_VER <= 1910)
#define __PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN (__INTEL_COMPILER == 1900 && _MSC_VER && !_DEBUG) #define _PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN (__INTEL_COMPILER == 1900 && _MSC_VER && !_DEBUG)
#endif /* __PSTL_TEST_config_H */ #endif /* _PSTL_TEST_config_H */

test/support/utils.h

Show First 20 Lines • Show All 566 Lines • ▼ Show 20 Lines
// Multiplication of matrix is an associative but not commutative operation // Multiplication of matrix is an associative but not commutative operation
// Typically used as value type in tests involving "GENERALIZED_NONCOMMUTATIVE_SUM". // Typically used as value type in tests involving "GENERALIZED_NONCOMMUTATIVE_SUM".
template <typename T> template <typename T>
struct Matrix2x2 struct Matrix2x2
{ {
T a[2][2]; T a[2][2];
Matrix2x2() : a{{1, 0}, {0, 1}} {} Matrix2x2() : a{{1, 0}, {0, 1}} {}
Matrix2x2(T x, T y) : a{{0, x}, {x, y}} {} Matrix2x2(T x, T y) : a{{0, x}, {x, y}} {}
#if !__PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN #if !_PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN
Matrix2x2(const Matrix2x2& m) : a{{m.a[0][0], m.a[0][1]}, {m.a[1][0], m.a[1][1]}} {} Matrix2x2(const Matrix2x2& m) : a{{m.a[0][0], m.a[0][1]}, {m.a[1][0], m.a[1][1]}} {}
Matrix2x2& Matrix2x2&
operator=(const Matrix2x2& m) operator=(const Matrix2x2& m)
{ {
a[0][0] = m.a[0][0], a[0][1] = m.a[0][1], a[1][0] = m.a[1][0], a[1][1] = m.a[1][1]; a[0][0] = m.a[0][0], a[0][1] = m.a[0][1], a[1][0] = m.a[1][0], a[1][1] = m.a[1][1];
return *this; return *this;
} }
#endif #endif
Show All 18 Lines for (int32_t i = 0; i < 2; ++i)
{ {
result.a[i][j] = left.a[i][0] * right.a[0][j] + left.a[i][1] * right.a[1][j]; result.a[i][j] = left.a[i][0] * right.a[0][j] + left.a[i][1] * right.a[1][j];
} }
} }
return result; return result;
} }
// Check that Intel(R) Threading Building Blocks header files are not used when parallel policies are off // Check that Intel(R) Threading Building Blocks header files are not used when parallel policies are off
#if !__PSTL_USE_PAR_POLICIES #if !_PSTL_USE_PAR_POLICIES
#if defined(TBB_INTERFACE_VERSION) #if defined(TBB_INTERFACE_VERSION)
#error The parallel backend is used while it should not (__PSTL_USE_PAR_POLICIES==0) #error The parallel backend is used while it should not (_PSTL_USE_PAR_POLICIES==0)
#endif #endif
#endif #endif
//============================================================================ //============================================================================
// Adapters for creating different types of iterators. // Adapters for creating different types of iterators.
// //
// In this block we implemented some adapters for creating differnet types of iterators. // In this block we implemented some adapters for creating differnet types of iterators.
// It's needed for extending the unit testing of Parallel STL algorithms. // It's needed for extending the unit testing of Parallel STL algorithms.
Show All 32 Lines
// Reverse adapter // Reverse adapter
template <typename Iterator, typename IsReverse> template <typename Iterator, typename IsReverse>
struct ReverseAdapter struct ReverseAdapter
{ {
typedef std::reverse_iterator<Iterator> iterator_type; typedef std::reverse_iterator<Iterator> iterator_type;
iterator_type iterator_type
operator()(Iterator it) operator()(Iterator it)
{ {
#if __PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT #if _PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT
return std::make_reverse_iterator(it); return std::make_reverse_iterator(it);
#else #else
return iterator_type(it); return iterator_type(it);
#endif #endif
} }
}; };
// Non-reverse adapter // Non-reverse adapter
▲ Show 20 Lines • Show All 376 Lines • ▼ Show 20 Lines
void void
invoke_on_all_policies(Op op, T&&... rest) invoke_on_all_policies(Op op, T&&... rest)
{ {
using namespace __pstl::execution; using namespace __pstl::execution;
// Try static execution policies // Try static execution policies
invoke_on_all_iterator_types()(seq, op, std::forward<T>(rest)...); invoke_on_all_iterator_types()(seq, op, std::forward<T>(rest)...);
invoke_on_all_iterator_types()(unseq, op, std::forward<T>(rest)...); invoke_on_all_iterator_types()(unseq, op, std::forward<T>(rest)...);
#if __PSTL_USE_PAR_POLICIES #if _PSTL_USE_PAR_POLICIES
invoke_on_all_iterator_types()(par, op, std::forward<T>(rest)...); invoke_on_all_iterator_types()(par, op, std::forward<T>(rest)...);
invoke_on_all_iterator_types()(par_unseq, op, std::forward<T>(rest)...); invoke_on_all_iterator_types()(par_unseq, op, std::forward<T>(rest)...);
#endif #endif
} }
template <typename F> template <typename F>
struct NonConstAdapter struct NonConstAdapter
{ {
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines for (; first != last; ++first)
init = binary_op(init, unary_op(*first)); init = binary_op(init, unary_op(*first));
} }
return init; return init;
} }
static const char* static const char*
done() done()
{ {
#if __PSTL_TEST_SUCCESSFUL_KEYWORD #if _PSTL_TEST_SUCCESSFUL_KEYWORD
return "done"; return "done";
#else #else
return "passed"; return "passed";
#endif #endif
} }
// test_algo_basic_* functions are used to execute // test_algo_basic_* functions are used to execute
// f on a very basic sequence of elements of type T. // f on a very basic sequence of elements of type T.
Show All 20 Linestest_algo_basic_double(F&& f)
invoke_on_all_policies(f, in.begin(), out.begin()); invoke_on_all_policies(f, in.begin(), out.begin());
} }
template <typename Policy, typename F> template <typename Policy, typename F>
static void static void
invoke_if(Policy&& p, F f) invoke_if(Policy&& p, F f)
{ {
#if __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN #if _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
__pstl::__internal::invoke_if_not(__pstl::__internal::allow_unsequenced<Policy>(), f); __pstl::__internal::invoke_if_not(__pstl::__internal::allow_unsequenced<Policy>(), f);
#else #else
f(); f();
#endif #endif
} }
} /* namespace TestUtils */ } /* namespace TestUtils */