From: Thomas Rodgers Date: Thu, 21 Mar 2019 23:48:49 +0000 (+0000) Subject: Integrate C++17 parallel algorithms X-Git-Tag: upstream/12.2.0~25542 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=061f457868281238db43ef784aa12269cc866adb;p=platform%2Fupstream%2Fgcc.git Integrate C++17 parallel algorithms This is the Intel implementation of the C++17 parallel algorithms, which has been donated to both GCC and LLVM. The upstream project is at - https://reviews.llvm.org/source/pstl/ The new files in the include/pstl sub-directory are covered by the LICENSE.txt in that sub-directory, as are the tests in testsuite/**/pstl/* * include/Makefile.am (std_header): Add ${std_srcdir}/execution. (pstl_srcdir, pstl_builddir, pstl_headers): New variables. (allstamped): Add stamp-pstl. (install-headers): Add ptsl_builddir. * include/Makefile.in: Regenerate. * include/bits/c++config: Add pstl configuration. * include/pstl/LICENSE.txt: New file. * include/pstl/algorithm_fwd.h: New file. * include/pstl/algorithm_impl.h: New file. * include/pstl/execution_defs.h: New file. * include/pstl/execution_impl.h: New file. * include/pstl/glue_algorithm_defs.h: New file. * include/pstl/glue_algorithm_impl.h: New file. * include/pstl/glue_execution_defs.h: New file. * include/pstl/glue_memory_defs.h: New file. * include/pstl/glue_memory_impl.h: New file. * include/pstl/glue_numeric_defs.h: New file. * include/pstl/glue_numeric_impl.h: New file. * include/pstl/memory_impl.h: New file. * include/pstl/numeric_fwd.h: New file. * include/pstl/numeric_impl.h: New file. * include/pstl/parallel_backend.h: New file. * include/pstl/parallel_backend_tbb.h: New file. * include/pstl/parallel_backend_utils.h: New file. * include/pstl/parallel_impl.h: New file. * include/pstl/pstl_config.h: New file. * include/pstl/unseq_backend_simd.h: New file. * include/pstl/utils.h: New file. * include/std/algorithm: Include parallel algorithm implementations. * include/std/execution: New file. * include/std/memory: Include parallel algorithm implementations. * include/std/numeric: Include parallel algorithm implementations. * include/std/version: Add parallel algorithms feature test macro. * testsuite/util/pstl/pstl_test_config.h: New file. * testsuite/util/pstl/test_utils.h: New file. * testsuite/20_util/specialized_algorithms/pstl/uninitialized_construct.cc: New file. * testsuite/20_util/specialized_algorithms/pstl/uninitialized_copy_move.cc: New file. * testsuite/20_util/specialized_algorithms/pstl/uninitialized_fill_destroy.cc: New file. * testsuite/25_algorithms/pstl/alg_merge/inplace_merge.cc: New file. * testsuite/25_algorithms/pstl/alg_merge/merge.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/copy_if.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/copy_move.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/fill.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/generate.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/is_partitioned.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/partition.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/partition_copy.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/remove.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/remove_copy.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/replace.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/replace_copy.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/rotate.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/rotate_copy.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/swap_ranges.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/transform_binary.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/transform_unary.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/unique.cc: New file. * testsuite/25_algorithms/pstl/alg_modifying_operations/unique_copy_equal.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/adjacent_find.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/all_of.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/any_of.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/count.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/equal.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/find.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/find_end.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/find_first_of.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/find_if.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/for_each.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/mismatch.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/none_of.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/nth_element.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/reverse.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/reverse_copy.cc: New file. * testsuite/25_algorithms/pstl/alg_nonmodifying/search_n.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/includes.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/is_heap.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/is_sorted.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/lexicographical_compare.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/partial_sort.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/partial_sort_copy.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/set.cc: New file. * testsuite/25_algorithms/pstl/alg_sorting/sort.cc: New file. * testsuite/26_numerics/pstl/numeric_ops/adjacent_difference.cc: New file. * testsuite/26_numerics/pstl/numeric_ops/reduce.cc: New file. * testsuite/26_numerics/pstl/numeric_ops/scan.cc: New file. * testsuite/26_numerics/pstl/numeric_ops/transform_reduce.cc: New file. * testsuite/26_numerics/pstl/numeric_ops/transform_scan.cc: New file. * testsuite/testsuite/20_util/specialized_algorithms/pstl/uninitialized_construct.cc: New file. * testsuite/testsuite/20_util/specialized_algorithms/pstl/uninitialized_copy_move.cc: New file. * testsuite/testsuite/20_util/specialized_algorithms/pstl/uninitialized_fill_destroy.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_merge/inplace_merge.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_merge/merge.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_if.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_move.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/fill.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/generate.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/is_partitioned.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/partition.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/partition_copy.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/remove.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/remove_copy.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/replace.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/replace_copy.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate_copy.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/swap_ranges.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_binary.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_unary.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/unique.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/unique_copy_equal.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/adjacent_find.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/all_of.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/any_of.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/count.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/equal.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find_end.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find_first_of.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find_if.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/for_each.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/mismatch.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/none_of.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/nth_element.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse_copy.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/search_n.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/includes.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/is_heap.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/is_sorted.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/lexicographical_compare.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/partial_sort.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/partial_sort_copy.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/set.cc: New file. * testsuite/testsuite/25_algorithms/pstl/alg_sorting/sort.cc: New file. * testsuite/testsuite/26_numerics/pstl/numeric_ops/adjacent_difference.cc: New file. * testsuite/testsuite/26_numerics/pstl/numeric_ops/reduce.cc: New file. * testsuite/testsuite/26_numerics/pstl/numeric_ops/scan.cc: New file. * testsuite/testsuite/26_numerics/pstl/numeric_ops/transform_reduce.cc: New file. * testsuite/testsuite/26_numerics/pstl/numeric_ops/transform_scan.cc: New file. From-SVN: r269863 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index dad1e54..c867226 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,147 @@ +2019-03-21 Thomas Rodgers + + * include/Makefile.am (std_header): Add ${std_srcdir}/execution. + (pstl_srcdir, pstl_builddir, pstl_headers): New variables. + (allstamped): Add stamp-pstl. + (install-headers): Add ptsl_builddir. + * include/Makefile.in: Regenerate. + * include/bits/c++config: Add pstl configuration. + * include/pstl/LICENSE.txt: New file. + * include/pstl/algorithm_fwd.h: New file. + * include/pstl/algorithm_impl.h: New file. + * include/pstl/execution_defs.h: New file. + * include/pstl/execution_impl.h: New file. + * include/pstl/glue_algorithm_defs.h: New file. + * include/pstl/glue_algorithm_impl.h: New file. + * include/pstl/glue_execution_defs.h: New file. + * include/pstl/glue_memory_defs.h: New file. + * include/pstl/glue_memory_impl.h: New file. + * include/pstl/glue_numeric_defs.h: New file. + * include/pstl/glue_numeric_impl.h: New file. + * include/pstl/memory_impl.h: New file. + * include/pstl/numeric_fwd.h: New file. + * include/pstl/numeric_impl.h: New file. + * include/pstl/parallel_backend.h: New file. + * include/pstl/parallel_backend_tbb.h: New file. + * include/pstl/parallel_backend_utils.h: New file. + * include/pstl/parallel_impl.h: New file. + * include/pstl/pstl_config.h: New file. + * include/pstl/unseq_backend_simd.h: New file. + * include/pstl/utils.h: New file. + * include/std/algorithm: Include parallel algorithm implementations. + * include/std/execution: New file. + * include/std/memory: Include parallel algorithm implementations. + * include/std/numeric: Include parallel algorithm implementations. + * include/std/version: Add parallel algorithms feature test macro. + * testsuite/util/pstl/pstl_test_config.h: New file. + * testsuite/util/pstl/test_utils.h: New file. + * testsuite/20_util/specialized_algorithms/pstl/uninitialized_construct.cc: New file. + * testsuite/20_util/specialized_algorithms/pstl/uninitialized_copy_move.cc: New file. + * testsuite/20_util/specialized_algorithms/pstl/uninitialized_fill_destroy.cc: New file. + * testsuite/25_algorithms/pstl/alg_merge/inplace_merge.cc: New file. + * testsuite/25_algorithms/pstl/alg_merge/merge.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/copy_if.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/copy_move.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/fill.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/generate.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/is_partitioned.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/partition.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/partition_copy.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/remove.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/remove_copy.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/replace.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/replace_copy.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/rotate.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/rotate_copy.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/swap_ranges.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/transform_binary.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/transform_unary.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/unique.cc: New file. + * testsuite/25_algorithms/pstl/alg_modifying_operations/unique_copy_equal.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/adjacent_find.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/all_of.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/any_of.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/count.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/equal.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/find.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/find_end.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/find_first_of.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/find_if.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/for_each.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/mismatch.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/none_of.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/nth_element.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/reverse.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/reverse_copy.cc: New file. + * testsuite/25_algorithms/pstl/alg_nonmodifying/search_n.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/includes.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/is_heap.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/is_sorted.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/lexicographical_compare.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/partial_sort.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/partial_sort_copy.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/set.cc: New file. + * testsuite/25_algorithms/pstl/alg_sorting/sort.cc: New file. + * testsuite/26_numerics/pstl/numeric_ops/adjacent_difference.cc: New file. + * testsuite/26_numerics/pstl/numeric_ops/reduce.cc: New file. + * testsuite/26_numerics/pstl/numeric_ops/scan.cc: New file. + * testsuite/26_numerics/pstl/numeric_ops/transform_reduce.cc: New file. + * testsuite/26_numerics/pstl/numeric_ops/transform_scan.cc: New file. + * testsuite/testsuite/20_util/specialized_algorithms/pstl/uninitialized_construct.cc: New file. + * testsuite/testsuite/20_util/specialized_algorithms/pstl/uninitialized_copy_move.cc: New file. + * testsuite/testsuite/20_util/specialized_algorithms/pstl/uninitialized_fill_destroy.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_merge/inplace_merge.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_merge/merge.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_if.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_move.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/fill.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/generate.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/is_partitioned.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/partition.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/partition_copy.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/remove.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/remove_copy.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/replace.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/replace_copy.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate_copy.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/swap_ranges.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_binary.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_unary.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/unique.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_modifying_operations/unique_copy_equal.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/adjacent_find.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/all_of.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/any_of.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/count.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/equal.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find_end.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find_first_of.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/find_if.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/for_each.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/mismatch.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/none_of.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/nth_element.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse_copy.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_nonmodifying/search_n.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/includes.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/is_heap.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/is_sorted.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/lexicographical_compare.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/partial_sort.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/partial_sort_copy.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/set.cc: New file. + * testsuite/testsuite/25_algorithms/pstl/alg_sorting/sort.cc: New file. + * testsuite/testsuite/26_numerics/pstl/numeric_ops/adjacent_difference.cc: New file. + * testsuite/testsuite/26_numerics/pstl/numeric_ops/reduce.cc: New file. + * testsuite/testsuite/26_numerics/pstl/numeric_ops/scan.cc: New file. + * testsuite/testsuite/26_numerics/pstl/numeric_ops/transform_reduce.cc: New file. + * testsuite/testsuite/26_numerics/pstl/numeric_ops/transform_scan.cc: New file. + 2019-03-21 Jonathan Wakely * include/c_compatibility/math.h [!__STDCPP_WANT_MATH_SPEC_FUNCS__] diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 6541cac..1deacb8 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -38,6 +38,7 @@ std_headers = \ ${std_srcdir}/complex \ ${std_srcdir}/condition_variable \ ${std_srcdir}/deque \ + ${std_srcdir}/execution \ ${std_srcdir}/filesystem \ ${std_srcdir}/forward_list \ ${std_srcdir}/fstream \ @@ -225,6 +226,32 @@ bits_sup_headers = \ ${bits_sup_srcdir}/hash_bytes.h \ ${bits_sup_srcdir}/nested_exception.h +# C++17 Parallel Algorithm Includes. +pstl_srcdir = ${glibcxx_srcdir}/include/pstl +pstl_builddir = ./pstl +pstl_headers = \ + ${pstl_srcdir}/algorithm_fwd.h \ + ${pstl_srcdir}/algorithm_impl.h \ + ${pstl_srcdir}/execution_defs.h \ + ${pstl_srcdir}/execution_impl.h \ + ${pstl_srcdir}/glue_algorithm_defs.h \ + ${pstl_srcdir}/glue_algorithm_impl.h \ + ${pstl_srcdir}/glue_execution_defs.h \ + ${pstl_srcdir}/glue_memory_defs.h \ + ${pstl_srcdir}/glue_memory_impl.h \ + ${pstl_srcdir}/glue_numeric_defs.h \ + ${pstl_srcdir}/glue_numeric_impl.h \ + ${pstl_srcdir}/memory_impl.h \ + ${pstl_srcdir}/numeric_fwd.h \ + ${pstl_srcdir}/numeric_impl.h \ + ${pstl_srcdir}/parallel_backend.h \ + ${pstl_srcdir}/parallel_backend_tbb.h \ + ${pstl_srcdir}/parallel_backend_utils.h \ + ${pstl_srcdir}/parallel_impl.h \ + ${pstl_srcdir}/pstl_config.h \ + ${pstl_srcdir}/unseq_backend_simd.h \ + ${pstl_srcdir}/utils.h + backward_srcdir = ${glibcxx_srcdir}/include/backward backward_builddir = ./backward backward_headers = \ @@ -1014,7 +1041,7 @@ endif # List of all timestamp files. By keeping only one copy of this list, both # CLEANFILES and all-local are kept up-to-date. allstamped = \ - stamp-std stamp-bits stamp-bits-sup stamp-c_base stamp-c_compatibility \ + stamp-std stamp-bits stamp-bits-sup stamp-pstl stamp-c_base stamp-c_compatibility \ stamp-backward stamp-ext stamp-pb stamp-tr1 stamp-tr2 stamp-decimal \ stamp-experimental stamp-experimental-bits stamp-debug stamp-parallel \ stamp-profile stamp-profile-impl stamp-host @@ -1047,6 +1074,11 @@ stamp-bits-sup: stamp-bits ${bits_sup_headers} @-cd ${bits_builddir} && $(LN_S) ${bits_sup_headers} . 2>/dev/null @$(STAMP) stamp-bits-sup +stamp-pstl: ${pstl_headers} + @-mkdir -p ${pstl_builddir} + @-cd ${pstl_builddir} && $(LN_S) $? . 2>/dev/null + @$(STAMP) stamp-pstl + stamp-c_base: ${c_base_headers} @-mkdir -p ${c_base_builddir} @-cd ${c_base_builddir} && $(LN_S) $? . 2>/dev/null @@ -1480,7 +1512,9 @@ install-headers: $(mkinstalldirs) $(DESTDIR)${host_installdir}/../ext for file in ${ext_host_headers}; do \ $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}/../ext; done - + $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${pstl_builddir} + for file in ${pstl_headers}; do \ + $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${pstl_builddir}; done # By adding these files here, automake will remove them for 'make clean' CLEANFILES = ${pch_output} ${pch_output_anchors} stamp-host diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index bafe69c..bc475c6 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -382,6 +382,7 @@ std_headers = \ ${std_srcdir}/complex \ ${std_srcdir}/condition_variable \ ${std_srcdir}/deque \ + ${std_srcdir}/execution \ ${std_srcdir}/filesystem \ ${std_srcdir}/forward_list \ ${std_srcdir}/fstream \ @@ -569,6 +570,33 @@ bits_sup_headers = \ ${bits_sup_srcdir}/hash_bytes.h \ ${bits_sup_srcdir}/nested_exception.h + +# C++17 Parallel Algorithm Includes. +pstl_srcdir = ${glibcxx_srcdir}/include/pstl +pstl_builddir = ./pstl +pstl_headers = \ + ${pstl_srcdir}/algorithm_fwd.h \ + ${pstl_srcdir}/algorithm_impl.h \ + ${pstl_srcdir}/execution_defs.h \ + ${pstl_srcdir}/execution_impl.h \ + ${pstl_srcdir}/glue_algorithm_defs.h \ + ${pstl_srcdir}/glue_algorithm_impl.h \ + ${pstl_srcdir}/glue_execution_defs.h \ + ${pstl_srcdir}/glue_memory_defs.h \ + ${pstl_srcdir}/glue_memory_impl.h \ + ${pstl_srcdir}/glue_numeric_defs.h \ + ${pstl_srcdir}/glue_numeric_impl.h \ + ${pstl_srcdir}/memory_impl.h \ + ${pstl_srcdir}/numeric_fwd.h \ + ${pstl_srcdir}/numeric_impl.h \ + ${pstl_srcdir}/parallel_backend.h \ + ${pstl_srcdir}/parallel_backend_tbb.h \ + ${pstl_srcdir}/parallel_backend_utils.h \ + ${pstl_srcdir}/parallel_impl.h \ + ${pstl_srcdir}/pstl_config.h \ + ${pstl_srcdir}/unseq_backend_simd.h \ + ${pstl_srcdir}/utils.h + backward_srcdir = ${glibcxx_srcdir}/include/backward backward_builddir = ./backward backward_headers = \ @@ -1346,7 +1374,7 @@ PCHFLAGS = -x c++-header -nostdinc++ $(CXXFLAGS) $(VTV_PCH_CXXFLAGS) # List of all timestamp files. By keeping only one copy of this list, both # CLEANFILES and all-local are kept up-to-date. allstamped = \ - stamp-std stamp-bits stamp-bits-sup stamp-c_base stamp-c_compatibility \ + stamp-std stamp-bits stamp-bits-sup stamp-pstl stamp-c_base stamp-c_compatibility \ stamp-backward stamp-ext stamp-pb stamp-tr1 stamp-tr2 stamp-decimal \ stamp-experimental stamp-experimental-bits stamp-debug stamp-parallel \ stamp-profile stamp-profile-impl stamp-host @@ -1362,7 +1390,6 @@ allcreated = \ # Host includes for threads uppercase = [ABCDEFGHIJKLMNOPQRSTUVWXYZ_] - # By adding these files here, automake will remove them for 'make clean' CLEANFILES = ${pch_output} ${pch_output_anchors} stamp-host all: all-am @@ -1550,6 +1577,11 @@ stamp-bits-sup: stamp-bits ${bits_sup_headers} @-cd ${bits_builddir} && $(LN_S) ${bits_sup_headers} . 2>/dev/null @$(STAMP) stamp-bits-sup +stamp-pstl: ${pstl_headers} + @-mkdir -p ${pstl_builddir} + @-cd ${pstl_builddir} && $(LN_S) $? . 2>/dev/null + @$(STAMP) stamp-pstl + stamp-c_base: ${c_base_headers} @-mkdir -p ${c_base_builddir} @-cd ${c_base_builddir} && $(LN_S) $? . 2>/dev/null @@ -1956,6 +1988,9 @@ install-headers: $(mkinstalldirs) $(DESTDIR)${host_installdir}/../ext for file in ${ext_host_headers}; do \ $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}/../ext; done + $(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${pstl_builddir} + for file in ${pstl_headers}; do \ + $(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${pstl_builddir}; done # To remove directories. clean-local: diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index c785bf84..66420a9 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -665,4 +665,103 @@ namespace std # endif #endif // GCC +// PSTL configuration + +#if __cplusplus >= 201703L +// Preserved here so we have some idea which version of upstream we've pulled in +// #define PSTL_VERSION 104 +// #define PSTL_VERSION_MAJOR (PSTL_VERSION/100) +// #define PSTL_VERSION_MINOR (PSTL_VERSION - PSTL_VERSION_MAJOR * 100) + +// For now this defaults to being based on the presence of Thread Building Blocks +# ifndef _GLIBCXX_USE_TBB_PAR_BACKEND +# define _GLIBCXX_USE_TBB_PAR_BACKEND __has_include() +# endif +// This section will need some rework when a new (default) backend type is added +# if _GLIBCXX_USE_TBB_PAR_BACKEND +# define __PSTL_USE_PAR_POLICIES 1 +# endif + +# if __PSTL_USE_PAR_POLICIES +# if !defined(__PSTL_PAR_BACKEND_TBB) +# define __PSTL_PAR_BACKEND_TBB 1 +# endif +# else +# undef __PSTL_PAR_BACKEND_TBB +# endif + +# define __PSTL_PRAGMA(x) _Pragma (#x) + +# define __PSTL_STRING_AUX(x) #x +# define __PSTL_STRING(x) __PSTL_STRING_AUX(x) +# define __PSTL_STRING_CONCAT(x, y) x#y + +# define __PSTL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + \ + __GNUC_PATCHLEVEL__) + +// Enable SIMD for compilers that support OpenMP 4.0 +# if (__PSTL_GCC_VERSION >= 40900) +# define __PSTL_PRAGMA_SIMD __PSTL_PRAGMA(omp simd) +#define __PSTL_PRAGMA_DECLARE_SIMD __PSTL_PRAGMA(omp declare simd) +# define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) __PSTL_PRAGMA(omp simd reduction(PRM)) +# else //no simd +# define __PSTL_PRAGMA_SIMD +# define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) +# endif //Enable SIMD + +#define __PSTL_PRAGMA_SIMD_SCAN(PRM) +#define __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) +#define __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) + +#define __PSTL_PRAGMA_FORCEINLINE + +// 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) +// TODO define libstdc++ policies + +# define __PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT \ + (__cplusplus >= 201300L || __cpp_lib_robust_nonmodifying_seq_ops == 201304) +# define __PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT \ + (__cplusplus >= 201402L || __cpp_lib_make_reverse_iterator == 201402) +# define __PSTL_CPP14_INTEGER_SEQUENCE_PRESENT (__cplusplus >= 201402L) +# define __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT (__cplusplus >= 201402L) + +# if __PSTL_MONOTONIC_PRESENT +# 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)) +# else +# define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) +# define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) +# endif + +// Declaration of reduction functor, where +// NAME - the name of the functor +// OP - type of the callable object with the reduction operation +// omp_in - refers to the local partial result +// omp_out - refers to the final value of the combiner operator +// omp_priv - refers to the private copy of the initial value +// omp_orig - refers to the original variable to be reduced +#define __PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP) \ + __PSTL_PRAGMA(omp declare reduction(NAME : OP : omp_out(omp_in)) initializer(omp_priv = omp_orig)) + +# define __PSTL_PRAGMA_VECTOR_UNALIGNED +# define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED +# define __PSTL_PRAGMA_LOCATION + +# define __PSTL_PRAGMA_MESSAGE_IMPL(x) \ + __PSTL_PRAGMA(message(__PSTL_STRING_CONCAT(__PSTL_PRAGMA_LOCATION, x))) +# define __PSTL_PRAGMA_MESSAGE_POLICIES(x) __PSTL_PRAGMA_MESSAGE_IMPL(x) + +//Too many warnings in output, switched off +# define __PSTL_PRAGMA_MESSAGE(x) + +# if defined(__GLIBCXX__) +# define __PSTL_CPP11_STD_ROTATE_BROKEN \ + (__PSTL_GCC_VERSION < 50100) //GCC 5.1 release +# endif + +#endif // End of prewritten config; the settings discovered at configure time follow. diff --git a/libstdc++-v3/include/pstl/LICENSE.txt b/libstdc++-v3/include/pstl/LICENSE.txt new file mode 100644 index 0000000..9eda544 --- /dev/null +++ b/libstdc++-v3/include/pstl/LICENSE.txt @@ -0,0 +1,307 @@ +============================================================================== +The LLVM Project is under the Apache License v2.0 with LLVM Exceptions: +============================================================================== + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +---- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. + +============================================================================== +Software from third parties included in the LLVM Project: +============================================================================== +The LLVM Project contains third party software which is under different license +terms. All such code will be identified clearly using at least one of two +mechanisms: +1) It will be in a separate directory tree with its own `LICENSE.txt` or + `LICENSE` file at the top containing the specific license and restrictions + which apply to that software, or +2) It will contain specific license and restriction terms at the top of every + file. + +============================================================================== +Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy): +============================================================================== + +The software contained in this directory tree is dual licensed under both the +University of Illinois "BSD-Like" license and the MIT license. As a user of +this code you may choose to use it under either license. As a contributor, +you agree to allow your code to be used under both. + +Full text of the relevant licenses is included below. + +============================================================================== + +University of Illinois/NCSA +Open Source License + +Copyright (c) 2017-2019 by the contributors listed in CREDITS.TXT + +All rights reserved. + +Developed by: + Threading Runtimes Team + Intel Corporation + http://www.intel.com + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal with +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimers. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimers in the + documentation and/or other materials provided with the distribution. + + * Neither the names of Intel Corporation Threading Runtimes Team nor the + names of its contributors may be used to endorse or promote products + derived from this Software without specific prior written permission. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE +SOFTWARE. + +============================================================================== + +Copyright (c) 2017-2019 by the contributors listed in CREDITS.TXT + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/libstdc++-v3/include/pstl/algorithm_fwd.h b/libstdc++-v3/include/pstl/algorithm_fwd.h new file mode 100644 index 0000000..209c680 --- /dev/null +++ b/libstdc++-v3/include/pstl/algorithm_fwd.h @@ -0,0 +1,1336 @@ +// -*- C++ -*- +//===-- algorithm_fwd.h --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_algorithm_fwd_H +#define __PSTL_algorithm_fwd_H + +#include +#include + +namespace __pstl +{ +namespace __internal +{ + +//------------------------------------------------------------------------ +// any_of +//------------------------------------------------------------------------ + +template +bool +__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, + /*__is_vector=*/std::false_type) noexcept; + +template +bool +__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, + /*__is_vector=*/std::true_type) noexcept; + +template +bool +__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, + /*parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// walk1 (pseudo) +// +// walk1 evaluates f(x) for each dereferenced value x drawn from [first,last) +//------------------------------------------------------------------------ + +template +void __brick_walk1(_ForwardIterator, _ForwardIterator, _Function, + /*vector=*/std::false_type) noexcept; + +template +void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function, + /*vector=*/std::true_type) noexcept; + +template +void +__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, + /*parallel=*/std::true_type); +#endif + +template +void +__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, + /*parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// walk1_n +//------------------------------------------------------------------------ + +template +_ForwardIterator __brick_walk1_n(_ForwardIterator, _Size, _Function, + /*_IsVectorTag=*/std::false_type); + +template +_RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function, + /*vectorTag=*/std::true_type) noexcept; + +template +_ForwardIterator +__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +template +_ForwardIterator +__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// walk2 (pseudo) +// +// walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...) +//------------------------------------------------------------------------ + +template +_ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, + /*vector=*/std::false_type) noexcept; + +template +_ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, + /*vector=*/std::true_type) noexcept; + +template +_ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, + /*vector=*/std::false_type) noexcept; + +template +_ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, + /*vector=*/std::true_type) noexcept; + +template +_ForwardIterator2 +__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator2 +__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, + /*parallel=*/std::true_type); +#endif + +template +_ForwardIterator2 +__pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator2 +__pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector, + /*parallel=*/std::true_type); +#endif + +template +_ForwardIterator2 +__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator2 +__pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _Brick, + /*parallel=*/std::true_type); +#endif + +template +_ForwardIterator2 +__pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator2 +__pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick, + /*parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// walk3 (pseudo) +// +// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...) +//------------------------------------------------------------------------ + +template +_ForwardIterator3 __brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function, + /*vector=*/std::false_type) noexcept; + +template +_RandomAccessIterator3 __brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator3, _Function, + /*vector=*/std::true_type) noexcept; + +template +_ForwardIterator3 +__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, + _Function, _IsVector, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator3 +__pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// equal +//------------------------------------------------------------------------ + +template +bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, + /* IsVector = */ std::false_type) noexcept; + +template +bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, + /* is_vector = */ std::true_type) noexcept; + +template +bool +__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, + _IsVector, + /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// find_if +//------------------------------------------------------------------------ + +template +_ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate, + /*is_vector=*/std::false_type) noexcept; + +template +_RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate, + /*is_vector=*/std::true_type) noexcept; + +template +_ForwardIterator +__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// find_end +//------------------------------------------------------------------------ + +template +_ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::false_type) noexcept; + +template +_ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::true_type) noexcept; + +template +_ForwardIterator1 +__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator1 +__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// find_first_of +//------------------------------------------------------------------------ + +template +_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::false_type) noexcept; + +template +_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*__is_vector=*/std::true_type) noexcept; + +template +_ForwardIterator1 +__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator1 +__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// search +//------------------------------------------------------------------------ + +template +_ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*vector=*/std::false_type) noexcept; + +template +_ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, + /*vector=*/std::true_type) noexcept; + +template +_ForwardIterator1 +__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator1 +__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// search_n +//------------------------------------------------------------------------ + +template +_ForwardIterator +__brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, + /*vector=*/std::false_type) noexcept; + +template +_ForwardIterator +__brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, + /*vector=*/std::true_type) noexcept; + +template +_ForwardIterator +__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, + IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, + _BinaryPredicate, IsVector, + /*is_parallel=*/std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// copy_n +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator, + /*vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator, + /*vector=*/std::true_type) noexcept; + +//------------------------------------------------------------------------ +// copy +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator, + /*vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + /*vector=*/std::true_type) noexcept; + +//------------------------------------------------------------------------ +// move +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator, + /*vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + /*vector=*/std::true_type) noexcept; + +//------------------------------------------------------------------------ +// swap_ranges +//------------------------------------------------------------------------ +template +_OutputIterator +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept; + +template +_OutputIterator +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept; + +//------------------------------------------------------------------------ +// copy_if +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, + /*vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, + /*vector=*/std::true_type) noexcept; + +template +std::pair<_DifferenceType, _DifferenceType> +__brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate, + /*vector=*/std::false_type) noexcept; +template +std::pair<_DifferenceType, _DifferenceType> +__brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate, + /*vector=*/std::true_type) noexcept; + +template +void +__brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*, + /*vector=*/std::false_type) noexcept; + +template +void +__brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict, + /*vector=*/std::true_type) noexcept; + +template +void +__brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*, + /*vector=*/std::false_type) noexcept; + +template +void +__brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*, + /*vector=*/std::true_type) noexcept; + +template +_OutputIterator +__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector, + /*parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate, + _IsVector, /*parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// count +//------------------------------------------------------------------------ + +template +typename std::iterator_traits<_ForwardIterator>::difference_type + __brick_count(_ForwardIterator, _ForwardIterator, _Predicate, + /* is_vector = */ std::true_type) noexcept; + +template +typename std::iterator_traits<_ForwardIterator>::difference_type + __brick_count(_ForwardIterator, _ForwardIterator, _Predicate, + /* is_vector = */ std::false_type) noexcept; + +template +typename std::iterator_traits<_ForwardIterator>::difference_type +__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, + /* is_parallel */ std::false_type, _IsVector) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +typename std::iterator_traits<_ForwardIterator>::difference_type +__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, + /* is_parallel */ std::true_type, _IsVector); +#endif + +//------------------------------------------------------------------------ +// unique +//------------------------------------------------------------------------ + +template +_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /*is_vector=*/std::false_type) noexcept; + +template +_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /*is_vector=*/std::true_type) noexcept; + +template +_ForwardIterator +__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, + /*is_parallel=*/std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// unique_copy +//------------------------------------------------------------------------ + +template +OutputIterator __brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, + /*vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate, + /*vector=*/std::true_type) noexcept; + +template +OutputIterator __pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector, + /*parallel=*/std::false_type) noexcept; + +template +_DifferenceType +__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, + /*vector=*/std::false_type) noexcept; + +template +_DifferenceType +__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, + /*vector=*/std::true_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + _BinaryPredicate, _IsVector, /*parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// reverse +//------------------------------------------------------------------------ + +template +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, + /*__is_vector=*/std::false_type) noexcept; + +template +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, + /*__is_vector=*/std::true_type) noexcept; + +template +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + /*is_vector=*/std::false_type) noexcept; + +template +void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + /*is_vector=*/std::true_type) noexcept; + +template +void +__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// reverse_copy +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, + /*is_vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, + /*is_vector=*/std::true_type) noexcept; + +template +_OutputIterator +__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// rotate +//------------------------------------------------------------------------ + +template +_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, + /*is_vector=*/std::false_type) noexcept; + +template +_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, + /*is_vector=*/std::true_type) noexcept; + +template +_ForwardIterator +__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// rotate_copy +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + /*__is_vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + /*__is_vector=*/std::true_type) noexcept; + +template +_OutputIterator +__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, + _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// is_partitioned +//------------------------------------------------------------------------ + +template +bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::false_type) noexcept; + +template +bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::true_type) noexcept; + +template +bool +__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// partition +//------------------------------------------------------------------------ + +template +_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::false_type) noexcept; + +template +_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /*is_vector=*/std::true_type) noexcept; + +template +_ForwardIterator +__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// stable_partition +//------------------------------------------------------------------------ + +template +_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + /*__is_vector=*/std::false_type) noexcept; + +template +_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + /*__is_vector=*/std::true_type) noexcept; + +template +_BidirectionalIterator +__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + _IsVector, + /*is_parallelization=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_BidirectionalIterator +__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, + _IsVector, + /*is_parallelization=*/std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// partition_copy +//------------------------------------------------------------------------ + +template +std::pair<_OutputIterator1, _OutputIterator2> + __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, + /*is_vector=*/std::false_type) noexcept; + +template +std::pair<_OutputIterator1, _OutputIterator2> + __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, + /*is_vector=*/std::true_type) noexcept; + +template +std::pair<_OutputIterator1, _OutputIterator2> +__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, + _UnaryPredicate, _IsVector, + /*is_parallelization=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +std::pair<_OutputIterator1, _OutputIterator2> +__pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, + _OutputIterator2, _UnaryPredicate, _IsVector, + /*is_parallelization=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// sort +//------------------------------------------------------------------------ + +template +void +__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, + /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/, + /*is_parallel=*/std::true_type, + /*is_move_constructible=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// stable_sort +//------------------------------------------------------------------------ + +template +void +__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector /*is_vector*/, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector /*is_vector*/, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// partial_sort +//------------------------------------------------------------------------ + +template +void +__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, + _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, + _Compare, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// partial_sort_copy +//------------------------------------------------------------------------ + +template +_RandomAccessIterator +__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, + _RandomAccessIterator, _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, + _RandomAccessIterator, _Compare, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// adjacent_find +//------------------------------------------------------------------------ + +template +_ForwardIterator +__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /* IsVector = */ std::true_type, bool) noexcept; + +template +_ForwardIterator +__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, + /* IsVector = */ std::false_type, bool) noexcept; + +template +_ForwardIterator +__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, + /* is_parallel */ std::false_type, _IsVector, bool) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate, + /* is_parallel */ std::true_type, _IsVector, bool); +#endif + +//------------------------------------------------------------------------ +// nth_element +//------------------------------------------------------------------------ +template +void +__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, + _IsVector, + /*is_parallel=*/std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// fill, fill_n +//------------------------------------------------------------------------ +template +void +__brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, + /* __is_vector = */ std::true_type) noexcept; + +template +void +__brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, + /* __is_vector = */ std::false_type) noexcept; + +template +void +__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, + /*is_parallel=*/std::false_type, _IsVector) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, + /*is_parallel=*/std::true_type, _IsVector); +#endif + +template +_OutputIterator +__brick_fill_n(_OutputIterator, _Size, const _Tp&, + /* __is_vector = */ std::true_type) noexcept; + +template +_OutputIterator +__brick_fill_n(_OutputIterator, _Size, const _Tp&, + /* __is_vector = */ std::false_type) noexcept; + +template +_OutputIterator +__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, + /*is_parallel=*/std::false_type, _IsVector) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, + /*is_parallel=*/std::true_type, _IsVector); +#endif + +//------------------------------------------------------------------------ +// generate, generate_n +//------------------------------------------------------------------------ + +template +void __brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator, + /* is_vector = */ std::true_type) noexcept; + +template +void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator, + /* is_vector = */ std::false_type) noexcept; + +template +void +__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, + /*is_parallel=*/std::false_type, _IsVector) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, + /*is_parallel=*/std::true_type, _IsVector); +#endif + +template +OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, + /* is_vector = */ std::true_type) noexcept; + +template +OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, + /* is_vector = */ std::false_type) noexcept; + +template +OutputIterator +__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, + /*is_parallel=*/std::false_type, _IsVector) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +OutputIterator +__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, + /*is_parallel=*/std::true_type, _IsVector); +#endif + +//------------------------------------------------------------------------ +// remove +//------------------------------------------------------------------------ +template +_ForwardIterator __brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, + /* __is_vector = */ std::false_type) noexcept; + +template +_RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate, + /* __is_vector = */ std::true_type) noexcept; + +template +_ForwardIterator +__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel*/ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, + /*is_parallel*/ std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// merge +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; + +template +_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; + +template +_OutputIterator +__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type); +#endif + +//------------------------------------------------------------------------ +// inplace_merge +//------------------------------------------------------------------------ + +template +void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; + +template +void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; + +template +void +__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, + _Compare, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// includes +//------------------------------------------------------------------------ + +template +bool +__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// set_union +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; + +template +_OutputIterator +__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// set_intersection +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; + +template +_OutputIterator +__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// set_difference +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; + +template +_OutputIterator +__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// set_symmetric_difference +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, + /*__is_vector=*/std::false_type) noexcept; + +template +_OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, + /*__is_vector=*/std::true_type) noexcept; + +template +_OutputIterator +__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _OutputIterator, _Compare, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// is_heap_until +//------------------------------------------------------------------------ + +template +_RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; + +template +_RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; + +template +_RandomAccessIterator +__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// min_element +//------------------------------------------------------------------------ + +template +_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; + +template +_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; + +template +_ForwardIterator +__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type); +#endif + +//------------------------------------------------------------------------ +// minmax_element +//------------------------------------------------------------------------ + +template +std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::false_type) noexcept; + +template +std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, + /* __is_vector = */ std::true_type) noexcept; + +template +std::pair<_ForwardIterator, _ForwardIterator> +__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, + /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +std::pair<_ForwardIterator, _ForwardIterator> +__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, + /* is_parallel = */ std::true_type); +#endif + +//------------------------------------------------------------------------ +// mismatch +//------------------------------------------------------------------------ + +template +std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1, + _ForwardIterator2, _ForwardIterator2, _Predicate, + /* __is_vector = */ std::false_type) noexcept; + +template +std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1, + _ForwardIterator2, _ForwardIterator2, _Predicate, + /* __is_vector = */ std::true_type) noexcept; + +template +std::pair<_ForwardIterator1, _ForwardIterator2> +__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Predicate, _IsVector, + /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +std::pair<_RandomAccessIterator1, _RandomAccessIterator2> +__pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _RandomAccessIterator2, _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept; +#endif + +//------------------------------------------------------------------------ +// lexicographical_compare +//------------------------------------------------------------------------ + +template +bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, + /* __is_vector = */ std::false_type) noexcept; + +template +bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, + _Compare, + /* __is_vector = */ std::true_type) noexcept; + +template +bool +__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept; +#endif + +} // namespace __internal +} // namespace __pstl +#endif /* __PSTL_algorithm_fwd_H */ diff --git a/libstdc++-v3/include/pstl/algorithm_impl.h b/libstdc++-v3/include/pstl/algorithm_impl.h new file mode 100644 index 0000000..9d82428 --- /dev/null +++ b/libstdc++-v3/include/pstl/algorithm_impl.h @@ -0,0 +1,3661 @@ +// -*- C++ -*- +//===-- algorithm_impl.h --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_algorithm_impl_H +#define __PSTL_algorithm_impl_H + +#include +#include +#include +#include +#include + +#include "execution_impl.h" +#include "memory_impl.h" +#include "unseq_backend_simd.h" + +#if __PSTL_USE_PAR_POLICIES +#include "parallel_backend.h" +#include "parallel_impl.h" +#endif + +namespace __pstl +{ +namespace __internal +{ + +//------------------------------------------------------------------------ +// any_of +//------------------------------------------------------------------------ + +template +bool +__brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, + /*__is_vector=*/std::false_type) noexcept +{ + return std::any_of(__first, __last, __pred); +}; + +template +bool +__brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, + /*__is_vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_or(__first, __last - __first, __pred); +}; + +template +bool +__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, + _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +{ + return __brick_any_of(__first, __last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, + _IsVector __is_vector, /*parallel=*/std::true_type) +{ + return __except_handler([&]() { + return __parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { + return __brick_any_of(__i, __j, __pred, __is_vector); + }); + }); +} +#endif + +// [alg.foreach] +// for_each_n with no policy + +template +_ForwardIterator +__for_each_n_it_serial(_ForwardIterator __first, _Size __n, _Function __f) +{ + for (; __n > 0; ++__first, --__n) + __f(__first); + return __first; +} + +//------------------------------------------------------------------------ +// walk1 (pseudo) +// +// walk1 evaluates f(x) for each dereferenced value x drawn from [first,last) +//------------------------------------------------------------------------ +template +void +__brick_walk1(_ForwardIterator __first, _ForwardIterator __last, _Function __f, /*vector=*/std::false_type) noexcept +{ + std::for_each(__first, __last, __f); +} + +template +void +__brick_walk1(_RandomAccessIterator __first, _RandomAccessIterator __last, _Function __f, + /*vector=*/std::true_type) noexcept +{ + __unseq_backend::__simd_walk_1(__first, __last - __first, __f); +} + +template +void +__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f, + _IsVector __is_vector, + /*parallel=*/std::false_type) noexcept +{ + __brick_walk1(__first, __last, __f, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f, + _IsVector __is_vector, + /*parallel=*/std::true_type) +{ + __except_handler([&]() { + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { + __brick_walk1(__i, __j, __f, __is_vector); + }); + }); +} +#endif + +template +void +__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, + /*parallel=*/std::false_type) noexcept +{ + __brick(__first, __last); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, + /*parallel=*/std::true_type) +{ + __except_handler([&]() { + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); }); + }); +} +#endif + +//------------------------------------------------------------------------ +// walk1_n +//------------------------------------------------------------------------ +template +_ForwardIterator +__brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, /*_IsVectorTag=*/std::false_type) +{ + return __for_each_n_it_serial(__first, __n, + [&__f](_ForwardIterator __it) { __f(*__it); }); // calling serial version +} + +template +_RandomAccessIterator +__brick_walk1_n(_RandomAccessIterator __first, _DifferenceType __n, _Function __f, + /*vectorTag=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_walk_1(__first, __n, __f); +} + +template +_ForwardIterator +__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_walk1_n(__first, __n, __f, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f, + _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + __pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector, std::true_type()); + return __first + __n; +} +#endif + +template +_ForwardIterator +__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick(__first, __n); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick, + /*is_parallel=*/std::true_type) +{ + return __except_handler([&]() { + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, + [__brick](_RandomAccessIterator __i, _RandomAccessIterator __j) { __brick(__i, __j - __i); }); + return __first + __n; + }); +} +#endif + +//------------------------------------------------------------------------ +// walk2 (pseudo) +// +// walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...) +//------------------------------------------------------------------------ +template +_ForwardIterator2 +__brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::false_type) noexcept +{ + for (; __first1 != __last1; ++__first1, ++__first2) + __f(*__first1, *__first2); + return __first2; +} + +template +_ForwardIterator2 +__brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_walk_2(__first1, __last1 - __first1, __first2, __f); +} + +template +_ForwardIterator2 +__brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::false_type) noexcept +{ + for (; __n > 0; --__n, ++__first1, ++__first2) + __f(*__first1, *__first2); + return __first2; +} + +template +_ForwardIterator2 +__brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, + /*vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_walk_2(__first1, __n, __first2, __f); +} + +template +_ForwardIterator2 +__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +{ + return __brick_walk2(__first1, __last1, __first2, __f, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator2 +__pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type) +{ + return __except_handler([&]() { + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, + [__f, __first1, __first2, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { + __brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector); + }); + return __first2 + (__last1 - __first1); + }); +} +#endif + +template +_ForwardIterator2 +__pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size n, _ForwardIterator2 __first2, _Function f, + _IsVector is_vector, /*parallel=*/std::false_type) noexcept +{ + return __brick_walk2_n(__first1, n, __first2, f, is_vector); +} + +template +_RandomAccessIterator2 +__pattern_walk2_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size n, _RandomAccessIterator2 __first2, + _Function f, _IsVector is_vector, /*parallel=*/std::true_type) +{ + return __pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + n, __first2, f, is_vector, + std::true_type()); +} + +template +_ForwardIterator2 +__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept +{ + return __brick(__first1, __last1, __first2); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator2 +__pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) +{ + return __except_handler([&]() { + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, + [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { + __brick(__i, __j, __first2 + (__i - __first1)); + }); + return __first2 + (__last1 - __first1); + }); +} +#endif + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator2 +__pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n, + _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type) +{ + return __except_handler([&]() { + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, + [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { + __brick(__i, __j - __i, __first2 + (__i - __first1)); + }); + return __first2 + __n; + }); +} +#endif + +template +_ForwardIterator2 +__pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, + _Brick __brick, /*parallel=*/std::false_type) noexcept +{ + return __brick(__first1, __n, __first2); +} + +//------------------------------------------------------------------------ +// walk3 (pseudo) +// +// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...) +//------------------------------------------------------------------------ +template +_ForwardIterator3 +__brick_walk3(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator3 __first3, _Function __f, /*vector=*/std::false_type) noexcept +{ + for (; __first1 != __last1; ++__first1, ++__first2, ++__first3) + __f(*__first1, *__first2, *__first3); + return __first3; +} + +template +_RandomAccessIterator3 +__brick_walk3(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, + _RandomAccessIterator3 __first3, _Function __f, /*vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f); +} + +template +_ForwardIterator3 +__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +{ + return __brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator3 +__pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector, + /*parallel=*/std::true_type) +{ + return __except_handler([&]() { + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, + [__f, __first1, __first2, __first3, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { + __brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f, __is_vector); + }); + return __first3 + (__last1 - __first1); + }); +} +#endif + +//------------------------------------------------------------------------ +// equal +//------------------------------------------------------------------------ + +template +bool +__brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p, + /* IsVector = */ std::false_type) noexcept +{ + return std::equal(__first1, __last1, __first2, __p); +} + +template +bool +__brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, + _BinaryPredicate __p, /* is_vector = */ std::true_type) noexcept +{ + return __unseq_backend::__simd_first(__first1, __last1 - __first1, __first2, __not_pred<_BinaryPredicate>(__p)) + .first == __last1; +} + +template +bool +__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +{ + return __brick_equal(__first1, __last1, __first2, __p, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + return __except_handler([&]() { + return !__parallel_or( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, + [__first1, __first2, __p, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { + return !__brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector); + }); + }); +} +#endif + +//------------------------------------------------------------------------ +// find_if +//------------------------------------------------------------------------ +template +_ForwardIterator +__brick_find_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /*is_vector=*/std::false_type) noexcept +{ + return std::find_if(__first, __last, __pred); +} + +template +_RandomAccessIterator +__brick_find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred, + /*is_vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType; + return __unseq_backend::__simd_first( + __first, _SizeType(0), __last - __first, + [&__pred](_RandomAccessIterator __it, _SizeType __i) { return __pred(__it[__i]); }); +} + +template +_ForwardIterator +__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_find_if(__first, __last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + return __except_handler([&]() { + return __parallel_find(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { + return __brick_find_if(__i, __j, __pred, __is_vector); + }, + std::less::difference_type>(), + /*is_first=*/true); + }); +} +#endif + +//------------------------------------------------------------------------ +// find_end +//------------------------------------------------------------------------ + +// find the first occurrence of the subsequence [s_first, s_last) +// or the last occurrence of the subsequence in the range [first, last) +// b_first determines what occurrence we want to find (first or last) +template +_RandomAccessIterator1 +__find_subrange(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator1 __global_last, + _RandomAccessIterator2 __s_first, _RandomAccessIterator2 __s_last, _BinaryPredicate __pred, + bool __b_first, _IsVector __is_vector) noexcept +{ + typedef typename std::iterator_traits<_RandomAccessIterator2>::value_type _ValueType; + auto __n2 = __s_last - __s_first; + if (__n2 < 1) + { + return __b_first ? __first : __last; + } + + auto __n1 = __global_last - __first; + if (__n1 < __n2) + { + return __last; + } + + auto __cur = __last; + while (__first != __last && (__global_last - __first >= __n2)) + { + // find position of *s_first in [first, last) (it can be start of subsequence) + __first = __brick_find_if(__first, __last, + __equal_value_by_pred<_ValueType, _BinaryPredicate>(*__s_first, __pred), __is_vector); + + // if position that was found previously is the start of subsequence + // then we can exit the loop (b_first == true) or keep the position + // (b_first == false) + if (__first != __last && (__global_last - __first >= __n2) && + __brick_equal(__s_first + 1, __s_last, __first + 1, __pred, __is_vector)) + { + if (__b_first) + { + return __first; + } + else + { + __cur = __first; + } + } + else if (__first == __last) + { + break; + } + else + { + } + + // in case of b_first == false we try to find new start position + // for the next subsequence + ++__first; + } + return __cur; +} + +template +_RandomAccessIterator +__find_subrange(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __global_last, + _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector) noexcept +{ + if (__global_last - __first < __count || __count < 1) + { + return __last; // According to the standard last shall be returned when count < 1 + } + + auto __n = __global_last - __first; + auto __unary_pred = __equal_value_by_pred<_Tp, _BinaryPredicate>(__value, __pred); + while (__first != __last && (__global_last - __first >= __count)) + { + __first = __brick_find_if(__first, __last, __unary_pred, __is_vector); + + // check that all of elements in [first+1, first+count) equal to value + if (__first != __last && (__global_last - __first >= __count) && + !__brick_any_of(__first + 1, __first + __count, __not_pred(__unary_pred), + __is_vector)) + { + return __first; + } + else if (__first == __last) + { + break; + } + else + { + ++__first; + } + } + return __last; +} + +template +_ForwardIterator1 +__brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept +{ + return std::find_end(__first, __last, __s_first, __s_last, __pred); +} + +template +_ForwardIterator1 +__brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept +{ + return __find_subrange(__first, __last, __last, __s_first, __s_last, __pred, false, std::true_type()); +} + +template +_ForwardIterator1 +__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator1 +__pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept +{ + if (__last - __first == __s_last - __s_first) + { + const bool __res = __pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred, + __is_vector, std::true_type()); + return __res ? __first : __last; + } + else + { + return __except_handler([&]() { + return __parallel_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { + return __find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, __is_vector); + }, + std::greater::difference_type>(), /*is_first=*/false); + }); + } +} +#endif + +//------------------------------------------------------------------------ +// find_first_of +//------------------------------------------------------------------------ +template +_ForwardIterator1 +__brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept +{ + return std::find_first_of(__first, __last, __s_first, __s_last, __pred); +} + +template +_ForwardIterator1 +__brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_find_first_of(__first, __last, __s_first, __s_last, __pred); +} + +template +_ForwardIterator1 +__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator1 +__pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept +{ + return __except_handler([&]() { + return __parallel_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { + return __brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector); + }, + std::less::difference_type>(), /*is_first=*/true); + }); +} +#endif + +//------------------------------------------------------------------------ +// search +//------------------------------------------------------------------------ +template +_ForwardIterator1 +__brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept +{ + return std::search(__first, __last, __s_first, __s_last, __pred); +} + +template +_ForwardIterator1 +__brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +{ + return __find_subrange(__first, __last, __last, __s_first, __s_last, __pred, true, std::true_type()); +} + +template +_ForwardIterator1 +__pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator1 +__pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, + _IsVector __is_vector, + /*is_parallel=*/std::true_type) noexcept +{ + if (__last - __first == __s_last - __s_first) + { + const bool __res = __pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred, + __is_vector, std::true_type()); + return __res ? __first : __last; + } + else + { + return __except_handler([&]() { + return __parallel_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { + return __find_subrange(__i, __j, __last, __s_first, __s_last, __pred, true, __is_vector); + }, + std::less::difference_type>(), /*is_first=*/true); + }); + } +} +#endif + +//------------------------------------------------------------------------ +// search_n +//------------------------------------------------------------------------ +template +_ForwardIterator +__brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, + _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept +{ + return std::search_n(__first, __last, __count, __value, __pred); +} + +template +_ForwardIterator +__brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, + _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +{ + return __find_subrange(__first, __last, __last, __count, __value, __pred, std::true_type()); +} + +template +_ForwardIterator +__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_search_n(__first, __last, __count, __value, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, + /*is_parallel=*/std::true_type) noexcept +{ + if (__last - __first == __count) + { + const bool __result = + !__pattern_any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); }, __is_vector, + /*is_parallel*/ std::true_type()); + return __result ? __first : __last; + } + else + { + return __except_handler([&__exec, __first, __last, __count, &__value, __pred, __is_vector]() { + return __parallel_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__last, __count, &__value, __pred, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) { + return __find_subrange(__i, __j, __last, __count, __value, __pred, __is_vector); + }, + std::less::difference_type>(), /*is_first=*/true); + }); + } +} +#endif + +//------------------------------------------------------------------------ +// copy_n +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::false_type) noexcept +{ + return std::copy_n(__first, __n, __result); +} + +template +_OutputIterator +__brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_assign( + __first, __n, __result, [](_ForwardIterator __first, _OutputIterator __result) { *__result = *__first; }); +} + +//------------------------------------------------------------------------ +// copy +//------------------------------------------------------------------------ +template +_OutputIterator +__brick_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept +{ + return std::copy(__first, __last, __result); +} + +template +_OutputIterator +__brick_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_assign( + __first, __last - __first, __result, + [](_RandomAccessIterator __first, _OutputIterator __result) { *__result = *__first; }); +} + +//------------------------------------------------------------------------ +// move +//------------------------------------------------------------------------ +template +_OutputIterator +__brick_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept +{ + return std::move(__first, __last, __result); +} + +template +_OutputIterator +__brick_move(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_assign( + __first, __last - __first, __result, + [](_RandomAccessIterator __first, _OutputIterator __result) { *__result = std::move(*__first); }); +} + +//------------------------------------------------------------------------ +// swap_ranges +//------------------------------------------------------------------------ +template +_OutputIterator +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept +{ + return std::swap_ranges(__first, __last, __result); +} + +template +_OutputIterator +__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept +{ + using std::iter_swap; + return __unseq_backend::__simd_assign(__first, __last - __first, __result, + iter_swap<_ForwardIterator, _OutputIterator>); +} + +//------------------------------------------------------------------------ +// copy_if +//------------------------------------------------------------------------ +template +_OutputIterator +__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, + /*vector=*/std::false_type) noexcept +{ + return std::copy_if(__first, __last, __result, __pred); +} + +template +_OutputIterator +__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, + /*vector=*/std::true_type) noexcept +{ +#if (__PSTL_MONOTONIC_PRESENT) + return __unseq_backend::__simd_copy_if(__first, __last - __first, __result, __pred); +#else + return std::copy_if(__first, __last, __result, __pred); +#endif +} + +// TODO: Try to use transform_reduce for combining __brick_copy_if_phase1 on IsVector. +template +std::pair<_DifferenceType, _DifferenceType> +__brick_calc_mask_1(_ForwardIterator __first, _ForwardIterator __last, bool* __restrict __mask, _UnaryPredicate __pred, + /*vector=*/std::false_type) noexcept +{ + auto __count_true = _DifferenceType(0); + auto __size = __last - __first; + + static_assert(__is_random_access_iterator<_ForwardIterator>::value, + "Pattern-brick error. Should be a random access iterator."); + + for (; __first != __last; ++__first, ++__mask) + { + *__mask = __pred(*__first); + if (*__mask) + { + ++__count_true; + } + } + return std::make_pair(__count_true, __size - __count_true); +} + +template +std::pair<_DifferenceType, _DifferenceType> +__brick_calc_mask_1(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __mask, _UnaryPredicate __pred, + /*vector=*/std::true_type) noexcept +{ + auto __result = __unseq_backend::__simd_calc_mask_1(__first, __last - __first, __mask, __pred); + return std::make_pair(__result, (__last - __first) - __result); +} + +template +void +__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask, + _Assigner __assigner, /*vector=*/std::false_type) noexcept +{ + for (; __first != __last; ++__first, ++__mask) + { + if (*__mask) + { + __assigner(__first, __result); + ++__result; + } + } +} + +template +void +__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + bool* __restrict __mask, _Assigner __assigner, /*vector=*/std::true_type) noexcept +{ +#if (__PSTL_MONOTONIC_PRESENT) + __unseq_backend::__simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner); +#else + __brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type()); +#endif +} + +template +void +__brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::false_type) noexcept +{ + for (; __first != __last; ++__first, ++__mask) + { + if (*__mask) + { + *__out_true = *__first; + ++__out_true; + } + else + { + *__out_false = *__first; + ++__out_false; + } + } +} + +template +void +__brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept +{ +#if (__PSTL_MONOTONIC_PRESENT) + __unseq_backend::__simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask); +#else + __brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type()); +#endif +} + +template +_OutputIterator +__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +{ + return __brick_copy_if(__first, __last, __result, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; + const _DifferenceType __n = __last - __first; + if (_DifferenceType(1) < __n) + { + __par_backend::__buffer __mask_buf(__n); + return __except_handler([&__exec, __n, __first, __result, __is_vector, __pred, &__mask_buf]() { + bool* __mask = __mask_buf.get(); + _DifferenceType __m{}; + __par_backend::parallel_strict_scan( + std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), + [=](_DifferenceType __i, _DifferenceType __len) { // Reduce + return __brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, + __pred, __is_vector) + .first; + }, + std::plus<_DifferenceType>(), // Combine + [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan + __brick_copy_by_mask(__first + __i, __first + (__i + __len), __result + __initial, __mask + __i, + [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, + __is_vector); + }, + [&__m](_DifferenceType __total) { __m = __total; }); + return __result + __m; + }); + } + // trivial sequence - use serial algorithm + return __brick_copy_if(__first, __last, __result, __pred, __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// count +//------------------------------------------------------------------------ +template +typename std::iterator_traits<_ForwardIterator>::difference_type +__brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_vector = */ std::true_type) noexcept +{ + return __unseq_backend::__simd_count(__first, __last - __first, __pred); +} + +template +typename std::iterator_traits<_ForwardIterator>::difference_type +__brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_vector = */ std::false_type) noexcept +{ + return std::count_if(__first, __last, __pred); +} + +template +typename std::iterator_traits<_ForwardIterator>::difference_type +__pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_parallel */ std::false_type, _IsVector __is_vector) noexcept +{ + return __brick_count(__first, __last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +typename std::iterator_traits<_ForwardIterator>::difference_type +__pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, + /* is_parallel */ std::true_type, _IsVector __is_vector) +{ + typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType; + return __except_handler([&]() { + return __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), __first, __last, _SizeType(0), + [__pred, __is_vector](_ForwardIterator __begin, _ForwardIterator __end, _SizeType __value) -> _SizeType { + return __value + __brick_count(__begin, __end, __pred, __is_vector); + }, + std::plus<_SizeType>()); + }); +} +#endif + +//------------------------------------------------------------------------ +// unique +//------------------------------------------------------------------------ + +template +_ForwardIterator +__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /*is_vector=*/std::false_type) noexcept +{ + return std::unique(__first, __last, __pred); +} + +template +_ForwardIterator +__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /*is_vector=*/std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::unique(__first, __last, __pred); +} + +template +_ForwardIterator +__pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_unique(__first, __last, __pred, __is_vector); +} + +#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. +// So, a caller passes _CalcMask brick into remove_elements. +template +_ForwardIterator +remove_elements(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _CalcMask __calc_mask, + _IsVector __is_vector) +{ + typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType; + typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp; + _DifferenceType __n = __last - __first; + __par_backend::__buffer __mask_buf(__n); + // 1. find a first iterator that should be removed + return __except_handler([&]() { + bool* __mask = __mask_buf.get(); + _DifferenceType __min = __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), _DifferenceType(0), __n, __n, + [__first, __mask, &__calc_mask, __is_vector](_DifferenceType __i, _DifferenceType __j, + _DifferenceType __local_min) -> _DifferenceType { + // Create mask + __calc_mask(__mask + __i, __mask + __j, __first + __i); + + // if minimum was found in a previous range we shouldn't do anymore + if (__local_min < __i) + { + return __local_min; + } + // find first iterator that should be removed + bool* __result = + __brick_find_if(__mask + __i, __mask + __j, [](bool __val) { return !__val; }, __is_vector); + if (__result - __mask == __j) + { + return __local_min; + } + return std::min(__local_min, _DifferenceType(__result - __mask)); + }, + [](_DifferenceType __local_min1, _DifferenceType __local_min2) -> _DifferenceType { + return std::min(__local_min1, __local_min2); + }); + + // No elements to remove - exit + if (__min == __n) + { + return __last; + } + __n -= __min; + __first += __min; + + __par_backend::__buffer<_Tp> __buf(__n); + _Tp* __result = __buf.get(); + __mask += __min; + _DifferenceType __m{}; + // 2. Elements that doesn't satisfy pred are moved to result + __par_backend::parallel_strict_scan( + std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), + [__mask, __is_vector](_DifferenceType __i, _DifferenceType __len) { + return __brick_count(__mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, __is_vector); + }, + std::plus<_DifferenceType>(), + [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { + __brick_copy_by_mask(__first + __i, __first + __i + __len, __result + __initial, __mask + __i, + [](_ForwardIterator __x, _Tp* __z) { + __invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); }, + [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); }); + }, + __is_vector); + }, + [&__m](_DifferenceType __total) { __m = __total; }); + + // 3. Elements from result are moved to [first, last) + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m, + [__result, __first, __is_vector](_Tp* __i, _Tp* __j) { + __brick_move(__i, __j, __first + (__i - __result), __is_vector); + }); + return __first + __m; + }); +} +#endif + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; + + if (__first == __last) + { + return __last; + } + if (__first + 1 == __last || __first + 2 == __last) + { + // Trivial sequence - use serial algorithm + return __brick_unique(__first, __last, __pred, __is_vector); + } + return remove_elements( + std::forward<_ExecutionPolicy>(__exec), ++__first, __last, + [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) { + __brick_walk3(__b, __e, __it - 1, __it, + [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); }, + __is_vector); + }, + __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// unique_copy +//------------------------------------------------------------------------ + +template +OutputIterator +__brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred, + /*vector=*/std::false_type) noexcept +{ + return std::unique_copy(__first, __last, __result, __pred); +} + +template +OutputIterator +__brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result, + _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +{ +#if (__PSTL_MONOTONIC_PRESENT) + return __unseq_backend::__simd_unique_copy(__first, __last - __first, __result, __pred); +#else + return std::unique_copy(__first, __last, __result, __pred); +#endif +} + +template +_OutputIterator +__pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _BinaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept +{ + return __brick_unique_copy(__first, __last, __result, __pred, __is_vector); +} + +template +_DifferenceType +__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, + _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept +{ + _DifferenceType __count = 0; + for (; __first != __last; ++__first, ++__mask) + { + *__mask = !__pred(*__first, *(__first - 1)); + __count += *__mask; + } + return __count; +} + +template +_DifferenceType +__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, + _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept +{ + return __unseq_backend::__simd_calc_mask_2(__first, __last - __first, __mask, __pred); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector, + /*parallel=*/std::true_type) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; + const _DifferenceType __n = __last - __first; + if (_DifferenceType(2) < __n) + { + __par_backend::__buffer __mask_buf(__n); + if (_DifferenceType(2) < __n) + { + return __except_handler([&__exec, __n, __first, __result, __pred, __is_vector, &__mask_buf]() { + bool* __mask = __mask_buf.get(); + _DifferenceType __m{}; + __par_backend::parallel_strict_scan( + std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), + [=](_DifferenceType __i, _DifferenceType __len) -> _DifferenceType { // Reduce + _DifferenceType __extra = 0; + if (__i == 0) + { + // Special boundary case + __mask[__i] = true; + if (--__len == 0) + return 1; + ++__i; + ++__extra; + } + return __brick_calc_mask_2<_DifferenceType>(__first + __i, __first + (__i + __len), + __mask + __i, __pred, __is_vector) + + __extra; + }, + std::plus<_DifferenceType>(), // Combine + [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan + // Phase 2 is same as for __pattern_copy_if + __brick_copy_by_mask(__first + __i, __first + (__i + __len), __result + __initial, __mask + __i, + [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, + __is_vector); + }, + [&__m](_DifferenceType __total) { __m = __total; }); + return __result + __m; + }); + } + } + // trivial sequence - use serial algorithm + return __brick_unique_copy(__first, __last, __result, __pred, __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// reverse +//------------------------------------------------------------------------ +template +void +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::false_type) noexcept +{ + std::reverse(__first, __last); +} + +template +void +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType; + + const auto __n = (__last - __first) / 2; + __unseq_backend::__simd_walk_2(__first, __n, std::reverse_iterator<_BidirectionalIterator>(__last), + [](_ReferenceType __x, _ReferenceType __y) { + using std::swap; + swap(__x, __y); + }); +} + +// this brick is called in parallel version, so we can use iterator arithmetic +template +void +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, + /*is_vector=*/std::false_type) noexcept +{ + for (--__d_last; __first != __last; ++__first, --__d_last) + { + using std::iter_swap; + iter_swap(__first, __d_last); + } +} + +// this brick is called in parallel version, so we can use iterator arithmetic +template +void +__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, + /*is_vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType; + + __unseq_backend::__simd_walk_2(__first, __last - __first, std::reverse_iterator<_BidirectionalIterator>(__d_last), + [](_ReferenceType __x, _ReferenceType __y) { + using std::swap; + swap(__x, __y); + }); +} + +template +void +__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, + _IsVector _is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + __brick_reverse(__first, __last, _is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2, + [__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) { + __brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector); + }); +} +#endif + +//------------------------------------------------------------------------ +// reverse_copy +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, + /*is_vector=*/std::false_type) noexcept +{ + return std::reverse_copy(__first, __last, __d_first); +} + +template +_OutputIterator +__brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, + /*is_vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType1; + typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2; + + return __unseq_backend::__simd_walk_2(std::reverse_iterator<_BidirectionalIterator>(__last), __last - __first, + __d_first, [](_ReferenceType1 __x, _ReferenceType2 __y) { __y = __x; }); +} + +template +_OutputIterator +__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_reverse_copy(__first, __last, __d_first, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + auto __len = __last - __first; + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first, + _BidirectionalIterator __inner_last) { + __brick_reverse_copy(__inner_first, __inner_last, + __d_first + (__len - (__inner_last - __first)), __is_vector); + }); + return __d_first + __len; +} +#endif + +//------------------------------------------------------------------------ +// rotate +//------------------------------------------------------------------------ +template +_ForwardIterator +__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + /*is_vector=*/std::false_type) noexcept +{ +#if __PSTL_CPP11_STD_ROTATE_BROKEN + std::rotate(__first, __middle, __last); + return std::next(__first, std::distance(__middle, __last)); +#else + return std::rotate(__first, __middle, __last); +#endif +} + +template +_ForwardIterator +__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + /*is_vector=*/std::true_type) noexcept +{ + auto __n = __last - __first; + auto __m = __middle - __first; + const _ForwardIterator __ret = __first + (__last - __middle); + + bool __is_left = (__m <= __n / 2); + if (!__is_left) + __m = __n - __m; + + while (__n > 1 && __m > 0) + { + using std::iter_swap; + const auto __m_2 = __m * 2; + if (__is_left) + { + for (; __last - __first >= __m_2; __first += __m) + { + __unseq_backend::__simd_assign(__first, __m, __first + __m, + iter_swap<_ForwardIterator, _ForwardIterator>); + } + } + else + { + for (; __last - __first >= __m_2; __last -= __m) + { + __unseq_backend::__simd_assign(__last - __m, __m, __last - __m_2, + iter_swap<_ForwardIterator, _ForwardIterator>); + } + } + __is_left = !__is_left; + __m = __n % __m; + __n = __last - __first; + } + + return __ret; +} + +template +_ForwardIterator +__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_rotate(__first, __middle, __last, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp; + auto __n = __last - __first; + auto __m = __middle - __first; + if (__m <= __n / 2) + { + __par_backend::__buffer<_Tp> __buf(__n - __m); + return __except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() { + _Tp* __result = __buf.get(); + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __middle, __last, + [__middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_uninitialized_move(__b, __e, __result + (__b - __middle), __is_vector); + }); + + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle, + [__last, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_move(__b, __e, __b + (__last - __middle), __is_vector); + }); + + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + (__n - __m), + [__first, __result, __is_vector](_Tp* __b, _Tp* __e) { + __brick_move(__b, __e, __first + (__b - __result), __is_vector); + }); + + return __first + (__last - __middle); + }); + } + else + { + __par_backend::__buffer<_Tp> __buf(__m); + return __except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() { + _Tp* __result = __buf.get(); + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle, + [__first, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_uninitialized_move(__b, __e, __result + (__b - __first), + __is_vector); + }); + + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last, + [__first, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + __brick_move(__b, __e, __first + (__b - __middle), __is_vector); + }); + + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m, + [__n, __m, __first, __result, __is_vector](_Tp* __b, _Tp* __e) { + __brick_move(__b, __e, __first + ((__n - __m) + (__b - __result)), + __is_vector); + }); + + return __first + (__last - __middle); + }); + } +} +#endif + +//------------------------------------------------------------------------ +// rotate_copy +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _OutputIterator __result, /*__is_vector=*/std::false_type) noexcept +{ + return std::rotate_copy(__first, __middle, __last, __result); +} + +template +_OutputIterator +__brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _OutputIterator __result, /*__is_vector=*/std::true_type) noexcept +{ + _OutputIterator __res = __brick_copy(__middle, __last, __result, std::true_type()); + return __brick_copy(__first, __middle, __res, std::true_type()); +} + +template +_OutputIterator +__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, + _OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_rotate_copy(__first, __middle, __last, __result, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__first, __last, __middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { + if (__b > __middle) + { + __brick_copy(__b, __e, __result + (__b - __middle), __is_vector); + } + else + { + _OutputIterator __new_result = __result + ((__last - __middle) + (__b - __first)); + if (__e < __middle) + { + __brick_copy(__b, __e, __new_result, __is_vector); + } + else + { + __brick_copy(__b, __middle, __new_result, __is_vector); + __brick_copy(__middle, __e, __result, __is_vector); + } + } + }); + return __result + (__last - __first); +} +#endif + +//------------------------------------------------------------------------ +// is_partitioned +//------------------------------------------------------------------------ + +template +bool +__brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::false_type) noexcept +{ + return std::is_partitioned(__first, __last, __pred); +} + +template +bool +__brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType; + if (__first == __last) + { + return true; + } + else + { + _ForwardIterator __result = __unseq_backend::__simd_first( + __first, _SizeType(0), __last - __first, + [&__pred](_ForwardIterator __it, _SizeType __i) { return !__pred(__it[__i]); }); + if (__result == __last) + { + return true; + } + else + { + ++__result; + return !__unseq_backend::__simd_or(__result, __last - __result, __pred); + } + } +} + +template +bool +__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_is_partitioned(__first, __last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + if (__first == __last) + { + return true; + } + else + { + return __except_handler([&]() { + // State of current range: + // broken - current range is not partitioned by pred + // all_true - all elements in current range satisfy pred + // all_false - all elements in current range don't satisfy pred + // true_false - elements satisfy pred are placed before elements that don't satisfy pred + enum _ReduceType + { + __not_init = -1, + __broken, + __all_true, + __all_false, + __true_false + }; + _ReduceType __init = __not_init; + + // Array with states that we'll have when state from the left branch is merged with state from the right branch. + // State is calculated by formula: new_state = table[left_state * 4 + right_state] + _ReduceType __table[] = {__broken, __broken, __broken, __broken, __broken, __all_true, + __true_false, __true_false, __broken, __broken, __all_false, __broken, + __broken, __broken, __true_false, __broken}; + + __init = __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, + [&__pred, &__table, __is_vector](_ForwardIterator __i, _ForwardIterator __j, + _ReduceType __value) -> _ReduceType { + if (__value == __broken) + { + return __broken; + } + _ReduceType __res = __not_init; + // if first element satisfy pred + if (__pred(*__i)) + { + // find first element that don't satisfy pred + _ForwardIterator __x = + __brick_find_if(__i + 1, __j, __not_pred<_UnaryPredicate>(__pred), __is_vector); + + if (__x != __j) + { + // find first element after "x" that satisfy pred + _ForwardIterator __y = __brick_find_if(__x + 1, __j, __pred, __is_vector); + // if it was found then range isn't partitioned by pred + if (__y != __j) + { + return __broken; + } + else + { + __res = __true_false; + } + } + else + { + __res = __all_true; + } + } + else + { // if first element doesn't satisfy pred + // then we should find the first element that satisfy pred. + // If we found it then range isn't partitioned by pred + if (__brick_find_if(__i + 1, __j, __pred, __is_vector) != __j) + { + return __broken; + } + else + { + __res = __all_false; + } + } + // if we have value from left range then we should calculate the result + return (__value == -1) ? __res : __table[__value * 4 + __res]; + }, + + [&__table](_ReduceType __val1, _ReduceType __val2) -> _ReduceType { + if (__val1 == __broken || __val2 == __broken) + { + return __broken; + } + // calculate the result for new big range + return __table[__val1 * 4 + __val2]; + }); + return __init != __broken; + }); + } +} +#endif + +//------------------------------------------------------------------------ +// partition +//------------------------------------------------------------------------ + +template +_ForwardIterator +__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::false_type) noexcept +{ + return std::partition(__first, __last, __pred); +} + +template +_ForwardIterator +__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /*is_vector=*/std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::partition(__first, __last, __pred); +} + +template +_ForwardIterator +__pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_partition(__first, __last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + + // partitioned range: elements before pivot satisfy pred (true part), + // elements after pivot don't satisfy pred (false part) + struct _PartitionRange + { + _ForwardIterator __begin; + _ForwardIterator __pivot; + _ForwardIterator __end; + }; + + return __except_handler([&]() { + _PartitionRange __init{__last, __last, __last}; + + // lambda for merging two partitioned ranges to one partitioned range + auto __reductor = [&__exec, __is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange { + auto __size1 = __val1.__end - __val1.__pivot; + auto __size2 = __val2.__pivot - __val2.__begin; + auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin); + + // if all elements in left range satisfy pred then we can move new pivot to pivot of right range + if (__val1.__end == __val1.__pivot) + { + return {__new_begin, __val2.__pivot, __val2.__end}; + } + // if true part of right range greater than false part of left range + // then we should swap the false part of left range and last part of true part of right range + else if (__size2 > __size1) + { + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size1, + [__val1, __val2, __size1, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { + __brick_swap_ranges(__i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), __is_vector); + }); + return {__new_begin, __val2.__pivot - __size1, __val2.__end}; + } + // else we should swap the first part of false part of left range and true part of right range + else + { + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size2, + [__val1, __val2, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { + __brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), __is_vector); + }); + return {__new_begin, __val1.__pivot + __size2, __val2.__end}; + } + }; + + _PartitionRange __result = __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, + [__pred, __is_vector, __reductor](_ForwardIterator __i, _ForwardIterator __j, + _PartitionRange __value) -> _PartitionRange { + //1. serial partition + _ForwardIterator __pivot = __brick_partition(__i, __j, __pred, __is_vector); + + // 2. merging of two ranges (left and right respectively) + return __reductor(__value, {__i, __pivot, __j}); + }, + __reductor); + return __result.__pivot; + }); +} +#endif + +//------------------------------------------------------------------------ +// stable_partition +//------------------------------------------------------------------------ + +template +_BidirectionalIterator +__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, + /*__is_vector=*/std::false_type) noexcept +{ + return std::stable_partition(__first, __last, __pred); +} + +template +_BidirectionalIterator +__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, + /*__is_vector=*/std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::stable_partition(__first, __last, __pred); +} + +template +_BidirectionalIterator +__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, + /*is_parallelization=*/std::false_type) noexcept +{ + return __brick_stable_partition(__first, __last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_BidirectionalIterator +__pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, + /*is_parallelization=*/std::true_type) noexcept +{ + // partitioned range: elements before pivot satisfy pred (true part), + // elements after pivot don't satisfy pred (false part) + struct _PartitionRange + { + _BidirectionalIterator __begin; + _BidirectionalIterator __pivot; + _BidirectionalIterator __end; + }; + + return __except_handler([&]() { + _PartitionRange __init{__last, __last, __last}; + + // lambda for merging two partitioned ranges to one partitioned range + auto __reductor = [__is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange { + auto __size1 = __val1.__end - __val1.__pivot; + auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin); + + // if all elements in left range satisfy pred then we can move new pivot to pivot of right range + if (__val1.__end == __val1.__pivot) + { + return {__new_begin, __val2.__pivot, __val2.__end}; + } + // if true part of right range greater than false part of left range + // then we should swap the false part of left range and last part of true part of right range + else + { + __brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, __is_vector); + return {__new_begin, __val2.__pivot - __size1, __val2.__end}; + } + }; + + _PartitionRange __result = __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, + [&__pred, __is_vector, __reductor](_BidirectionalIterator __i, _BidirectionalIterator __j, + _PartitionRange __value) -> _PartitionRange { + //1. serial stable_partition + _BidirectionalIterator __pivot = __brick_stable_partition(__i, __j, __pred, __is_vector); + + // 2. merging of two ranges (left and right respectively) + return __reductor(__value, {__i, __pivot, __j}); + }, + __reductor); + return __result.__pivot; + }); +} +#endif + +//------------------------------------------------------------------------ +// partition_copy +//------------------------------------------------------------------------ + +template +std::pair<_OutputIterator1, _OutputIterator2> +__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::false_type) noexcept +{ + return std::partition_copy(__first, __last, __out_true, __out_false, __pred); +} + +template +std::pair<_OutputIterator1, _OutputIterator2> +__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept +{ +#if (__PSTL_MONOTONIC_PRESENT) + return __unseq_backend::__simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred); +#else + return std::partition_copy(__first, __last, __out_true, __out_false, __pred); +#endif +} + +template +std::pair<_OutputIterator1, _OutputIterator2> +__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept +{ + return __brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +std::pair<_OutputIterator1, _OutputIterator2> +__pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallelization=*/std::true_type) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; + typedef std::pair<_DifferenceType, _DifferenceType> _ReturnType; + const _DifferenceType __n = __last - __first; + if (_DifferenceType(1) < __n) + { + __par_backend::__buffer __mask_buf(__n); + return __except_handler([&__exec, __n, __first, __out_true, __out_false, __is_vector, __pred, &__mask_buf]() { + bool* __mask = __mask_buf.get(); + _ReturnType __m{}; + __par_backend::parallel_strict_scan( + std::forward<_ExecutionPolicy>(__exec), __n, std::make_pair(_DifferenceType(0), _DifferenceType(0)), + [=](_DifferenceType __i, _DifferenceType __len) { // Reduce + return __brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, + __pred, __is_vector); + }, + [](const _ReturnType& __x, const _ReturnType& __y) -> _ReturnType { + return std::make_pair(__x.first + __y.first, __x.second + __y.second); + }, // Combine + [=](_DifferenceType __i, _DifferenceType __len, _ReturnType __initial) { // Scan + __brick_partition_by_mask(__first + __i, __first + (__i + __len), __out_true + __initial.first, + __out_false + __initial.second, __mask + __i, __is_vector); + }, + [&__m](_ReturnType __total) { __m = __total; }); + return std::make_pair(__out_true + __m.first, __out_false + __m.second); + }); + } + // trivial sequence - use serial algorithm + return __brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// sort +//------------------------------------------------------------------------ + +template +void +__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + _IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept +{ + std::sort(__first, __last, __comp); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type) +{ + __except_handler([&]() { + __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + [](_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) { std::sort(__first, __last, __comp); }, + __last - __first); + }); +} +#endif + +//------------------------------------------------------------------------ +// stable_sort +//------------------------------------------------------------------------ + +template +void +__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept +{ + std::stable_sort(__first, __last, __comp); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type) +{ + __except_handler([&]() { + __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + [](_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) { std::stable_sort(__first, __last, __comp); }); + }); +} +#endif + +//------------------------------------------------------------------------ +// partial_sort +//------------------------------------------------------------------------ + +template +void +__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept +{ + std::partial_sort(__first, __middle, __last, __comp); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type) +{ + const auto __n = __middle - __first; + __except_handler([&]() { + __par_backend::__parallel_stable_sort( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + [__n](_RandomAccessIterator __begin, _RandomAccessIterator __end, _Compare __comp) { + if (__n < __end - __begin) + std::partial_sort(__begin, __begin + __n, __end, __comp); + else + std::sort(__begin, __end, __comp); + }, + __n); + }); +} +#endif + +//------------------------------------------------------------------------ +// partial_sort_copy +//------------------------------------------------------------------------ + +template +_RandomAccessIterator +__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept +{ + return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, + _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + if (__last == __first || __d_last == __d_first) + { + return __d_first; + } + auto __n1 = __last - __first; + auto __n2 = __d_last - __d_first; + return __except_handler([&]() { + if (__n2 >= __n1) + { + __par_backend::__parallel_stable_sort( + std::forward<_ExecutionPolicy>(__exec), __d_first, __d_first + __n1, __comp, + [__first, __d_first, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j, + _Compare __comp) { + _ForwardIterator __i1 = __first + (__i - __d_first); + _ForwardIterator __j1 = __first + (__j - __d_first); + + // 1. Copy elements from input to output +#if !__PSTL_ICC_18_OMP_SIMD_BROKEN + __brick_copy(__i1, __j1, __i, __is_vector); +#else + std::copy(__i1, __j1, __i); +#endif + // 2. Sort elements in output sequence + std::sort(__i, __j, __comp); + }, + __n1); + return __d_first + __n1; + } + else + { + typedef typename std::iterator_traits<_ForwardIterator>::value_type _T1; + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _T2; + __par_backend::__buffer<_T1> __buf(__n1); + _T1* __r = __buf.get(); + + __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n1, __comp, + [__n2, __first, __r](_T1* __i, _T1* __j, _Compare __comp) { + _ForwardIterator __it = __first + (__i - __r); + + // 1. Copy elements from input to raw memory + for (_T1* __k = __i; __k != __j; ++__k, ++__it) + { + ::new (__k) _T2(*__it); + } + + // 2. Sort elements in temporary __buffer + if (__n2 < __j - __i) + std::partial_sort(__i, __i + __n2, __j, __comp); + else + std::sort(__i, __j, __comp); + }, + __n2); + + // 3. Move elements from temporary __buffer to output + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2, + [__r, __d_first, __is_vector](_T1* __i, _T1* __j) { + __brick_move(__i, __j, __d_first + (__i - __r), __is_vector); + }); + return __d_first + __n2; + } + }); +} +#endif + +//------------------------------------------------------------------------ +// adjacent_find +//------------------------------------------------------------------------ +template +_ForwardIterator +__brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /* IsVector = */ std::true_type, bool __or_semantic) noexcept +{ + return __unseq_backend::__simd_adjacent_find(__first, __last, __pred, __or_semantic); +} + +template +_ForwardIterator +__brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /* IsVector = */ std::false_type, bool __or_semantic) noexcept +{ + return std::adjacent_find(__first, __last, __pred); +} + +template +_ForwardIterator +__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, + /* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept +{ + return __brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector, + bool __or_semantic) +{ + if (__last - __first < 2) + return __last; + + return __except_handler([&]() { + return __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __last, + [__last, __pred, __is_vector, __or_semantic](_RandomAccessIterator __begin, _RandomAccessIterator __end, + _RandomAccessIterator __value) -> _RandomAccessIterator { + // TODO: investigate performance benefits from the use of shared variable for the result, + // checking (compare_and_swap idiom) its __value at __first. + if (__or_semantic && __value < __last) + { //found + __par_backend::__cancel_execution(); + return __value; + } + + if (__value > __begin) + { + // modify __end to check the predicate on the boundary __values; + // TODO: to use a custom range with boundaries overlapping + // TODO: investigate what if we remove "if" below and run algorithm on range [__first, __last-1) + // then check the pair [__last-1, __last) + if (__end != __last) + ++__end; + + //correct the global result iterator if the "brick" returns a local "__last" + const _RandomAccessIterator __res = + __brick_adjacent_find(__begin, __end, __pred, __is_vector, __or_semantic); + if (__res < __end) + __value = __res; + } + return __value; + }, + [](_RandomAccessIterator __x, _RandomAccessIterator __y) -> _RandomAccessIterator { + return __x < __y ? __x : __y; + } //reduce a __value + ); + }); +} +#endif + +//------------------------------------------------------------------------ +// nth_element +//------------------------------------------------------------------------ + +template +void +__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept +{ + std::nth_element(__first, __nth, __last, __comp); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, + /*is_parallel=*/std::true_type) noexcept +{ + if (__first == __last || __nth == __last) + { + return; + } + + using std::iter_swap; + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _Tp; + _RandomAccessIterator __x; + do + { + __x = __pattern_partition(std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, + [&__comp, __first](const _Tp& __x) { return __comp(__x, *__first); }, __is_vector, + /*is_parallel=*/std::true_type()); + --__x; + if (__x != __first) + { + iter_swap(__first, __x); + } + // if x > nth then our new range for partition is [first, x) + if (__x - __nth > 0) + { + __last = __x; + } + // if x < nth then our new range for partition is [x, last) + else if (__x - __nth < 0) + { + // if *x == *nth then we can start new partition with x+1 + if (!__comp(*__nth, *__x) && !__comp(*__x, *__nth)) + { + ++__x; + } + else + { + iter_swap(__nth, __x); + } + __first = __x; + } + } while (__x != __nth); +} +#endif + +//------------------------------------------------------------------------ +// fill, fill_n +//------------------------------------------------------------------------ +template +void +__brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /* __is_vector = */ std::true_type) noexcept +{ + __unseq_backend::__simd_fill_n(__first, __last - __first, __value); +} + +template +void +__brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /* __is_vector = */ std::false_type) noexcept +{ + std::fill(__first, __last, __value); +} + +template +void +__pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +{ + __brick_fill(__first, __last, __value, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, + /*is_parallel=*/std::true_type, _IsVector __is_vector) +{ + return __except_handler([&__exec, __first, __last, &__value, __is_vector]() { + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { + __brick_fill(__begin, __end, __value, __is_vector); + }); + return __last; + }); +} +#endif + +template +_OutputIterator +__brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::true_type) noexcept +{ + return __unseq_backend::__simd_fill_n(__first, __count, __value); +} + +template +_OutputIterator +__brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::false_type) noexcept +{ + return std::fill_n(__first, __count, __value); +} + +template +_OutputIterator +__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, const _Tp& __value, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +{ + return __brick_fill_n(__first, __count, __value, __is_vector); +} + +template +_OutputIterator +__pattern_fill_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, const _Tp& __value, + /*is_parallel=*/std::true_type, _IsVector __is_vector) +{ + return __pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __value, std::true_type(), + __is_vector); +} + +//------------------------------------------------------------------------ +// generate, generate_n +//------------------------------------------------------------------------ +template +void +__brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g, + /* is_vector = */ std::true_type) noexcept +{ + __unseq_backend::__simd_generate_n(__first, __last - __first, __g); +} + +template +void +__brick_generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __g, + /* is_vector = */ std::false_type) noexcept +{ + std::generate(__first, __last, __g); +} + +template +void +__pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +{ + __brick_generate(__first, __last, __g, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, + /*is_parallel=*/std::true_type, _IsVector __is_vector) +{ + return __except_handler([&]() { + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { + __brick_generate(__begin, __end, __g, __is_vector); + }); + return __last; + }); +} +#endif + +template +OutputIterator +__brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept +{ + return __unseq_backend::__simd_generate_n(__first, __count, __g); +} + +template +OutputIterator +__brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept +{ + return std::generate_n(__first, __count, __g); +} + +template +_OutputIterator +__pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g, + /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept +{ + return __brick_generate_n(__first, __count, __g, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g, + /*is_parallel=*/std::true_type, _IsVector __is_vector) +{ + static_assert(__is_random_access_iterator<_OutputIterator>::value, + "Pattern-brick error. Should be a random access iterator."); + return __pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g, std::true_type(), + __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// remove +//------------------------------------------------------------------------ + +template +_ForwardIterator +__brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + /* __is_vector = */ std::false_type) noexcept +{ + return std::remove_if(__first, __last, __pred); +} + +template +_RandomAccessIterator +__brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred, + /* __is_vector = */ std::true_type) noexcept +{ +#if __PSTL_MONOTONIC_PRESENT + return __unseq_backend::__simd_remove_if(__first, __last - __first, __pred); +#else + return std::remove_if(__first, __last, __pred); +#endif +} + +template +_ForwardIterator +__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + _IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept +{ + return __brick_remove_if(__first, __last, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator +__pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept +{ + typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; + + if (__first == __last || __first + 1 == __last) + { + // Trivial sequence - use serial algorithm + return __brick_remove_if(__first, __last, __pred, __is_vector); + } + + return remove_elements(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) { + __brick_walk2(__b, __e, __it, + [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, + __is_vector); + }, + __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// merge +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept +{ + return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp); +} + +template +_OutputIterator +__brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp); +} + +template +_OutputIterator +__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector, + /* is_parallel = */ std::false_type) noexcept +{ + return __brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) +{ + __par_backend::__parallel_merge( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp, + [__is_vector](_RandomAccessIterator1 __f1, _RandomAccessIterator1 __l1, _RandomAccessIterator2 __f2, + _RandomAccessIterator2 __l2, _OutputIterator __f3, + _Compare __comp) { return __brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); }); + return __d_first + (__last1 - __first1) + (__last2 - __first2); +} +#endif + +//------------------------------------------------------------------------ +// inplace_merge +//------------------------------------------------------------------------ +template +void +__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, + _Compare __comp, /* __is_vector = */ std::false_type) noexcept +{ + std::inplace_merge(__first, __middle, __last, __comp); +} + +template +void +__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, + _Compare __comp, /* __is_vector = */ std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial") + std::inplace_merge(__first, __middle, __last, __comp); +} + +template +void +__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, + /* is_parallel = */ std::false_type) noexcept +{ + __brick_inplace_merge(__first, __middle, __last, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +void +__pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + if (__first == __last || __first == __middle || __middle == __last) + { + return; + } + typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _Tp; + auto __n = __last - __first; + __par_backend::__buffer<_Tp> __buf(__n); + _Tp* __r = __buf.get(); + __except_handler([&]() { + auto __move_values = [](_BidirectionalIterator __x, _Tp* __z) { + __invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); }, + [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); }); + }; + + auto __move_sequences = [](_BidirectionalIterator __first1, _BidirectionalIterator __last1, _Tp* __first2) { + return __brick_uninitialized_move(__first1, __last1, __first2, _IsVector()); + }; + + __par_backend::__parallel_merge( + std::forward<_ExecutionPolicy>(__exec), __first, __middle, __middle, __last, __r, __comp, + [__n, __move_values, __move_sequences](_BidirectionalIterator __f1, _BidirectionalIterator __l1, + _BidirectionalIterator __f2, _BidirectionalIterator __l2, _Tp* __f3, + _Compare __comp) { + auto __func = __par_backend::__serial_move_merge( + __n, __move_values, __move_sequences); + __func(__f1, __l1, __f2, __l2, __f3, __comp); + return __f3 + (__l1 - __f1) + (__l2 - __f2); + }); + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n, + [__r, __first, __is_vector](_Tp* __i, _Tp* __j) { + __brick_move(__i, __j, __first + (__i - __r), __is_vector); + }); + }); +} +#endif + +//------------------------------------------------------------------------ +// includes +//------------------------------------------------------------------------ + +template +bool +__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector, + /*is_parallel=*/std::false_type) noexcept +{ + return std::includes(__first1, __last1, __first2, __last2, __comp); +} + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + if (__first2 >= __last2) + return true; + + if (__first1 >= __last1 || __comp(*__first2, *__first1) || __comp(*(__last1 - 1), *(__last2 - 1))) + return false; + + __first1 = std::lower_bound(__first1, __last1, *__first2, __comp); + if (__first1 == __last1) + return false; + + if (__last2 - __first2 == 1) + return !__comp(*__first1, *__first2) && !__comp(*__first2, *__first1); + + return __except_handler([&]() { + return !__parallel_or( + std::forward<_ExecutionPolicy>(__exec), __first2, __last2, + [__first1, __last1, __first2, __last2, &__comp](_ForwardIterator2 __i, _ForwardIterator2 __j) { + assert(__j > __i); + //assert(__j - __i > 1); + + //1. moving boundaries to "consume" subsequence of equal elements + auto __is_equal = [&__comp](_ForwardIterator2 __a, _ForwardIterator2 __b) -> bool { + return !__comp(*__a, *__b) && !__comp(*__b, *__a); + }; + + //1.1 left bound, case "aaa[aaaxyz...]" - searching "x" + if (__i > __first2 && __is_equal(__i, __i - 1)) + { + //whole subrange continues to content equal elements - return "no op" + if (__is_equal(__i, __j - 1)) + return false; + + __i = std::upper_bound(__i, __last2, *__i, __comp); + } + + //1.2 right bound, case "[...aaa]aaaxyz" - searching "x" + if (__j < __last2 && __is_equal(__j - 1, __j)) + __j = std::upper_bound(__j, __last2, *__j, __comp); + + //2. testing is __a subsequence of the second range included into the first range + auto __b = std::lower_bound(__first1, __last1, *__i, __comp); + + assert(!__comp(*(__last1 - 1), *__b)); + assert(!__comp(*(__j - 1), *__i)); + return !std::includes(__b, __last1, __i, __j, __comp); + }); + }); +} +#endif + +constexpr auto __set_algo_cut_off = 1000; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + _SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector) +{ + typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; + typedef typename std::iterator_traits<_OutputIterator>::value_type _T; + + struct _SetRange + { + _DifferenceType __pos, __len, __buf_pos; + bool + empty() const + { + return __len == 0; + } + }; + + const _DifferenceType __n1 = __last1 - __first1; + const _DifferenceType __n2 = __last2 - __first2; + + __par_backend::__buffer<_T> __buf(__size_func(__n1, __n2)); + + return __except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector, __comp, + __size_func, __set_op, &__buf]() { + auto __buffer = __buf.get(); + _DifferenceType __m{}; + auto __scan = [=](_DifferenceType, _DifferenceType, const _SetRange& __s) { // Scan + if (!__s.empty()) + __brick_move(__buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos, + __is_vector); + }; + __par_backend::parallel_strict_scan( + std::forward<_ExecutionPolicy>(__exec), __n1, _SetRange{0, 0, 0}, //-1, 0}, + [=](_DifferenceType __i, _DifferenceType __len) { // Reduce + //[__b; __e) - a subrange of the first sequence, to reduce + _ForwardIterator1 __b = __first1 + __i, __e = __first1 + (__i + __len); + + //try searching for the first element which not equal to *__b + if (__b != __first1) + __b = std::upper_bound(__b, __last1, *__b, __comp); + + //try searching for the first element which not equal to *__e + if (__e != __last1) + __e = std::upper_bound(__e, __last1, *__e, __comp); + + //check is [__b; __e) empty + if (__e - __b < 1) + { + _ForwardIterator2 __bb = __last2; + if (__b != __last1) + __bb = std::lower_bound(__first2, __last2, *__b, __comp); + + const _DifferenceType __buf_pos = __size_func((__b - __first1), (__bb - __first2)); + return _SetRange{0, 0, __buf_pos}; + } + + //try searching for "corresponding" subrange [__bb; __ee) in the second sequence + _ForwardIterator2 __bb = __first2; + if (__b != __first1) + __bb = std::lower_bound(__first2, __last2, *__b, __comp); + + _ForwardIterator2 __ee = __last2; + if (__e != __last1) + __ee = std::lower_bound(__bb, __last2, *__e, __comp); + + const _DifferenceType __buf_pos = __size_func((__b - __first1), (__bb - __first2)); + auto __buffer_b = __buffer + __buf_pos; + auto __res = __set_op(__b, __e, __bb, __ee, __buffer_b, __comp); + + return _SetRange{0, __res - __buffer_b, __buf_pos}; + }, + [](const _SetRange& __a, const _SetRange& __b) { // Combine + if (__b.__buf_pos > __a.__buf_pos || ((__b.__buf_pos == __a.__buf_pos) && !__b.empty())) + return _SetRange{__a.__pos + __a.__len + __b.__pos, __b.__len, __b.__buf_pos}; + return _SetRange{__b.__pos + __b.__len + __a.__pos, __a.__len, __a.__buf_pos}; + }, + __scan, // Scan + [&__m, &__scan](const _SetRange& __total) { // Apex + //final scan + __scan(0, 0, __total); + __m = __total.__pos + __total.__len; + }); + return __result + __m; + }); +} +#endif + +#if __PSTL_USE_PAR_POLICIES +//a shared parallel pattern for '__pattern_set_union' and '__pattern_set_symmetric_difference' +template +_OutputIterator +__parallel_set_union_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + _SetUnionOp __set_union_op, _IsVector __is_vector) +{ + typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; + + const auto __n1 = __last1 - __first1; + const auto __n2 = __last2 - __first2; + + auto copy_range1 = [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { + return __brick_copy(__begin, __end, __res, __is_vector); + }; + auto copy_range2 = [__is_vector](_ForwardIterator2 __begin, _ForwardIterator2 __end, _OutputIterator __res) { + return __brick_copy(__begin, __end, __res, __is_vector); + }; + + // {1} {}: parallel copying just first sequence + if (__n2 == 0) + return __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1, + std::true_type()); + + // {} {2}: parallel copying justmake second sequence + if (__n1 == 0) + return __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2, + std::true_type()); + + // testing whether the sequences are intersected + _ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp); + + if (__left_bound_seq_1 == __last1) + { + //{1} < {2}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2 + __par_backend::__parallel_invoke(std::forward<_ExecutionPolicy>(__exec), + [=] { + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, + __last1, __result, copy_range1, std::true_type()); + }, + [=] { + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, + __last2, __result + __n1, copy_range2, + std::true_type()); + }); + return __result + __n1 + __n2; + } + + // testing whether the sequences are intersected + _ForwardIterator2 __left_bound_seq_2 = lower_bound(__first2, __last2, *__first1, __comp); + + if (__left_bound_seq_2 == __last2) + { + //{2} < {1}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2 + __par_backend::__parallel_invoke(std::forward<_ExecutionPolicy>(__exec), + [=] { + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, + __last2, __result, copy_range2, std::true_type()); + }, + [=] { + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, + __last1, __result + __n2, copy_range1, + std::true_type()); + }); + return __result + __n1 + __n2; + } + + const auto __m1 = __left_bound_seq_1 - __first1; + if (__m1 > __set_algo_cut_off) + { + auto __res_or = __result; + __result += __m1; //we know proper offset due to [first1; left_bound_seq_1) < [first2; last2) + __par_backend::__parallel_invoke( + std::forward<_ExecutionPolicy>(__exec), + //do parallel copying of [first1; left_bound_seq_1) + [=] { + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or, + copy_range1, std::true_type()); + }, + [=, &__result] { + __result = __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, + __first2, __last2, __result, __comp, + [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, + __set_union_op, __is_vector); + }); + return __result; + } + + const auto __m2 = __left_bound_seq_2 - __first2; + assert(__m1 == 0 || __m2 == 0); + if (__m2 > __set_algo_cut_off) + { + auto __res_or = __result; + __result += __m2; //we know proper offset due to [first2; left_bound_seq_2) < [first1; last1) + __par_backend::__parallel_invoke( + std::forward<_ExecutionPolicy>(__exec), + //do parallel copying of [first2; left_bound_seq_2) + [=] { + __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or, + copy_range2, std::true_type()); + }, + [=, &__result] { + __result = __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, + __left_bound_seq_2, __last2, __result, __comp, + [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, + __set_union_op, __is_vector); + }); + return __result; + } + + return __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, + __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op, + __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// set_union +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept +{ + return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + _IsVector __is_vector, /*__is_parallel=*/std::true_type) +{ + + const auto __n1 = __last1 - __first1; + const auto __n2 = __last2 - __first2; + + // use serial algorithm + if (__n1 + __n2 <= __set_algo_cut_off) + return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); + + typedef typename std::iterator_traits<_OutputIterator>::value_type _T; + return __parallel_set_union_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, + __comp, + [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _T* __result, _Compare __comp) { + return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); + }, + __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// set_intersection +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept +{ + return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + typedef typename std::iterator_traits<_OutputIterator>::value_type _T; + typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; + + const auto __n1 = __last1 - __first1; + const auto __n2 = __last2 - __first2; + + // intersection is empty + if (__n1 == 0 || __n2 == 0) + return __result; + + // testing whether the sequences are intersected + _ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp); + //{1} < {2}: seq 2 is wholly greater than seq 1, so, the intersection is empty + if (__left_bound_seq_1 == __last1) + return __result; + + // testing whether the sequences are intersected + _ForwardIterator2 __left_bound_seq_2 = lower_bound(__first2, __last2, *__first1, __comp); + //{2} < {1}: seq 1 is wholly greater than seq 2, so, the intersection is empty + if (__left_bound_seq_2 == __last2) + return __result; + + const auto __m1 = __last1 - __left_bound_seq_1 + __n2; + if (__m1 > __set_algo_cut_off) + { + //we know proper offset due to [first1; left_bound_seq_1) < [first2; last2) + return __parallel_set_op( + std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2, __result, __comp, + [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); }, + [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _T* __result, _Compare __comp) { + return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); + }, + __is_vector); + } + + const auto __m2 = __last2 - __left_bound_seq_2 + __n1; + if (__m2 > __set_algo_cut_off) + { + //we know proper offset due to [first2; left_bound_seq_2) < [first1; last1) + __result = __parallel_set_op( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __left_bound_seq_2, __last2, __result, __comp, + [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); }, + [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _T* __result, _Compare __comp) { + return std::set_intersection(__first2, __last2, __first1, __last1, __result, __comp); + }, + __is_vector); + return __result; + } + + // [left_bound_seq_1; last1) and [left_bound_seq_2; last2) - use serial algorithm + return std::set_intersection(__left_bound_seq_1, __last1, __left_bound_seq_2, __last2, __result, __comp); +} +#endif + +//------------------------------------------------------------------------ +// set_difference +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept +{ + return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + typedef typename std::iterator_traits<_OutputIterator>::value_type _T; + typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; + + const auto __n1 = __last1 - __first1; + const auto __n2 = __last2 - __first2; + + // {} \ {2}: the difference is empty + if (__n1 == 0) + return __result; + + // {1} \ {}: parallel copying just first sequence + if (__n2 == 0) + return __pattern_walk2_brick( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, + [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { + return __brick_copy(__begin, __end, __res, __is_vector); + }, + std::true_type()); + + // testing whether the sequences are intersected + _ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp); + //{1} < {2}: seq 2 is wholly greater than seq 1, so, parallel copying just first sequence + if (__left_bound_seq_1 == __last1) + return __pattern_walk2_brick( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, + [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { + return __brick_copy(__begin, __end, __res, __is_vector); + }, + std::true_type()); + + // testing whether the sequences are intersected + _ForwardIterator2 __left_bound_seq_2 = lower_bound(__first2, __last2, *__first1, __comp); + //{2} < {1}: seq 1 is wholly greater than seq 2, so, parallel copying just first sequence + if (__left_bound_seq_2 == __last2) + return __pattern_walk2_brick( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, + [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { + return __brick_copy(__begin, __end, __res, __is_vector); + }, + std::true_type()); + + if (__n1 + __n2 > __set_algo_cut_off) + return __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, + __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n; }, + [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _T* __result, _Compare __comp) { + return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); + }, + __is_vector); + + // use serial algorithm + return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); +} +#endif + +//------------------------------------------------------------------------ +// set_symmetric_difference +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::false_type) noexcept +{ + return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, + /*__is_vector=*/std::true_type) noexcept +{ + __PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial"); + return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); +} + +template +_OutputIterator +__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, + _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + + const auto __n1 = __last1 - __first1; + const auto __n2 = __last2 - __first2; + + // use serial algorithm + if (__n1 + __n2 <= __set_algo_cut_off) + return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); + + typedef typename std::iterator_traits<_OutputIterator>::value_type _T; + return __parallel_set_union_op( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, + [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _T* __result, _Compare __comp) { + return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); + }, + __is_vector); +} +#endif + +//------------------------------------------------------------------------ +// is_heap_until +//------------------------------------------------------------------------ + +template +_RandomAccessIterator +__brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept +{ + return std::is_heap_until(__first, __last, __comp); +} + +template +_RandomAccessIterator +__brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept +{ + if (__last - __first < 2) + return __last; + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType; + return __unseq_backend::__simd_first( + __first, _SizeType(0), __last - __first, + [&__comp](_RandomAccessIterator __it, _SizeType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); }); +} + +template +_RandomAccessIterator +__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +{ + return __brick_is_heap_until(__first, __last, __comp, __is_vector); +} + +template +_RandomAccessIterator +__is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept +{ + _DifferenceType __i = __begin; + for (; __i < __end; ++__i) + { + if (__comp(__first[(__i - 1) / 2], __first[__i])) + { + break; + } + } + return __first + __i; +} + +template +_RandomAccessIterator +__is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept +{ + return __unseq_backend::__simd_first( + __first, __begin, __end, + [&__comp](_RandomAccessIterator __it, _DifferenceType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); }); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept +{ + if (__last - __first < 2) + return __last; + + return __except_handler([&]() { + return __parallel_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__first, __comp, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) { + return __is_heap_until_local(__first, __i - __first, __j - __first, __comp, __is_vector); + }, + std::less::difference_type>(), /*is_first=*/true); + }); +} +#endif + +//------------------------------------------------------------------------ +// min_element +//------------------------------------------------------------------------ + +template +_ForwardIterator +__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept +{ + return std::min_element(__first, __last, __comp); +} + +template +_ForwardIterator +__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept +{ +#if __PSTL_UDR_PRESENT + return __unseq_backend::__simd_min_element(__first, __last - __first, __comp); +#else + return std::min_element(__first, __last, __comp); +#endif +} + +template +_ForwardIterator +__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +{ + return __brick_min_element(__first, __last, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_RandomAccessIterator +__pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) +{ + if (__first == __last) + return __last; + + return __except_handler([&]() { + return __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, __first, + [=](_RandomAccessIterator __begin, _RandomAccessIterator __end, + _RandomAccessIterator __init) -> _RandomAccessIterator { + const _RandomAccessIterator subresult = __brick_min_element(__begin, __end, __comp, __is_vector); + return __cmp_iterators_by_values(__init, subresult, __comp); + }, + [=](_RandomAccessIterator __it1, _RandomAccessIterator __it2) -> _RandomAccessIterator { + return __cmp_iterators_by_values(__it1, __it2, __comp); + }); + }); +} +#endif + +//------------------------------------------------------------------------ +// minmax_element +//------------------------------------------------------------------------ + +template +std::pair<_ForwardIterator, _ForwardIterator> +__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept +{ + return std::minmax_element(__first, __last, __comp); +} + +template +std::pair<_ForwardIterator, _ForwardIterator> +__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + /* __is_vector = */ std::true_type) noexcept +{ +#if __PSTL_UDR_PRESENT + return __unseq_backend::__simd_minmax_element(__first, __last - __first, __comp); +#else + return std::minmax_element(__first, __last, __comp); +#endif +} + +template +std::pair<_ForwardIterator, _ForwardIterator> +__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +{ + return __brick_minmax_element(__first, __last, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +std::pair<_ForwardIterator, _ForwardIterator> +__pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::true_type) +{ + if (__first == __last) + return std::make_pair(__first, __first); + + return __except_handler([&]() { + typedef std::pair<_ForwardIterator, _ForwardIterator> _Result; + + return __par_backend::__parallel_reduce( + std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, std::make_pair(__first, __first), + [=](_ForwardIterator __begin, _ForwardIterator __end, _Result __init) -> _Result { + const _Result __subresult = __brick_minmax_element(__begin, __end, __comp, __is_vector); + return std::make_pair( + __cmp_iterators_by_values(__subresult.first, __init.first, __comp), + __cmp_iterators_by_values(__init.second, __subresult.second, __not_pred<_Compare>(__comp))); + }, + [=](_Result __p1, _Result __p2) -> _Result { + return std::make_pair( + __cmp_iterators_by_values(__p1.first, __p2.first, __comp), + __cmp_iterators_by_values(__p2.second, __p1.second, __not_pred<_Compare>(__comp))); + }); + }); +} +#endif + +//------------------------------------------------------------------------ +// mismatch +//------------------------------------------------------------------------ +template +std::pair<_ForwardIterator1, _ForwardIterator2> +__mismatch_serial(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _BinaryPredicate __pred) +{ +#if __PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT + return std::mismatch(__first1, __last1, __first2, __last2, __pred); +#else + for (; __first1 != __last1 && __first2 != __last2 && __pred(*__first1, *__first2); ++__first1, ++__first2) + { + } + return std::make_pair(__first1, __first2); +#endif +} + +template +std::pair<_ForwardIterator1, _ForwardIterator2> +__brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::false_type) noexcept +{ + return __mismatch_serial(__first1, __last1, __first2, __last2, __pred); +} + +template +std::pair<_ForwardIterator1, _ForwardIterator2> +__brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::true_type) noexcept +{ + auto __n = std::min(__last1 - __first1, __last2 - __first2); + return __unseq_backend::__simd_first(__first1, __n, __first2, __not_pred<_Predicate>(__pred)); +} + +template +std::pair<_ForwardIterator1, _ForwardIterator2> +__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector, + /* is_parallel = */ std::false_type) noexcept +{ + return __brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +std::pair<_RandomAccessIterator1, _RandomAccessIterator2> +__pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred, + _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept +{ + return __except_handler([&]() { + auto __n = std::min(__last1 - __first1, __last2 - __first2); + auto __result = __parallel_find( + std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, + [__first1, __first2, __pred, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { + return __brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), __pred, + __is_vector) + .first; + }, + std::less::difference_type>(), /*is_first=*/true); + return std::make_pair(__result, __first2 + (__result - __first1)); + }); +} +#endif + +//------------------------------------------------------------------------ +// lexicographical_compare +//------------------------------------------------------------------------ + +template +bool +__brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Compare __comp, + /* __is_vector = */ std::false_type) noexcept +{ + return std::lexicographical_compare(__first1, __last1, __first2, __last2, __comp); +} + +template +bool +__brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Compare __comp, /* __is_vector = */ std::true_type) noexcept +{ + if (__first2 == __last2) + { // if second sequence is empty + return false; + } + else if (__first1 == __last1) + { // if first sequence is empty + return true; + } + else + { + typedef typename std::iterator_traits<_ForwardIterator1>::reference ref_type1; + typedef typename std::iterator_traits<_ForwardIterator2>::reference ref_type2; + --__last1; + --__last2; + auto __n = std::min(__last1 - __first1, __last2 - __first2); + std::pair<_ForwardIterator1, _ForwardIterator2> __result = __unseq_backend::__simd_first( + __first1, __n, __first2, [__comp](const ref_type1 __x, const ref_type2 __y) mutable { + return __comp(__x, __y) || __comp(__y, __x); + }); + + if (__result.first == __last1 && __result.second != __last2) + { // if first sequence shorter than second + return !__comp(*__result.second, *__result.first); + } + else + { // if second sequence shorter than first or both have the same number of elements + return __comp(*__result.first, *__result.second); + } + } +} + +template +bool +__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept +{ + return __brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +bool +__pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, + _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept +{ + if (__first2 == __last2) + { // if second sequence is empty + return false; + } + else if (__first1 == __last1) + { // if first sequence is empty + return true; + } + else + { + typedef typename std::iterator_traits<_ForwardIterator1>::reference _RefType1; + typedef typename std::iterator_traits<_ForwardIterator2>::reference _RefType2; + --__last1; + --__last2; + auto __n = std::min(__last1 - __first1, __last2 - __first2); + auto __result = __parallel_find( + std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, + [__first1, __first2, &__comp, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { + return __brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), + [&__comp](const _RefType1 __x, const _RefType2 __y) { + return !__comp(__x, __y) && !__comp(__y, __x); + }, + __is_vector) + .first; + }, + std::less::difference_type>(), /*is_first=*/true); + + if (__result == __last1 && __first2 + (__result - __first1) != __last2) + { // if first sequence shorter than second + return !__comp(*(__first2 + (__result - __first1)), *__result); + } + else + { // if second sequence shorter than first or both have the same number of elements + return __comp(*__result, *(__first2 + (__result - __first1))); + } + } +} +#endif + +} // namespace __internal +} // namespace __pstl + +#endif /* __PSTL_algorithm_impl_H */ diff --git a/libstdc++-v3/include/pstl/execution_defs.h b/libstdc++-v3/include/pstl/execution_defs.h new file mode 100644 index 0000000..be8a4a3 --- /dev/null +++ b/libstdc++-v3/include/pstl/execution_defs.h @@ -0,0 +1,162 @@ +// -*- C++ -*- +//===-- execution_defs.h --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_execution_policy_defs_H +#define __PSTL_execution_policy_defs_H + +#include + +namespace __pstl +{ +namespace execution +{ +inline namespace v1 +{ + +// 2.4, Sequential execution policy +class sequenced_policy +{ + public: + // For internal use only + static constexpr std::false_type + __allow_unsequenced() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_vector() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_parallel() + { + return std::false_type{}; + } +}; + +#if __PSTL_USE_PAR_POLICIES +// 2.5, Parallel execution policy +class parallel_policy +{ + public: + // For internal use only + static constexpr std::false_type + __allow_unsequenced() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_vector() + { + return std::false_type{}; + } + static constexpr std::true_type + __allow_parallel() + { + return std::true_type{}; + } +}; + +// 2.6, Parallel+Vector execution policy +class parallel_unsequenced_policy +{ + public: + // For internal use only + static constexpr std::true_type + __allow_unsequenced() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_vector() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_parallel() + { + return std::true_type{}; + } +}; +#endif + +class unsequenced_policy +{ + public: + // For internal use only + static constexpr std::true_type + __allow_unsequenced() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_vector() + { + return std::true_type{}; + } + static constexpr std::false_type + __allow_parallel() + { + return std::false_type{}; + } +}; + +// 2.8, Execution policy objects +constexpr sequenced_policy seq{}; +#if __PSTL_USE_PAR_POLICIES +constexpr parallel_policy par{}; +constexpr parallel_unsequenced_policy par_unseq{}; +#endif +constexpr unsequenced_policy unseq{}; + +// 2.3, Execution policy type trait +template +struct is_execution_policy : std::false_type +{ +}; + +template <> +struct is_execution_policy : std::true_type +{ +}; +#if __PSTL_USE_PAR_POLICIES +template <> +struct is_execution_policy : std::true_type +{ +}; +template <> +struct is_execution_policy : std::true_type +{ +}; +#endif +template <> +struct is_execution_policy : std::true_type +{ +}; + +#if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT +template +constexpr bool is_execution_policy_v = is_execution_policy::value; +#endif + +} // namespace v1 +} // namespace execution + +namespace __internal +{ +template +using __enable_if_execution_policy = + typename std::enable_if<__pstl::execution::is_execution_policy::type>::value, + T>::type; +} // namespace __internal + +} // namespace __pstl + +#endif /* __PSTL_execution_policy_defs_H */ diff --git a/libstdc++-v3/include/pstl/execution_impl.h b/libstdc++-v3/include/pstl/execution_impl.h new file mode 100644 index 0000000..f33e6fc --- /dev/null +++ b/libstdc++-v3/include/pstl/execution_impl.h @@ -0,0 +1,155 @@ +// -*- C++ -*- +//===-- execution_impl.h --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_execution_impl_H +#define __PSTL_execution_impl_H + +#include +#include + +#include "execution_defs.h" + +namespace __pstl +{ +namespace __internal +{ + +using namespace __pstl::execution; + +/* predicate */ + +template +std::false_type __lazy_and(_Tp, std::false_type) +{ + return std::false_type{}; +}; + +template +inline _Tp +__lazy_and(_Tp __a, std::true_type) +{ + return __a; +} + +template +std::true_type __lazy_or(_Tp, std::true_type) +{ + return std::true_type{}; +}; + +template +inline _Tp +__lazy_or(_Tp __a, std::false_type) +{ + return __a; +} + +/* iterator */ +template +struct __is_random_access_iterator +{ + static constexpr bool value = + __is_random_access_iterator<_IteratorType>::value && __is_random_access_iterator<_OtherIteratorTypes...>::value; + typedef std::integral_constant type; +}; + +template +struct __is_random_access_iterator<_IteratorType> + : std::is_same::iterator_category, std::random_access_iterator_tag> +{ +}; + +/* policy */ +template +struct __policy_traits +{ +}; + +template <> +struct __policy_traits +{ + typedef std::false_type allow_parallel; + typedef std::false_type allow_unsequenced; + typedef std::false_type allow_vector; +}; + +template <> +struct __policy_traits +{ + typedef std::false_type allow_parallel; + typedef std::true_type allow_unsequenced; + typedef std::true_type allow_vector; +}; + +#if __PSTL_USE_PAR_POLICIES +template <> +struct __policy_traits +{ + typedef std::true_type allow_parallel; + typedef std::false_type allow_unsequenced; + typedef std::false_type allow_vector; +}; + +template <> +struct __policy_traits +{ + typedef std::true_type allow_parallel; + typedef std::true_type allow_unsequenced; + typedef std::true_type allow_vector; +}; +#endif + +template +using __collector_t = typename __policy_traits::type>::__collector_type; + +template +using __allow_vector = typename __policy_traits::type>::__allow_vector; + +template +using __allow_unsequenced = typename __policy_traits::type>::__allow_unsequenced; + +template +using __allow_parallel = typename __policy_traits::type>::__allow_parallel; + +template +auto +__is_vectorization_preferred(_ExecutionPolicy&& __exec) + -> decltype(__lazy_and(__exec.__allow_vector(), typename __is_random_access_iterator<_IteratorTypes...>::type())) +{ + return __lazy_and(__exec.__allow_vector(), typename __is_random_access_iterator<_IteratorTypes...>::type()); +} + +template +auto +__is_parallelization_preferred(_ExecutionPolicy&& __exec) + -> decltype(__lazy_and(__exec.__allow_parallel(), typename __is_random_access_iterator<_IteratorTypes...>::type())) +{ + return __lazy_and(__exec.__allow_parallel(), typename __is_random_access_iterator<_IteratorTypes...>::type()); +} + +template +struct __prefer_unsequenced_tag +{ + static constexpr bool value = + __allow_unsequenced::value && __is_random_access_iterator<_IteratorTypes...>::value; + typedef std::integral_constant type; +}; + +template +struct __prefer_parallel_tag +{ + static constexpr bool value = + __allow_parallel::value && __is_random_access_iterator<_IteratorTypes...>::value; + typedef std::integral_constant type; +}; + +} // namespace __internal +} // namespace __pstl + +#endif /* __PSTL_execution_impl_H */ diff --git a/libstdc++-v3/include/pstl/glue_algorithm_defs.h b/libstdc++-v3/include/pstl/glue_algorithm_defs.h new file mode 100644 index 0000000..c622ed3 --- /dev/null +++ b/libstdc++-v3/include/pstl/glue_algorithm_defs.h @@ -0,0 +1,551 @@ +// -*- C++ -*- +//===-- glue_algorithm_defs.h ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_glue_algorithm_defs_H +#define __PSTL_glue_algorithm_defs_H + +#include + +#include "execution_defs.h" + +namespace std +{ + +// [alg.any_of] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +// [alg.all_of] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +// [alg.none_of] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +// [alg.foreach] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f); + +// [alg.find] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +// [alg.find.end] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last); + +// [alg.find_first_of] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); + +// [alg.adjacent_find] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); + +// [alg.count] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::difference_type> +count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::difference_type> +count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +// [alg.search] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value); + +// [alg.copy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result, + _Predicate __pred); + +// [alg.swap] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2); + +// [alg.transform] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + _UnaryOperation __op); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator __result, _BinaryOperation __op); + +// [alg.replace] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + const _Tp& __new_value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, + const _Tp& __new_value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + const _Tp& __old_value, const _Tp& __new_value); + +// [alg.fill] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value); + +// [alg.generate] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g); + +// [alg.remove] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Predicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +// [alg.unique] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); + +// [alg.reverse] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _ForwardIterator __d_first); + +// [alg.rotate] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last, + _ForwardIterator2 __result); + +// [alg.partitions] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> +stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _UnaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred); + +// [alg.sort] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + +// [stable.sort] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + +// [mismatch] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); + +// [alg.equal] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __p); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _BinaryPredicate __p); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2); + +// [alg.move] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first); + +// [partial.sort] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last); + +// [partial.sort.copy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last); + +// [is.sorted] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +// [alg.nth.element] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last); + +// [alg.merge] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __d_first); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last); + +// [includes] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2); + +// [set.union] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __result); + +// [set.intersection] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); + +// [set.difference] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); + +// [set.symmetric.difference] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator result, + _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); + +// [is.heap] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + +// [alg.min.max] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> +minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> +minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +// [alg.lex.comparison] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2); + +} // namespace std +#endif /* __PSTL_glue_algorithm_defs_H */ diff --git a/libstdc++-v3/include/pstl/glue_algorithm_impl.h b/libstdc++-v3/include/pstl/glue_algorithm_impl.h new file mode 100644 index 0000000..88ce93f --- /dev/null +++ b/libstdc++-v3/include/pstl/glue_algorithm_impl.h @@ -0,0 +1,1182 @@ +// -*- C++ -*- +//===-- glue_algorithm_impl.h ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_glue_algorithm_impl_H +#define __PSTL_glue_algorithm_impl_H + +#include + +#include "execution_defs.h" +#include "utils.h" +#include "algorithm_fwd.h" +#include "numeric_fwd.h" /* count and count_if use __pattern_transform_reduce */ + +namespace std +{ + +// [alg.any_of] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_any_of( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +// [alg.all_of] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) +{ + return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, + __pstl::__internal::__not_pred<_Pred>(__pred)); +} + +// [alg.none_of] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) +{ + return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred); +} + +// [alg.foreach] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f) +{ + using namespace __pstl; + __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, __f, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f) +{ + using namespace __pstl; + return __internal::__pattern_walk1_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, __f, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +// [alg.find] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_find_if( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) +{ + return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, + __pstl::__internal::__not_pred<_Predicate>(__pred)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) +{ + return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, + __pstl::__internal::__equal_value<_Tp>(__value)); +} + +// [alg.find.end] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_find_end( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last) +{ + return std::find_end(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, + __pstl::__internal::__pstl_equal()); +} + +// [alg.find_first_of] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_find_first_of( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last) +{ + return std::find_first_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, + __pstl::__internal::__pstl_equal()); +} + +// [alg.adjacent_find] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + using namespace __pstl; + return __internal::__pattern_adjacent_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<_ValueType>(), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_adjacent_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false); +} + +// [alg.count] + +// Implementation note: count and count_if call the pattern directly instead of calling std::transform_reduce +// so that we do not have to include . + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::difference_type> +count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + using namespace __pstl; + return __internal::__pattern_count( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__value](const _ValueType& __x) { return __value == __x; }, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::difference_type> +count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_count( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +// [alg.search] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_search( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last) +{ + return std::search(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, + __pstl::__internal::__pstl_equal()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value, _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_search_n( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value) +{ + return std::search_n(std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, + std::equal_to::value_type>()); +} + +// [alg.copy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) +{ + using namespace __pstl; + const auto __is_vector = + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); + + return __internal::__pattern_walk2_brick( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) { + return __internal::__brick_copy(__begin, __end, __res, __is_vector); + }, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result) +{ + using namespace __pstl; + const auto __is_vector = + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); + + return __internal::__pattern_walk2_brick_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, + [__is_vector](_ForwardIterator1 __begin, _Size __sz, _ForwardIterator2 __res) { + return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector); + }, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + _Predicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_copy_if( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +// [alg.swap] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) +{ + using namespace __pstl; + typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1; + typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2; + return __internal::__pattern_walk2( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, + [](_ReferenceType1 __x, _ReferenceType2 __y) { + using std::swap; + swap(__x, __y); + }, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +// [alg.transform] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + _UnaryOperation __op) +{ + typedef typename iterator_traits<_ForwardIterator1>::reference _InputType; + typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType; + using namespace __pstl; + return __internal::__pattern_walk2( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [__op](_InputType __x, _OutputType __y) mutable { __y = __op(__x); }, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator __result, _BinaryOperation __op) +{ + typedef typename iterator_traits<_ForwardIterator1>::reference _Input1Type; + typedef typename iterator_traits<_ForwardIterator2>::reference _Input2Type; + typedef typename iterator_traits<_ForwardIterator>::reference _OutputType; + using namespace __pstl; + return __internal::__pattern_walk3( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __result, + [__op](_Input1Type x, _Input2Type y, _OutputType z) mutable { z = __op(x, y); }, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec)); +} + +// [alg.replace] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + const _Tp& __new_value) +{ + using namespace __pstl; + typedef typename iterator_traits<_ForwardIterator>::reference _ElementType; + __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__pred, &__new_value](_ElementType __elem) { + if (__pred(__elem)) + { + __elem = __new_value; + } + }, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, + const _Tp& __new_value) +{ + std::replace_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, + __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value) +{ + typedef typename iterator_traits<_ForwardIterator1>::reference _InputType; + typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType; + using namespace __pstl; + return __internal::__pattern_walk2( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [__pred, &__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; }, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + const _Tp& __old_value, const _Tp& __new_value) +{ + return std::replace_copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value); +} + +// [alg.fill] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) +{ + using namespace __pstl; + __internal::__pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __last, __value, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value) +{ + if (__count <= 0) + return __first; + + using namespace __pstl; + return __internal::__pattern_fill_n( + std::forward<_ExecutionPolicy>(__exec), __first, __count, __value, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +// [alg.generate] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g) +{ + using namespace __pstl; + __internal::__pattern_generate( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __g, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, _Generator __g) +{ + if (__count <= 0) + return __first; + + using namespace __pstl; + return __internal::__pattern_generate_n( + std::forward<_ExecutionPolicy>(__exec), __first, __count, __g, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +// [alg.remove] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Predicate __pred) +{ + return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + __pstl::__internal::__not_pred<_Predicate>(__pred)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + const _Tp& __value) +{ + return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + __pstl::__internal::__not_equal_value<_Tp>(__value)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_remove_if( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) +{ + return std::remove_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, + __pstl::__internal::__equal_value<_Tp>(__value)); +} + +// [alg.unique] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_unique( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + return std::unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__pstl_equal()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_unique_copy( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) +{ + return std::unique_copy(__exec, __first, __last, __result, __pstl::__internal::__pstl_equal()); +} + +// [alg.reverse] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last) +{ + using namespace __pstl; + __internal::__pattern_reverse( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _ForwardIterator __d_first) +{ + using namespace __pstl; + return __internal::__pattern_reverse_copy( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec)); +} + +// [alg.rotate] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) +{ + using namespace __pstl; + return __internal::__pattern_rotate( + std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last, + _ForwardIterator2 __result) +{ + using namespace __pstl; + return __internal::__pattern_rotate_copy( + std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __result, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +// [alg.partitions] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_is_partitioned( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_partition( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> +stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _UnaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_stable_partition( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_partition_copy( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __out_true, __out_false, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1, + _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1, + _ForwardIterator2>(__exec)); +} + +// [alg.sort] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) +{ + typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType; + using namespace __pstl; + return __internal::__pattern_sort( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), + typename std::is_move_constructible<_InputType>::type()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; + std::sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); +} + +// [stable.sort] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_stable_sort( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; + std::stable_sort(__exec, __first, __last, std::less<_InputType>()); +} + +// [mismatch] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _BinaryPredicate __pred) +{ + using namespace __pstl; + return __internal::__pattern_mismatch( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pred, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __pred) +{ + return std::mismatch(__exec, __first1, __last1, __first2, std::next(__first2, std::distance(__first1, __last1)), + __pred); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2) +{ + return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, + __pstl::__internal::__pstl_equal()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) +{ + //TODO: to get rid of "distance" + return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, + std::next(__first2, std::distance(__first1, __last1))); +} + +// [alg.equal] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __p) +{ + using namespace __pstl; + return __internal::__pattern_equal( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) +{ + return std::equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, + __pstl::__internal::__pstl_equal()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _BinaryPredicate __p) +{ + //TODO: to get rid of "distance" + if (std::distance(__first1, __last1) == std::distance(__first2, __last2)) + return std::equal(__first1, __last1, __first2, __p); + else + return false; +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2) +{ + return equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, + __pstl::__internal::__pstl_equal()); +} + +// [alg.move] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first) +{ + using namespace __pstl; + const auto __is_vector = + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); + + return __internal::__pattern_walk2_brick( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, + [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) { + return __internal::__brick_move(__begin, __end, __res, __is_vector); + }, + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +// [partial.sort] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp) +{ + using namespace __pstl; + __internal::__pattern_partial_sort( + std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last) +{ + typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType; + std::partial_sort(__exec, __first, __middle, __last, std::less<_InputType>()); +} + +// [partial.sort.copy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_partial_sort_copy( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last) +{ + return std::partial_sort_copy(std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, + __pstl::__internal::__pstl_less()); +} + +// [is.sorted] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) +{ + using namespace __pstl; + const _ForwardIterator __res = __internal::__pattern_adjacent_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__reorder_pred<_Compare>(__comp), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false); + return __res == __last ? __last : std::next(__res); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; + return is_sorted_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_adjacent_find( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __internal::__reorder_pred<_Compare>(__comp), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + /*or_semantic*/ true) == __last; +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; + return std::is_sorted(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); +} + +// [alg.merge] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_merge( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __d_first) +{ + return std::merge(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, + __pstl::__internal::__pstl_less()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last, _Compare __comp) +{ + using namespace __pstl; + __internal::__pattern_inplace_merge( + std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last) +{ + typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _InputType; + std::inplace_merge(__exec, __first, __middle, __last, std::less<_InputType>()); +} + +// [includes] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_includes( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2) +{ + return std::includes(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, + __pstl::__internal::__pstl_less()); +} + +// [set.union] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_set_union( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __result) +{ + return std::set_union(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, + __pstl::__internal::__pstl_less()); +} + +// [set.intersection] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_set_intersection( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result) +{ + return std::set_intersection(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, + __pstl::__internal::__pstl_less()); +} + +// [set.difference] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_set_difference( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result) +{ + return std::set_difference(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, + __pstl::__internal::__pstl_less()); +} + +// [set.symmetric.difference] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, + _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_set_symmetric_difference( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, + _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result) +{ + return std::set_symmetric_difference(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, + __result, __pstl::__internal::__pstl_less()); +} + +// [is.heap] +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_is_heap_until( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; + return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) +{ + return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp) == __last; +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; + return std::is_heap(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); +} + +// [alg.min.max] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_min_element( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; + return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) +{ + return min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, + __pstl::__internal::__reorder_pred<_Compare>(__comp)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; + return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, + __pstl::__internal::__reorder_pred>(std::less<_InputType>())); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> +minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_minmax_element( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> +minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + return std::minmax_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_ValueType>()); +} + +// [alg.nth.element] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp) +{ + using namespace __pstl; + __internal::__pattern_nth_element( + std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last) +{ + typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType; + std::nth_element(std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, std::less<_InputType>()); +} + +// [alg.lex.comparison] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp) +{ + using namespace __pstl; + return __internal::__pattern_lexicographical_compare( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) +{ + return std::lexicographical_compare(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, + __pstl::__internal::__pstl_less()); +} + +} // namespace std + +#endif /* __PSTL_glue_algorithm_impl_H */ diff --git a/libstdc++-v3/include/pstl/glue_execution_defs.h b/libstdc++-v3/include/pstl/glue_execution_defs.h new file mode 100644 index 0000000..dacd038 --- /dev/null +++ b/libstdc++-v3/include/pstl/glue_execution_defs.h @@ -0,0 +1,56 @@ +// -*- C++ -*- +//===-- glue_execution_defs.h ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_glue_execution_defs_H +#define __PSTL_glue_execution_defs_H + +#include + +#include "execution_defs.h" + +namespace std +{ +// Type trait +using __pstl::execution::is_execution_policy; +#if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT +#if __INTEL_COMPILER +template +constexpr bool is_execution_policy_v = is_execution_policy::value; +#else +using __pstl::execution::is_execution_policy_v; +#endif +#endif + +namespace execution +{ +// Standard C++ policy classes +using __pstl::execution::sequenced_policy; +#if __PSTL_USE_PAR_POLICIES +using __pstl::execution::parallel_policy; +using __pstl::execution::parallel_unsequenced_policy; +#endif +// Standard predefined policy instances +using __pstl::execution::seq; +#if __PSTL_USE_PAR_POLICIES +using __pstl::execution::par; +using __pstl::execution::par_unseq; +#endif +// Implementation-defined names +// Unsequenced policy is not yet standard, but for consistency +// we include it into namespace std::execution as well +using __pstl::execution::unseq; +using __pstl::execution::unsequenced_policy; +} // namespace execution +} // namespace std + +#include "algorithm_impl.h" +#include "numeric_impl.h" +#include "parallel_backend.h" + +#endif /* __PSTL_glue_execution_defs_H */ diff --git a/libstdc++-v3/include/pstl/glue_memory_defs.h b/libstdc++-v3/include/pstl/glue_memory_defs.h new file mode 100644 index 0000000..79e4ed7 --- /dev/null +++ b/libstdc++-v3/include/pstl/glue_memory_defs.h @@ -0,0 +1,79 @@ +// -*- C++ -*- +//===-- glue_memory_defs.h ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_glue_memory_defs_H +#define __PSTL_glue_memory_defs_H + +#include "execution_defs.h" + +namespace std +{ + +// [uninitialized.copy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); + +// [uninitialized.move] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); + +// [uninitialized.fill] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value); + +// [specialized.destroy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); + +// [uninitialized.construct.default] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); + +// [uninitialized.construct.value] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); + +} // namespace std +#endif /* __PSTL_glue_memory_defs_H */ diff --git a/libstdc++-v3/include/pstl/glue_memory_impl.h b/libstdc++-v3/include/pstl/glue_memory_impl.h new file mode 100644 index 0000000..4cde9ba --- /dev/null +++ b/libstdc++-v3/include/pstl/glue_memory_impl.h @@ -0,0 +1,358 @@ +// -*- C++ -*- +//===-- glue_memory_impl.h ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_glue_memory_impl_H +#define __PSTL_glue_memory_impl_H + +#include "utils.h" +#include "algorithm_fwd.h" + +namespace std +{ + +// [uninitialized.copy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) +{ + typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; + typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; + using namespace __pstl; + + const auto __is_parallel = + __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + const auto __is_vector = + __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else( + std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), + [&]() { + return __internal::__pattern_walk2_brick( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) { + return __internal::__brick_copy(__begin, __end, __res, __is_vector); + }, + __is_parallel); + }, + [&]() { + return __internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(__val1); + }, + __is_vector, __is_parallel); + }); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result) +{ + typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; + typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; + using namespace __pstl; + + const auto __is_parallel = + __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + const auto __is_vector = + __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else( + std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), + [&]() { + return __internal::__pattern_walk2_brick_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, + [__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) { + return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector); + }, + __is_parallel); + }, + [&]() { + return __internal::__pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(__val1); + }, + __is_vector, __is_parallel); + }); +} + +// [uninitialized.move] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) +{ + typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; + typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; + using namespace __pstl; + + const auto __is_parallel = + __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + const auto __is_vector = + __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else( + std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), + [&]() { + return __internal::__pattern_walk2_brick( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) { + return __internal::__brick_copy(__begin, __end, __res, __is_vector); + }, + __is_parallel); + }, + [&]() { + return __internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); + }, + __is_vector, __is_parallel); + }); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result) +{ + typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; + typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; + using namespace __pstl; + + const auto __is_parallel = + __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + const auto __is_vector = + __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else( + std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), + [&]() { + return __internal::__pattern_walk2_brick_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, + [__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) { + return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector); + }, + __is_parallel); + }, + [&]() { + return __internal::__pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, + [](_ReferenceType1 __val1, _ReferenceType2 __val2) { + ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); + }, + __is_vector, __is_parallel); + }); +} + +// [uninitialized.fill] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + __internal::__invoke_if_else(std::is_arithmetic<_ValueType>(), + [&]() { + __internal::__pattern_walk_brick( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [&__value, &__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { + __internal::__brick_fill(__begin, __end, _ValueType(__value), __is_vector); + }, + __is_parallel); + }, + [&]() { + __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, + __last, + [&__value](_ReferenceType __val) { + ::new (std::addressof(__val)) _ValueType(__value); + }, + __is_vector, __is_parallel); + }); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else( + std::is_arithmetic<_ValueType>(), + [&]() { + return __internal::__pattern_walk_brick_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, + [&__value, &__is_vector](_ForwardIterator __begin, _Size __count) { + return __internal::__brick_fill_n(__begin, __count, _ValueType(__value), __is_vector); + }, + __is_parallel); + }, + [&]() { + return __internal::__pattern_walk1_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, + [&__value](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(__value); }, __is_vector, + __is_parallel); + }); +} + +// [specialized.destroy] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + __internal::__invoke_if_not(std::is_trivially_destructible<_ValueType>(), [&]() { + __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, __is_parallel); + }); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else( + std::is_trivially_destructible<_ValueType>(), [&]() { return std::next(__first, __n); }, + [&]() { + return __internal::__pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, + [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, + __is_parallel); + }); +} + +// [uninitialized.construct.default] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + __internal::__invoke_if_not(std::is_trivial<_ValueType>(), [&]() { + __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, + __is_parallel); + }); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else(std::is_trivial<_ValueType>(), [&]() { return std::next(__first, __n); }, + [&]() { + return __internal::__pattern_walk1_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, + [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, + __is_vector, __is_parallel); + }); +} + +// [uninitialized.construct.value] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + __internal::__invoke_if_else( + std::is_trivial<_ValueType>(), + [&]() { + __internal::__pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { + __internal::__brick_fill(__begin, __end, _ValueType(), __is_vector); + }, + __is_parallel); + }, + [&]() { + __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, + __is_vector, __is_parallel); + }); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; + using namespace __pstl; + + const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); + + return __internal::__invoke_if_else( + std::is_trivial<_ValueType>(), + [&]() { + return __internal::__pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, + [__is_vector](_ForwardIterator __begin, _Size __count) { + return __internal::__brick_fill_n(__begin, __count, + _ValueType(), __is_vector); + }, + __is_parallel); + }, + [&]() { + return __internal::__pattern_walk1_n( + std::forward<_ExecutionPolicy>(__exec), __first, __n, + [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, __is_vector, __is_parallel); + }); +} + +} // namespace std + +#endif /* __PSTL_glue_memory_imple_H */ diff --git a/libstdc++-v3/include/pstl/glue_numeric_defs.h b/libstdc++-v3/include/pstl/glue_numeric_defs.h new file mode 100644 index 0000000..55187f1 --- /dev/null +++ b/libstdc++-v3/include/pstl/glue_numeric_defs.h @@ -0,0 +1,116 @@ +// -*- C++ -*- +//===-- glue_numeric_defs.h -----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_glue_numeric_defs_H +#define __PSTL_glue_numeric_defs_H + +#include "execution_defs.h" + +namespace std +{ +// [reduce] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::value_type> +reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Tp __init); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, + _BinaryOperation2 __binary_op2); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op, _UnaryOperation __unary_op); + +// [exclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Tp __init); + +template +_ForwardIterator2 +exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op); + +// [inclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init); + +// [transform.exclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op, + _UnaryOperation __unary_op); + +// [transform.inclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op, + _Tp __init); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op); + +// [adjacent.difference] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __d_first, _BinaryOperation op); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __d_first); + +} // namespace std +#endif /* __PSTL_glue_numeric_defs_H */ diff --git a/libstdc++-v3/include/pstl/glue_numeric_impl.h b/libstdc++-v3/include/pstl/glue_numeric_impl.h new file mode 100644 index 0000000..bde0b03 --- /dev/null +++ b/libstdc++-v3/include/pstl/glue_numeric_impl.h @@ -0,0 +1,224 @@ +// -*- C++ -*- +//===-- glue_numeric_impl.h -----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_glue_numeric_impl_H +#define __PSTL_glue_numeric_impl_H + +#include + +#include "utils.h" +#include "numeric_fwd.h" + +namespace std +{ + +// [reduce] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op) +{ + return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, + __pstl::__internal::__no_op()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init) +{ + return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, std::plus<_Tp>(), + __pstl::__internal::__no_op()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::value_type> +reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) +{ + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, _ValueType{}, + std::plus<_ValueType>(), __pstl::__internal::__no_op()); +} + +// [transform.reduce] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Tp __init) +{ + typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType; + using namespace __pstl; + return __internal::__pattern_transform_reduce( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, std::plus<_InputType>(), + std::multiplies<_InputType>(), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2) +{ + using namespace __pstl; + return __internal::__pattern_transform_reduce( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, __binary_op1, __binary_op2, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> +transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op, _UnaryOperation __unary_op) +{ + using namespace __pstl; + return __internal::__pattern_transform_reduce( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __unary_op, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); +} + +// [exclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Tp __init) +{ + return transform_exclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __init, + std::plus<_Tp>(), __pstl::__internal::__no_op()); +} + +template +_ForwardIterator2 +exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op) +{ + return transform_exclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __init, + __binary_op, __pstl::__internal::__no_op()); +} + +// [inclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result) +{ + typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType; + return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, + std::plus<_InputType>(), __pstl::__internal::__no_op()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op) +{ + return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __binary_op, + __pstl::__internal::__no_op()); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init) +{ + return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __binary_op, + __pstl::__internal::__no_op(), __init); +} + +// [transform.exclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op, + _UnaryOperation __unary_op) +{ + using namespace __pstl; + return __internal::__pattern_transform_scan( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op, + /*inclusive=*/std::false_type(), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +// [transform.inclusive.scan] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op, + _Tp __init) +{ + using namespace __pstl; + return __internal::__pattern_transform_scan( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op, + /*inclusive=*/std::true_type(), + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op) +{ + if (__first != __last) + { + auto __tmp = __unary_op(*__first); + *__result = __tmp; + return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), ++__first, __last, ++__result, + __binary_op, __unary_op, __tmp); + } + else + { + return __result; + } +} + +// [adjacent.difference] + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __d_first, _BinaryOperation __op) +{ + + if (__first == __last) + return __d_first; + + using namespace __pstl; + return __internal::__pattern_adjacent_difference( + std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __op, + __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), + __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); +} + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __d_first) +{ + typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType; + return adjacent_difference(std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, + std::minus<_ValueType>()); +} + +} // namespace std + +#endif /* __PSTL_glue_numeric_impl_H_ */ diff --git a/libstdc++-v3/include/pstl/memory_impl.h b/libstdc++-v3/include/pstl/memory_impl.h new file mode 100644 index 0000000..0fadbc6 --- /dev/null +++ b/libstdc++-v3/include/pstl/memory_impl.h @@ -0,0 +1,56 @@ +// -*- C++ -*- +//===-- memory_impl.h -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_memory_impl_H +#define __PSTL_memory_impl_H + +#include + +#include "unseq_backend_simd.h" + +namespace __pstl +{ +namespace __internal +{ + +//------------------------------------------------------------------------ +// uninitialized_move +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::false_type) noexcept +{ + typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType2; + for (; __first != __last; ++__first, ++__result) + { + ::new (std::addressof(*__result)) _ValueType2(std::move(*__first)); + } + return __result; +} + +template +_OutputIterator +__brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + /*vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_OutputIterator>::value_type __ValueType2; + typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType1; + typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2; + + return __unseq_backend::__simd_walk_2( + __first, __last - __first, __result, + [](_ReferenceType1 __x, _ReferenceType2 __y) { ::new (std::addressof(__y)) __ValueType2(std::move(__x)); }); +} + +} // namespace __internal +} // namespace __pstl + +#endif /* __PSTL_memory_impl_H */ diff --git a/libstdc++-v3/include/pstl/numeric_fwd.h b/libstdc++-v3/include/pstl/numeric_fwd.h new file mode 100644 index 0000000..5666796 --- /dev/null +++ b/libstdc++-v3/include/pstl/numeric_fwd.h @@ -0,0 +1,146 @@ +// -*- C++ -*- +//===-- numeric_fwd.h --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_numeric_fwd_H +#define __PSTL_numeric_fwd_H + +#include +#include + +namespace __pstl +{ +namespace __internal +{ + +//------------------------------------------------------------------------ +// transform_reduce (version with two binary functions, according to draft N4659) +//------------------------------------------------------------------------ + +template +_Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, + _BinaryOperation2, + /*__is_vector=*/std::true_type) noexcept; + +template +_Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, + _BinaryOperation2, + /*__is_vector=*/std::false_type) noexcept; + +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, + _BinaryOperation1, _BinaryOperation2, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, + _Tp, _BinaryOperation1, _BinaryOperation2, _IsVector __is_vector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// transform_reduce (version with unary and binary functions) +//------------------------------------------------------------------------ + +template +_Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, + /*is_vector=*/std::true_type) noexcept; + +template +_Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, + /*is_vector=*/std::false_type) noexcept; + +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, + _UnaryOperation, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, + _UnaryOperation, _IsVector, + /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// transform_exclusive_scan +// +// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...) +//------------------------------------------------------------------------ + +template +std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, + /*Inclusive*/ std::false_type) noexcept; + +template +std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, + /*Inclusive*/ std::true_type) noexcept; + +template +_OutputIterator +__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp, + _BinaryOperation, _Inclusive, _IsVector, + /*is_parallel=*/std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +typename std::enable_if::value, _OutputIterator>::type +__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type); +#endif + +#if __PSTL_USE_PAR_POLICIES +template +typename std::enable_if::value, _OutputIterator>::type +__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, + _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type); +#endif + +//------------------------------------------------------------------------ +// adjacent_difference +//------------------------------------------------------------------------ + +template +_OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + /*is_vector*/ std::false_type) noexcept; + +template +_OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + /*is_vector*/ std::true_type) noexcept; + +template +_OutputIterator +__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + _IsVector, /*is_parallel*/ std::false_type) noexcept; + +#if __PSTL_USE_PAR_POLICIES +template +_OutputIterator +__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, + _IsVector, /*is_parallel*/ std::true_type); +#endif + +} // namespace __internal +} // namespace __pstl +#endif /* __PSTL_numeric_fwd_H */ diff --git a/libstdc++-v3/include/pstl/numeric_impl.h b/libstdc++-v3/include/pstl/numeric_impl.h new file mode 100644 index 0000000..803e2d8 --- /dev/null +++ b/libstdc++-v3/include/pstl/numeric_impl.h @@ -0,0 +1,368 @@ +// -*- C++ -*- +//===-- numeric_impl.h ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_numeric_impl_H +#define __PSTL_numeric_impl_H + +#include +#include +#include + +#include "execution_impl.h" +#include "unseq_backend_simd.h" +#include "algorithm_fwd.h" + +#if __PSTL_USE_PAR_POLICIES +#include "parallel_backend.h" +#endif + +namespace __pstl +{ +namespace __internal +{ + +//------------------------------------------------------------------------ +// transform_reduce (version with two binary functions, according to draft N4659) +//------------------------------------------------------------------------ + +template +_Tp +__brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, + _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, + /*is_vector=*/std::false_type) noexcept +{ + return std::inner_product(__first1, __last1, __first2, __init, __binary_op1, __binary_op2); +} + +template +_Tp +__brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, + _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, + /*is_vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; + return __unseq_backend::__simd_transform_reduce( + __last1 - __first1, __init, __binary_op1, + [=, &__binary_op2](_DifferenceType __i) { return __binary_op2(__first1[__i], __first2[__i]); }); +} + +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, + _BinaryOperation2 __binary_op2, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, + _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + return __except_handler([&]() { + return __par_backend::__parallel_transform_reduce( + std::forward<_ExecutionPolicy>(__exec), __first1, __last1, + [__first1, __first2, __binary_op2](_RandomAccessIterator1 __i) mutable { + return __binary_op2(*__i, *(__first2 + (__i - __first1))); + }, + __init, + __binary_op1, // Combine + [__first1, __first2, __binary_op1, __binary_op2, + __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j, _Tp __init) -> _Tp { + return __brick_transform_reduce(__i, __j, __first2 + (__i - __first1), __init, __binary_op1, + __binary_op2, __is_vector); + }); + }); +} +#endif + +//------------------------------------------------------------------------ +// transform_reduce (version with unary and binary functions) +//------------------------------------------------------------------------ + +template +_Tp +__brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, + _UnaryOperation __unary_op, /*is_vector=*/std::false_type) noexcept +{ + for (; __first != __last; ++__first) + { + __init = __binary_op(__init, __unary_op(*__first)); + } + return __init; +} + +template +_Tp +__brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, + _UnaryOperation __unary_op, /*is_vector=*/std::true_type) noexcept +{ + typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType; + return __unseq_backend::__simd_transform_reduce( + __last - __first, __init, __binary_op, + [=, &__unary_op](_DifferenceType __i) { return __unary_op(__first[__i]); }); +} + +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, + /*is_parallel=*/std::false_type) noexcept +{ + return __brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_Tp +__pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, + _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + return __except_handler([&]() { + return __par_backend::__parallel_transform_reduce( + std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__unary_op](_ForwardIterator __i) mutable { return __unary_op(*__i); }, __init, __binary_op, + [__unary_op, __binary_op, __is_vector](_ForwardIterator __i, _ForwardIterator __j, _Tp __init) { + return __brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector); + }); + }); +} +#endif + +//------------------------------------------------------------------------ +// transform_exclusive_scan +// +// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...) +//------------------------------------------------------------------------ + +// Exclusive form +template +std::pair<_OutputIterator, _Tp> +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + /*Inclusive*/ std::false_type, /*is_vector=*/std::false_type) noexcept +{ + for (; __first != __last; ++__first, ++__result) + { + *__result = __init; + __PSTL_PRAGMA_FORCEINLINE + __init = __binary_op(__init, __unary_op(*__first)); + } + return std::make_pair(__result, __init); +} + +// Inclusive form +template +std::pair<_OutputIterator, _Tp> +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + /*Inclusive*/ std::true_type, /*is_vector=*/std::false_type) noexcept +{ + for (; __first != __last; ++__first, ++__result) + { + __PSTL_PRAGMA_FORCEINLINE + __init = __binary_op(__init, __unary_op(*__first)); + *__result = __init; + } + return std::make_pair(__result, __init); +} + +// type is arithmetic and binary operation is a user defined operation. +template +using is_arithmetic_udop = std::integral_constant::value && + !std::is_same<_BinaryOperation, std::plus<_Tp>>::value>; + +// [restriction] - T shall be DefaultConstructible. +// [violation] - default ctor of T shall set the identity value for binary_op. +template +typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, + /*is_vector=*/std::true_type) noexcept +{ +#if (__PSTL_UDS_PRESENT) + return __unseq_backend::__simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op, + _Inclusive()); +#else + // We need to call serial brick here to call function for inclusive and exclusive scan that depends on _Inclusive() value + return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), + /*is_vector=*/std::false_type()); +#endif +} + +template +typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type +__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, + _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, + /*is_vector=*/std::true_type) noexcept +{ + return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), + /*is_vector=*/std::false_type()); +} + +template +_OutputIterator +__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept +{ + return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), __is_vector) + .first; +} + +#if __PSTL_USE_PAR_POLICIES +template +typename std::enable_if::value, _OutputIterator>::type +__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; + + return __except_handler([&]() { + __par_backend::__parallel_transform_scan( + std::forward<_ExecutionPolicy>(__exec), __last - __first, + [__first, __unary_op](_DifferenceType __i) mutable { return __unary_op(__first[__i]); }, __init, + __binary_op, + [__first, __unary_op, __binary_op](_DifferenceType __i, _DifferenceType __j, _Tp __init) { + // Execute serial __brick_transform_reduce, due to the explicit SIMD vectorization (reduction) requires a commutative operation for the guarantee of correct scan. + return __brick_transform_reduce(__first + __i, __first + __j, __init, __binary_op, __unary_op, + /*__is_vector*/ std::false_type()); + }, + [__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __j, + _Tp __init) { + return __brick_transform_scan(__first + __i, __first + __j, __result + __i, __unary_op, __init, + __binary_op, _Inclusive(), __is_vector) + .second; + }); + return __result + (__last - __first); + }); +} +#endif + +#if __PSTL_USE_PAR_POLICIES +template +typename std::enable_if::value, _OutputIterator>::type +__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, + _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type) +{ + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; + _DifferenceType __n = __last - __first; + + if (__n <= 0) + { + return __result; + } + return __except_handler([&]() { + __par_backend::parallel_strict_scan( + std::forward<_ExecutionPolicy>(__exec), __n, __init, + [__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __len) { + return __brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i, __unary_op, _Tp{}, + __binary_op, _Inclusive(), __is_vector) + .second; + }, + __binary_op, + [__result, &__binary_op](_DifferenceType __i, _DifferenceType __len, _Tp __initial) { + return *(std::transform(__result + __i, __result + __i + __len, __result + __i, + [&__initial, &__binary_op](const _Tp& __x) { + __PSTL_PRAGMA_FORCEINLINE + return __binary_op(__initial, __x); + }) - + 1); + }, + [](_Tp __res) {}); + return __result + (__last - __first); + }); +} +#endif + +//------------------------------------------------------------------------ +// adjacent_difference +//------------------------------------------------------------------------ + +template +_OutputIterator +__brick_adjacent_difference(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first, + _BinaryOperation __op, /*is_vector*/ std::false_type) noexcept +{ + return std::adjacent_difference(__first, __last, __d_first, __op); +} + +template +_ForwardIterator2 +__brick_adjacent_difference(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, + BinaryOperation __op, /*is_vector=*/std::true_type) noexcept +{ + assert(__first != __last); + + typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1; + typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2; + + auto __n = __last - __first; + *__d_first = *__first; + return __unseq_backend::__simd_walk_3( + __first + 1, __n - 1, __first, __d_first + 1, + [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__x, __y); }); +} + +template +_OutputIterator +__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector, + /*is_parallel*/ std::false_type) noexcept +{ + return __brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector); +} + +#if __PSTL_USE_PAR_POLICIES +template +_ForwardIterator2 +__pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector, + /*is_parallel=*/std::true_type) +{ + assert(__first != __last); + typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1; + typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2; + + *__d_first = *__first; + __par_backend::__parallel_for( + std::forward<_ExecutionPolicy>(__exec), __first, __last - 1, + [&__op, __is_vector, __d_first, __first](_ForwardIterator1 __b, _ForwardIterator1 __e) { + _ForwardIterator2 __d_b = __d_first + (__b - __first); + __brick_walk3( + __b, __e, __b + 1, __d_b + 1, + [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__y, __x); }, + __is_vector); + }); + return __d_first + (__last - __first); +} +#endif + +} // namespace __internal +} // namespace __pstl + +#endif /* __PSTL_numeric_impl_H */ diff --git a/libstdc++-v3/include/pstl/parallel_backend.h b/libstdc++-v3/include/pstl/parallel_backend.h new file mode 100644 index 0000000..820e2b7 --- /dev/null +++ b/libstdc++-v3/include/pstl/parallel_backend.h @@ -0,0 +1,19 @@ +// -*- C++ -*- +//===-- parallel_backend.h ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_parallel_backend_H +#define __PSTL_parallel_backend_H + +#if __PSTL_PAR_BACKEND_TBB +#include "parallel_backend_tbb.h" +#else +__PSTL_PRAGMA_MESSAGE("Parallel backend was not specified"); +#endif + +#endif /* __PSTL_parallel_backend_H */ diff --git a/libstdc++-v3/include/pstl/parallel_backend_tbb.h b/libstdc++-v3/include/pstl/parallel_backend_tbb.h new file mode 100644 index 0000000..114bf63 --- /dev/null +++ b/libstdc++-v3/include/pstl/parallel_backend_tbb.h @@ -0,0 +1,653 @@ +// -*- C++ -*- +//===-- parallel_backend_tbb.h --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_parallel_backend_tbb_H +#define __PSTL_parallel_backend_tbb_H + +#include +#include +#include + +#include "parallel_backend_utils.h" + +// Bring in minimal required subset of Intel TBB +#include +#include +#include +#include +#include +#include +#include + +#if TBB_INTERFACE_VERSION < 10000 +#error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported. +#endif + +namespace __pstl +{ +namespace __par_backend +{ + +//! Raw memory buffer with automatic freeing and no exceptions. +/** Some of our algorithms need to start with raw memory buffer, +not an initialize array, because initialization/destruction +would make the span be at least O(N). */ +// tbb::allocator can improve performance in some cases. +template +class __buffer +{ + tbb::tbb_allocator<_Tp> _M_allocator; + _Tp* _M_ptr; + const std::size_t _M_buf_size; + __buffer(const __buffer&) = delete; + void + operator=(const __buffer&) = delete; + + public: + //! Try to obtain buffer of given size to store objects of _Tp type + __buffer(std::size_t n) : _M_allocator(), _M_ptr(_M_allocator.allocate(n)), _M_buf_size(n) {} + //! True if buffer was successfully obtained, zero otherwise. + operator bool() const { return _M_ptr != NULL; } + //! Return pointer to buffer, or NULL if buffer could not be obtained. + _Tp* + get() const + { + return _M_ptr; + } + //! Destroy buffer + ~__buffer() { _M_allocator.deallocate(_M_ptr, _M_buf_size); } +}; + +// Wrapper for tbb::task +inline void +__cancel_execution() +{ + tbb::task::self().group()->cancel_group_execution(); +} + +//------------------------------------------------------------------------ +// parallel_for +//------------------------------------------------------------------------ + +template +class __parallel_for_body +{ + public: + __parallel_for_body(const _RealBody& __body) : _M_body(__body) {} + __parallel_for_body(const __parallel_for_body& __body) : _M_body(__body._M_body) {} + void + operator()(const tbb::blocked_range<_Index>& __range) const + { + _M_body(__range.begin(), __range.end()); + } + + private: + _RealBody _M_body; +}; + +//! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last) +// wrapper over tbb::parallel_for +template +void +__parallel_for(_ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f) +{ + tbb::this_task_arena::isolate([=]() { + tbb::parallel_for(tbb::blocked_range<_Index>(__first, __last), __parallel_for_body<_Index, _Fp>(__f)); + }); +} + +//! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last) +// wrapper over tbb::parallel_reduce +template +_Value +__parallel_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, const _Value& __identity, + const _RealBody& __real_body, const _Reduction& __reduction) +{ + return tbb::this_task_arena::isolate([__first, __last, &__identity, &__real_body, &__reduction]() -> _Value { + return tbb::parallel_reduce( + tbb::blocked_range<_Index>(__first, __last), __identity, + [__real_body](const tbb::blocked_range<_Index>& __r, const _Value& __value) -> _Value { + return __real_body(__r.begin(), __r.end(), __value); + }, + __reduction); + }); +} + +//------------------------------------------------------------------------ +// parallel_transform_reduce +// +// Notation: +// r(i,j,init) returns reduction of init with reduction over [i,j) +// u(i) returns f(i,i+1,identity) for a hypothetical left identity element of r +// c(x,y) combines values x and y that were the result of r or u +//------------------------------------------------------------------------ + +template +struct __par_trans_red_body +{ + alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true + _Rp _M_brick_reduce; // Most likely to have non-empty layout + _Up _M_u; + _Cp _M_combine; + bool _M_has_sum; // Put last to minimize size of class + _Tp& + sum() + { + __TBB_ASSERT(_M_has_sum, "sum expected"); + return *(_Tp*)_M_sum_storage; + } + __par_trans_red_body(_Up __u, _Tp __init, _Cp __c, _Rp __r) + : _M_brick_reduce(__r), _M_u(__u), _M_combine(__c), _M_has_sum(true) + { + new (_M_sum_storage) _Tp(__init); + } + + __par_trans_red_body(__par_trans_red_body& __left, tbb::split) + : _M_brick_reduce(__left._M_brick_reduce), _M_u(__left._M_u), _M_combine(__left._M_combine), _M_has_sum(false) + { + } + + ~__par_trans_red_body() + { + // 17.6.5.12 tells us to not worry about catching exceptions from destructors. + if (_M_has_sum) + sum().~_Tp(); + } + + void + join(__par_trans_red_body& __rhs) + { + sum() = _M_combine(sum(), __rhs.sum()); + } + + void + operator()(const tbb::blocked_range<_Index>& __range) + { + _Index __i = __range.begin(); + _Index __j = __range.end(); + if (!_M_has_sum) + { + __TBB_ASSERT(__range.size() > 1, "there should be at least 2 elements"); + new (&_M_sum_storage) + _Tp(_M_combine(_M_u(__i), _M_u(__i + 1))); // The condition i+1 < j is provided by the grain size of 3 + _M_has_sum = true; + std::advance(__i, 2); + if (__i == __j) + return; + } + sum() = _M_brick_reduce(__i, __j, sum()); + } +}; + +template +_Tp +__parallel_transform_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, _Up __u, _Tp __init, _Cp __combine, + _Rp __brick_reduce) +{ + __par_trans_red_body<_Index, _Up, _Tp, _Cp, _Rp> __body(__u, __init, __combine, __brick_reduce); + // The grain size of 3 is used in order to provide mininum 2 elements for each body + tbb::this_task_arena::isolate( + [__first, __last, &__body]() { tbb::parallel_reduce(tbb::blocked_range<_Index>(__first, __last, 3), __body); }); + return __body.sum(); +} + +//------------------------------------------------------------------------ +// parallel_scan +//------------------------------------------------------------------------ + +template +class __trans_scan_body +{ + alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true + _Rp _M_brick_reduce; // Most likely to have non-empty layout + _Up _M_u; + _Cp _M_combine; + _Sp _M_scan; + bool _M_has_sum; // Put last to minimize size of class + public: + __trans_scan_body(_Up __u, _Tp __init, _Cp __combine, _Rp __reduce, _Sp __scan) + : _M_brick_reduce(__reduce), _M_u(__u), _M_combine(__combine), _M_scan(__scan), _M_has_sum(true) + { + new (_M_sum_storage) _Tp(__init); + } + + __trans_scan_body(__trans_scan_body& __b, tbb::split) + : _M_brick_reduce(__b._M_brick_reduce), _M_u(__b._M_u), _M_combine(__b._M_combine), _M_scan(__b._M_scan), + _M_has_sum(false) + { + } + + ~__trans_scan_body() + { + // 17.6.5.12 tells us to not worry about catching exceptions from destructors. + if (_M_has_sum) + sum().~_Tp(); + } + + _Tp& + sum() const + { + __TBB_ASSERT(_M_has_sum, "sum expected"); + return *(_Tp*)_M_sum_storage; + } + + void + operator()(const tbb::blocked_range<_Index>& __range, tbb::pre_scan_tag) + { + _Index __i = __range.begin(); + _Index __j = __range.end(); + if (!_M_has_sum) + { + new (&_M_sum_storage) _Tp(_M_u(__i)); + _M_has_sum = true; + ++__i; + if (__i == __j) + return; + } + sum() = _M_brick_reduce(__i, __j, sum()); + } + + void + operator()(const tbb::blocked_range<_Index>& __range, tbb::final_scan_tag) + { + sum() = _M_scan(__range.begin(), __range.end(), sum()); + } + + void + reverse_join(__trans_scan_body& __a) + { + if (_M_has_sum) + { + sum() = _M_combine(__a.sum(), sum()); + } + else + { + new (&_M_sum_storage) _Tp(__a.sum()); + _M_has_sum = true; + } + } + + void + assign(__trans_scan_body& __b) + { + sum() = __b.sum(); + } +}; + +template +_Index +__split(_Index __m) +{ + _Index __k = 1; + while (2 * __k < __m) + __k *= 2; + return __k; +} + +//------------------------------------------------------------------------ +// parallel_strict_scan +//------------------------------------------------------------------------ + +template +void +__upsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Rp __reduce, _Cp __combine) +{ + if (__m == 1) + __r[0] = __reduce(__i * __tilesize, __lastsize); + else + { + _Index __k = __split(__m); + tbb::parallel_invoke( + [=] { __upsweep(__i, __k, __tilesize, __r, __tilesize, __reduce, __combine); }, + [=] { __upsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, __reduce, __combine); }); + if (__m == 2 * __k) + __r[__m - 1] = __combine(__r[__k - 1], __r[__m - 1]); + } +} + +template +void +__downsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Tp __initial, _Cp __combine, + _Sp __scan) +{ + if (__m == 1) + __scan(__i * __tilesize, __lastsize, __initial); + else + { + const _Index __k = __split(__m); + tbb::parallel_invoke([=] { __downsweep(__i, __k, __tilesize, __r, __tilesize, __initial, __combine, __scan); }, + // Assumes that __combine never throws. + //TODO: Consider adding a requirement for user functors to be constant. + [=, &__combine] { + __downsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, + __combine(__initial, __r[__k - 1]), __combine, __scan); + }); + } +} + +// Adapted from Intel(R) Cilk(TM) version from cilkpub. +// Let i:len denote a counted interval of length n starting at i. s denotes a generalized-sum value. +// Expected actions of the functors are: +// reduce(i,len) -> s -- return reduction value of i:len. +// combine(s1,s2) -> s -- return merged sum +// apex(s) -- do any processing necessary between reduce and scan. +// scan(i,len,initial) -- perform scan over i:len starting with initial. +// The initial range 0:n is partitioned into consecutive subranges. +// reduce and scan are each called exactly once per subrange. +// Thus callers can rely upon side effects in reduce. +// combine must not throw an exception. +// apex is called exactly once, after all calls to reduce and before all calls to scan. +// For example, it's useful for allocating a __buffer used by scan but whose size is the sum of all reduction values. +// T must have a trivial constructor and destructor. +template +void +parallel_strict_scan(_ExecutionPolicy&&, _Index __n, _Tp __initial, _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex) +{ + tbb::this_task_arena::isolate([=, &__combine]() { + if (__n > 1) + { + _Index __p = tbb::this_task_arena::max_concurrency(); + const _Index __slack = 4; + _Index __tilesize = (__n - 1) / (__slack * __p) + 1; + _Index __m = (__n - 1) / __tilesize; + __buffer<_Tp> __buf(__m + 1); + _Tp* __r = __buf.get(); + __upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce, __combine); + // When __apex is a no-op and __combine has no side effects, a good optimizer + // should be able to eliminate all code between here and __apex. + // Alternatively, provide a default value for __apex that can be + // recognized by metaprogramming that conditionlly executes the following. + size_t __k = __m + 1; + _Tp __t = __r[__k - 1]; + while ((__k &= __k - 1)) + __t = __combine(__r[__k - 1], __t); + __apex(__combine(__initial, __t)); + __downsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __initial, __combine, + __scan); + return; + } + // Fewer than 2 elements in sequence, or out of memory. Handle has single block. + _Tp __sum = __initial; + if (__n) + __sum = __combine(__sum, __reduce(_Index(0), __n)); + __apex(__sum); + if (__n) + __scan(_Index(0), __n, __initial); + }); +} + +template +_Tp +__parallel_transform_scan(_ExecutionPolicy&&, _Index __n, _Up __u, _Tp __init, _Cp __combine, _Rp __brick_reduce, + _Sp __scan) +{ + __trans_scan_body<_Index, _Up, _Tp, _Cp, _Rp, _Sp> __body(__u, __init, __combine, __brick_reduce, __scan); + auto __range = tbb::blocked_range<_Index>(0, __n); + tbb::this_task_arena::isolate([__range, &__body]() { tbb::parallel_scan(__range, __body); }); + return __body.sum(); +} + +//------------------------------------------------------------------------ +// parallel_stable_sort +//------------------------------------------------------------------------ + +//------------------------------------------------------------------------ +// stable_sort utilities +// +// These are used by parallel implementations but do not depend on them. +//------------------------------------------------------------------------ + +template +class __merge_task : public tbb::task +{ + /*override*/ tbb::task* + execute(); + _RandomAccessIterator1 _M_xs, _M_xe; + _RandomAccessIterator2 _M_ys, _M_ye; + _RandomAccessIterator3 _M_zs; + _Compare _M_comp; + _Cleanup _M_cleanup; + _LeafMerge _M_leaf_merge; + + public: + __merge_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys, + _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _Cleanup __cleanup, + _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_leaf_merge(__leaf_merge) + { + } +}; + +#define __PSTL_MERGE_CUT_OFF 2000 + +template +tbb::task* +__merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _Cleanup, + _LeafMerge>::execute() +{ + typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1; + typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2; + typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType; + const _SizeType __n = (_M_xe - _M_xs) + (_M_ye - _M_ys); + const _SizeType __merge_cut_off = __PSTL_MERGE_CUT_OFF; + if (__n <= __merge_cut_off) + { + _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 + _M_cleanup(_M_xs, _M_xe); + _M_cleanup(_M_ys, _M_ye); + return nullptr; + } + else + { + _RandomAccessIterator1 __xm; + _RandomAccessIterator2 __ym; + if (_M_xe - _M_xs < _M_ye - _M_ys) + { + __ym = _M_ys + (_M_ye - _M_ys) / 2; + __xm = std::upper_bound(_M_xs, _M_xe, *__ym, _M_comp); + } + else + { + __xm = _M_xs + (_M_xe - _M_xs) / 2; + __ym = std::lower_bound(_M_ys, _M_ye, *__xm, _M_comp); + } + const _RandomAccessIterator3 __zm = _M_zs + ((__xm - _M_xs) + (__ym - _M_ys)); + tbb::task* __right = new (tbb::task::allocate_additional_child_of(*parent())) + __merge_task(__xm, _M_xe, __ym, _M_ye, __zm, _M_comp, _M_cleanup, _M_leaf_merge); + tbb::task::spawn(*__right); + tbb::task::recycle_as_continuation(); + _M_xe = __xm; + _M_ye = __ym; + } + return this; +} + +template +class __stable_sort_task : public tbb::task +{ + public: + typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1; + typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2; + typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType; + + private: + /*override*/ tbb::task* + execute(); + _RandomAccessIterator1 _M_xs, _M_xe; + _RandomAccessIterator2 _M_zs; + _Compare _M_comp; + _LeafSort _M_leaf_sort; + int32_t _M_inplace; + _SizeType _M_nsort; + + public: + __stable_sort_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __zs, + int32_t __inplace, _Compare __comp, _LeafSort __leaf_sort, _SizeType __n) + : _M_xs(__xs), _M_xe(__xe), _M_zs(__zs), _M_comp(__comp), _M_leaf_sort(__leaf_sort), _M_inplace(__inplace), + _M_nsort(__n) + { + } +}; + +//! Binary operator that does nothing +struct __binary_no_op +{ + template + void operator()(_T, _T) + { + } +}; + +#define __PSTL_STABLE_SORT_CUT_OFF 500 + +template +tbb::task* +__stable_sort_task<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::execute() +{ + const _SizeType __n = _M_xe - _M_xs; + const _SizeType __nmerge = _M_nsort > 0 ? _M_nsort : __n; + const _SizeType __sort_cut_off = __PSTL_STABLE_SORT_CUT_OFF; + if (__n <= __sort_cut_off) + { + _M_leaf_sort(_M_xs, _M_xe, _M_comp); + if (_M_inplace != 2) + __init_buf(_M_xs, _M_xe, _M_zs, _M_inplace == 0); + return NULL; + } + else + { + const _RandomAccessIterator1 __xm = _M_xs + __n / 2; + const _RandomAccessIterator2 __zm = _M_zs + (__xm - _M_xs); + const _RandomAccessIterator2 __ze = _M_zs + __n; + task* __m; + auto __move_values = [](_RandomAccessIterator2 __x, _RandomAccessIterator1 __z) { *__z = std::move(*__x); }; + auto __move_sequences = [](_RandomAccessIterator2 __first1, _RandomAccessIterator2 __last1, + _RandomAccessIterator1 __first2) { return std::move(__first1, __last1, __first2); }; + if (_M_inplace == 2) + __m = new (allocate_continuation()) + __merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare, + __serial_destroy, + __serial_move_merge>( + _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, __serial_destroy(), + __serial_move_merge(__nmerge, __move_values, + __move_sequences)); + else if (_M_inplace) + __m = new (allocate_continuation()) + __merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare, + __binary_no_op, __serial_move_merge>( + _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, __binary_no_op(), + __serial_move_merge(__nmerge, __move_values, + __move_sequences)); + else + { + auto __move_values = [](_RandomAccessIterator1 __x, _RandomAccessIterator2 __z) { *__z = std::move(*__x); }; + auto __move_sequences = [](_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, + _RandomAccessIterator2 __first2) { + return std::move(__first1, __last1, __first2); + }; + __m = new (allocate_continuation()) + __merge_task<_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Compare, + __binary_no_op, __serial_move_merge>( + _M_xs, __xm, __xm, _M_xe, _M_zs, _M_comp, __binary_no_op(), + __serial_move_merge(__nmerge, __move_values, + __move_sequences)); + } + __m->set_ref_count(2); + task* __right = new (__m->allocate_child()) + __stable_sort_task(__xm, _M_xe, __zm, !_M_inplace, _M_comp, _M_leaf_sort, __nmerge); + spawn(*__right); + recycle_as_child_of(*__m); + _M_xe = __xm; + _M_inplace = !_M_inplace; + } + return this; +} + +template +void +__parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp, + _LeafSort __leaf_sort, std::size_t __nsort = 0) +{ + tbb::this_task_arena::isolate([=, &__nsort]() { + //sorting based on task tree and parallel merge + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType; + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; + const _DifferenceType __n = __xe - __xs; + if (__nsort == 0) + __nsort = __n; + + const _DifferenceType __sort_cut_off = __PSTL_STABLE_SORT_CUT_OFF; + if (__n > __sort_cut_off) + { + assert(__nsort > 0 && __nsort <= __n); + __buffer<_ValueType> __buf(__n); + using tbb::task; + task::spawn_root_and_wait(*new (task::allocate_root()) + __stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>( + __xs, __xe, (_ValueType*)__buf.get(), 2, __comp, __leaf_sort, __nsort)); + return; + } + //serial sort + __leaf_sort(__xs, __xe, __comp); + }); +} + +//------------------------------------------------------------------------ +// parallel_merge +//------------------------------------------------------------------------ + +template +void +__parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, + _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, + _LeafMerge __leaf_merge) +{ + typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1; + typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2; + typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType; + const _SizeType __n = (__xe - __xs) + (__ye - __ys); + const _SizeType __merge_cut_off = __PSTL_MERGE_CUT_OFF; + if (__n <= __merge_cut_off) + { + // Fall back on serial merge + __leaf_merge(__xs, __xe, __ys, __ye, __zs, __comp); + } + else + { + tbb::this_task_arena::isolate([=]() { + typedef __merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, _Compare, + __binary_no_op, _LeafMerge> + _TaskType; + tbb::task::spawn_root_and_wait(*new (tbb::task::allocate_root()) _TaskType( + __xs, __xe, __ys, __ye, __zs, __comp, __binary_no_op(), __leaf_merge)); + }); + } +} + +//------------------------------------------------------------------------ +// parallel_invoke +//------------------------------------------------------------------------ +template +void +__parallel_invoke(_ExecutionPolicy&&, _F1&& __f1, _F2&& __f2) +{ + //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)); }); +} + +} // namespace __par_backend +} // namespace __pstl + +#endif /* __PSTL_parallel_backend_tbb_H */ diff --git a/libstdc++-v3/include/pstl/parallel_backend_utils.h b/libstdc++-v3/include/pstl/parallel_backend_utils.h new file mode 100644 index 0000000..4fc63c0 --- /dev/null +++ b/libstdc++-v3/include/pstl/parallel_backend_utils.h @@ -0,0 +1,195 @@ +// -*- C++ -*- +//===-- parallel_backend_utils.h ------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_parallel_backend_utils_H +#define __PSTL_parallel_backend_utils_H + +#include +#include +#include "utils.h" + +namespace __pstl +{ +namespace __par_backend +{ + +//! Destroy sequence [xs,xe) +struct __serial_destroy +{ + template + void + operator()(_RandomAccessIterator __zs, _RandomAccessIterator __ze) + { + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType; + while (__zs != __ze) + { + --__ze; + (*__ze).~_ValueType(); + } + } +}; + +//! Merge sequences [__xs,__xe) and [__ys,__ye) to output sequence [__zs,(__xe-__xs)+(__ye-__ys)), using std::move +template +struct __serial_move_merge +{ + const std::size_t _M_nmerge; + _MoveValues _M_move_values; + _MoveSequences _M_move_sequences; + + explicit __serial_move_merge(std::size_t __nmerge, _MoveValues __move_values, _MoveSequences __move_sequences) + : _M_nmerge(__nmerge), _M_move_values(__move_values), _M_move_sequences(__move_sequences) + { + } + template + void + operator()(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys, + _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp) + { + auto __n = _M_nmerge; + assert(__n > 0); + if (__xs != __xe) + { + if (__ys != __ye) + { + for (;;) + { + if (__comp(*__ys, *__xs)) + { + _M_move_values(__ys, __zs); + ++__zs, --__n; + if (++__ys == __ye) + { + break; + } + else if (__n == 0) + { + __zs = _M_move_sequences(__ys, __ye, __zs); + break; + } + else + { + } + } + else + { + _M_move_values(__xs, __zs); + ++__zs, --__n; + if (++__xs == __xe) + { + _M_move_sequences(__ys, __ye, __zs); + return; + } + else if (__n == 0) + { + __zs = _M_move_sequences(__xs, __xe, __zs); + _M_move_sequences(__ys, __ye, __zs); + return; + } + else + { + } + } + } + } + __ys = __xs; + __ye = __xe; + } + _M_move_sequences(__ys, __ye, __zs); + } +}; + +template +void +__init_buf(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _OutputIterator __zs, bool __bMove) +{ + const _OutputIterator __ze = __zs + (__xe - __xs); + typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType; + if (__bMove) + { + // Initialize the temporary buffer and move keys to it. + for (; __zs != __ze; ++__xs, ++__zs) + new (&*__zs) _ValueType(std::move(*__xs)); + } + else + { + // Initialize the temporary buffer + for (; __zs != __ze; ++__zs) + new (&*__zs) _ValueType; + } +} + +// TODO is this actually used anywhere? +template +class __stack +{ + typedef typename std::iterator_traits::value_type _ValueType; + typedef typename std::iterator_traits<_ValueType*>::difference_type _DifferenceType; + + _Buf _M_buf; + _ValueType* _M_ptr; + _DifferenceType _M_maxsize; + + __stack(const __stack&) = delete; + void + operator=(const __stack&) = delete; + + public: + __stack(_DifferenceType __max_size) : _M_buf(__max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); } + + ~__stack() + { + assert(size() <= _M_maxsize); + while (!empty()) + pop(); + } + + const _Buf& + buffer() const + { + return _M_buf; + } + size_t + size() const + { + assert(_M_ptr - _M_buf.get() <= _M_maxsize); + assert(_M_ptr - _M_buf.get() >= 0); + return _M_ptr - _M_buf.get(); + } + bool + empty() const + { + assert(_M_ptr >= _M_buf.get()); + return _M_ptr == _M_buf.get(); + } + void + push(const _ValueType& __v) + { + assert(size() < _M_maxsize); + new (_M_ptr) _ValueType(__v); + ++_M_ptr; + } + const _ValueType& + top() const + { + return *(_M_ptr - 1); + } + void + pop() + { + assert(_M_ptr > _M_buf.get()); + --_M_ptr; + (*_M_ptr).~_ValueType(); + } +}; + +} // namespace __par_backend +} // namespace __pstl + +#endif /* __PSTL_parallel_backend_utils_H */ diff --git a/libstdc++-v3/include/pstl/parallel_impl.h b/libstdc++-v3/include/pstl/parallel_impl.h new file mode 100644 index 0000000..2498003 --- /dev/null +++ b/libstdc++-v3/include/pstl/parallel_impl.h @@ -0,0 +1,81 @@ +// -*- C++ -*- +//===-- parallel_impl.h ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_parallel_impl_H +#define __PSTL_parallel_impl_H + +#include +// 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 + +namespace __pstl +{ +namespace __internal +{ + +//------------------------------------------------------------------------ +// parallel_find +//----------------------------------------------------------------------- +/** Return extremum value returned by brick f[i,j) for subranges [i,j) of [first,last) +Each f[i,j) must return a value in [i,j). */ +template +_Index +__parallel_find(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first) +{ + typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType; + const _DifferenceType __n = __last - __first; + _DifferenceType __initial_dist = __b_first ? __n : -1; + std::atomic<_DifferenceType> __extremum(__initial_dist); + // TODO: find out what is better here: parallel_for or parallel_reduce + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__comp, __f, __first, &__extremum](_Index __i, _Index __j) { + // See "Reducing Contention Through Priority Updates", PPoPP '13, for discussion of + // why using a shared variable scales fairly well in this situation. + if (__comp(__i - __first, __extremum)) + { + _Index __res = __f(__i, __j); + // If not '__last' returned then we found what we want so put this to extremum + if (__res != __j) + { + const _DifferenceType __k = __res - __first; + for (_DifferenceType __old = __extremum; __comp(__k, __old); + __old = __extremum) + { + __extremum.compare_exchange_weak(__old, __k); + } + } + } + }); + return __extremum != __initial_dist ? __first + __extremum : __last; +} + +//------------------------------------------------------------------------ +// parallel_or +//------------------------------------------------------------------------ +//! Return true if brick f[i,j) returns true for some subrange [i,j) of [first,last) +template +bool +__parallel_or(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f) +{ + std::atomic __found(false); + __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, + [__f, &__found](_Index __i, _Index __j) { + if (!__found.load(std::memory_order_relaxed) && __f(__i, __j)) + { + __found.store(true, std::memory_order_relaxed); + __par_backend::__cancel_execution(); + } + }); + return __found; +} + +} // namespace __internal +} // namespace __pstl + +#endif /* __PSTL_parallel_impl_H */ diff --git a/libstdc++-v3/include/pstl/pstl_config.h b/libstdc++-v3/include/pstl/pstl_config.h new file mode 100644 index 0000000..d799028 --- /dev/null +++ b/libstdc++-v3/include/pstl/pstl_config.h @@ -0,0 +1,174 @@ +// -*- C++ -*- +//===-- pstl_config.h -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_config_H +#define __PSTL_config_H + +#define PSTL_VERSION 203 +#define PSTL_VERSION_MAJOR (PSTL_VERSION / 100) +#define PSTL_VERSION_MINOR (PSTL_VERSION - PSTL_VERSION_MAJOR * 100) + +// Check the user-defined macro for parallel policies +#if defined(PSTL_USE_PARALLEL_POLICIES) +#undef __PSTL_USE_PAR_POLICIES +#define __PSTL_USE_PAR_POLICIES PSTL_USE_PARALLEL_POLICIES +// Check the internal macro for parallel policies +#elif !defined(__PSTL_USE_PAR_POLICIES) +#define __PSTL_USE_PAR_POLICIES 1 +#endif + +#if __PSTL_USE_PAR_POLICIES +#if !defined(__PSTL_PAR_BACKEND_TBB) +#define __PSTL_PAR_BACKEND_TBB 1 +#endif +#else +#undef __PSTL_PAR_BACKEND_TBB +#endif + +// Check the user-defined macro for warnings +#if defined(PSTL_USAGE_WARNINGS) +#undef __PSTL_USAGE_WARNINGS +#define __PSTL_USAGE_WARNINGS PSTL_USAGE_WARNINGS +// Check the internal macro for warnings +#elif !defined(__PSTL_USAGE_WARNINGS) +#define __PSTL_USAGE_WARNINGS 0 +#endif + +// Portability "#pragma" definition +#ifdef _MSC_VER +#define __PSTL_PRAGMA(x) __pragma(x) +#else +#define __PSTL_PRAGMA(x) _Pragma(#x) +#endif + +#define __PSTL_STRING_AUX(x) #x +#define __PSTL_STRING(x) __PSTL_STRING_AUX(x) +#define __PSTL_STRING_CONCAT(x, y) x #y + +// note that when ICC or Clang is in use, __PSTL_GCC_VERSION might not fully match +// the actual GCC version on the system. +#define __PSTL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) + +#if __clang__ +// according to clang documentation, version can be vendor specific +#define __PSTL_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) +#endif + +// Enable SIMD for compilers that support OpenMP 4.0 +#if (_OPENMP >= 201307) || (__INTEL_COMPILER >= 1600) || (!defined(__INTEL_COMPILER) && __PSTL_GCC_VERSION >= 40900) +#define __PSTL_PRAGMA_SIMD __PSTL_PRAGMA(omp simd) +#define __PSTL_PRAGMA_DECLARE_SIMD __PSTL_PRAGMA(omp declare simd) +#define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) __PSTL_PRAGMA(omp simd reduction(PRM)) +#elif !defined(_MSC_VER) //#pragma simd +#define __PSTL_PRAGMA_SIMD __PSTL_PRAGMA(simd) +#define __PSTL_PRAGMA_DECLARE_SIMD +#define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) __PSTL_PRAGMA(simd reduction(PRM)) +#else //no simd +#define __PSTL_PRAGMA_SIMD +#define __PSTL_PRAGMA_DECLARE_SIMD +#define __PSTL_PRAGMA_SIMD_REDUCTION(PRM) +#endif //Enable SIMD + +#if (__INTEL_COMPILER) +#define __PSTL_PRAGMA_FORCEINLINE __PSTL_PRAGMA(forceinline) +#else +#define __PSTL_PRAGMA_FORCEINLINE +#endif + +#if (__INTEL_COMPILER >= 1900) +#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_EXCLUSIVE_SCAN(PRM) __PSTL_PRAGMA(omp scan exclusive(PRM)) +#else +#define __PSTL_PRAGMA_SIMD_SCAN(PRM) +#define __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) +#define __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) +#endif + +// 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_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT \ + (_MSC_VER >= 1900 || __cplusplus >= 201300L || __cpp_lib_robust_nonmodifying_seq_ops == 201304) +#define __PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT \ + (_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_VARIABLE_TEMPLATES_PRESENT \ + (!__INTEL_COMPILER || __INTEL_COMPILER >= 1700) && (_MSC_FULL_VER >= 190023918 || __cplusplus >= 201402L) + +#define __PSTL_EARLYEXIT_PRESENT (__INTEL_COMPILER >= 1800) +#define __PSTL_MONOTONIC_PRESENT (__INTEL_COMPILER >= 1800) + +#if (__INTEL_COMPILER >= 1900 || !defined(__INTEL_COMPILER) && __PSTL_GCC_VERSION >= 40900 || _OPENMP >= 201307) +#define __PSTL_UDR_PRESENT 1 +#else +#define __PSTL_UDR_PRESENT 0 +#endif + +#define __PSTL_UDS_PRESENT (__INTEL_COMPILER >= 1900 && __INTEL_COMPILER_BUILD_DATE >= 20180626) + +#if __PSTL_EARLYEXIT_PRESENT +#define __PSTL_PRAGMA_SIMD_EARLYEXIT __PSTL_PRAGMA(omp simd early_exit) +#else +#define __PSTL_PRAGMA_SIMD_EARLYEXIT +#endif + +#if __PSTL_MONOTONIC_PRESENT +#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)) +#else +#define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) +#define __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2) +#endif + +// Declaration of reduction functor, where +// NAME - the name of the functor +// OP - type of the callable object with the reduction operation +// omp_in - refers to the local partial result +// omp_out - refers to the final value of the combiner operator +// omp_priv - refers to the private copy of the initial value +// omp_orig - refers to the original variable to be reduced +#define __PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP) \ + __PSTL_PRAGMA(omp declare reduction(NAME : OP : omp_out(omp_in)) initializer(omp_priv = omp_orig)) + +#if (__INTEL_COMPILER >= 1600) +#define __PSTL_PRAGMA_VECTOR_UNALIGNED __PSTL_PRAGMA(vector unaligned) +#else +#define __PSTL_PRAGMA_VECTOR_UNALIGNED +#endif + +// Check the user-defined macro to use non-temporal stores +#if defined(PSTL_USE_NONTEMPORAL_STORES) && (__INTEL_COMPILER >= 1600) +#define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED __PSTL_PRAGMA(vector nontemporal) +#else +#define __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED +#endif + +#if _MSC_VER || __INTEL_COMPILER //the preprocessors don't type a message location +#define __PSTL_PRAGMA_LOCATION __FILE__ ":" __PSTL_STRING(__LINE__) ": [Parallel STL message]: " +#else +#define __PSTL_PRAGMA_LOCATION " [Parallel STL message]: " +#endif + +#define __PSTL_PRAGMA_MESSAGE_IMPL(x) __PSTL_PRAGMA(message(__PSTL_STRING_CONCAT(__PSTL_PRAGMA_LOCATION, x))) + +#if __PSTL_USAGE_WARNINGS +#define __PSTL_PRAGMA_MESSAGE(x) __PSTL_PRAGMA_MESSAGE_IMPL(x) +#define __PSTL_PRAGMA_MESSAGE_POLICIES(x) __PSTL_PRAGMA_MESSAGE_IMPL(x) +#else +#define __PSTL_PRAGMA_MESSAGE(x) +#define __PSTL_PRAGMA_MESSAGE_POLICIES(x) +#endif + +// broken macros +#define __PSTL_CPP11_STD_ROTATE_BROKEN ((__GLIBCXX__ && __GLIBCXX__ < 20150716) || (_MSC_VER && _MSC_VER < 1800)) + +#define __PSTL_ICC_18_OMP_SIMD_BROKEN (__INTEL_COMPILER == 1800) + +#endif /* __PSTL_config_H */ diff --git a/libstdc++-v3/include/pstl/unseq_backend_simd.h b/libstdc++-v3/include/pstl/unseq_backend_simd.h new file mode 100644 index 0000000..b48b07b --- /dev/null +++ b/libstdc++-v3/include/pstl/unseq_backend_simd.h @@ -0,0 +1,855 @@ +// -*- C++ -*- +//===-- unseq_backend_simd.h ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_unseq_backend_simd_H +#define __PSTL_unseq_backend_simd_H + +#include + +#include "utils.h" + +// This header defines the minimum set of vector routines required +// to support parallel STL. +namespace __pstl +{ +namespace __unseq_backend +{ + +// Expect vector width up to 64 (or 512 bit) +const std::size_t __lane_size = 64; + +template +_Iterator +__simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept +{ + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + __f(__first[__i]); + + return __first + __n; +} + +template +_Iterator2 +__simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept +{ + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + __f(__first1[__i], __first2[__i]); + return __first2 + __n; +} + +template +_Iterator3 +__simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3, + _Function __f) noexcept +{ + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + __f(__first1[__i], __first2[__i], __first3[__i]); + return __first3 + __n; +} + +// TODO: check whether __simd_first() can be used here +template +bool +__simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept +{ +#if __PSTL_EARLYEXIT_PRESENT + _DifferenceType __i; + __PSTL_PRAGMA_VECTOR_UNALIGNED + __PSTL_PRAGMA_SIMD_EARLYEXIT + for (__i = 0; __i < __n; ++__i) + if (__pred(__first[__i])) + break; + return __i < __n; +#else + _DifferenceType __block_size = 4 < __n ? 4 : __n; + const _Index __last = __first + __n; + while (__last != __first) + { + int32_t __flag = 1; + __PSTL_PRAGMA_SIMD_REDUCTION(& : __flag) + for (_DifferenceType __i = 0; __i < __block_size; ++__i) + if (__pred(*(__first + __i))) + __flag = 0; + if (!__flag) + return true; + + __first += __block_size; + if (__last - __first >= __block_size << 1) + { + // Double the block _Size. Any unnecessary iterations can be amortized against work done so far. + __block_size <<= 1; + } + else + { + __block_size = __last - __first; + } + } + return false; +#endif +} + +template +_Index +__simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept +{ +#if __PSTL_EARLYEXIT_PRESENT + _DifferenceType __i = __begin; + __PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part + __PSTL_PRAGMA_SIMD_EARLYEXIT for (; __i < __end; ++__i) + { + if (__comp(__first, __i)) + { + break; + } + } + return __first + __i; +#else + // Experiments show good block sizes like this + const _DifferenceType __block_size = 8; + alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; + while (__end - __begin >= __block_size) + { + _DifferenceType __found = 0; + __PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part + __PSTL_PRAGMA_SIMD_REDUCTION(| + : __found) for (_DifferenceType __i = __begin; __i < __begin + __block_size; + ++__i) + { + const _DifferenceType __t = __comp(__first, __i); + __lane[__i - __begin] = __t; + __found |= __t; + } + if (__found) + { + _DifferenceType __i; + // This will vectorize + for (__i = 0; __i < __block_size; ++__i) + { + if (__lane[__i]) + { + break; + } + } + return __first + __begin + __i; + } + __begin += __block_size; + } + + //Keep remainder scalar + while (__begin != __end) + { + if (__comp(__first, __begin)) + { + return __first + __begin; + } + ++__begin; + } + return __first + __end; +#endif //__PSTL_EARLYEXIT_PRESENT +} + +template +std::pair<_Index1, _Index2> +__simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept +{ +#if __PSTL_EARLYEXIT_PRESENT + _DifferenceType __i = 0; + __PSTL_PRAGMA_VECTOR_UNALIGNED + __PSTL_PRAGMA_SIMD_EARLYEXIT + for (; __i < __n; ++__i) + if (__pred(__first1[__i], __first2[__i])) + break; + return std::make_pair(__first1 + __i, __first2 + __i); +#else + const _Index1 __last1 = __first1 + __n; + const _Index2 __last2 = __first2 + __n; + // Experiments show good block sizes like this + const _DifferenceType __block_size = 8; + alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; + while (__last1 - __first1 >= __block_size) + { + _DifferenceType __found = 0; + _DifferenceType __i; + __PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part + __PSTL_PRAGMA_SIMD_REDUCTION(| + : __found) for (__i = 0; __i < __block_size; ++__i) + { + const _DifferenceType __t = __pred(__first1[__i], __first2[__i]); + __lane[__i] = __t; + __found |= __t; + } + if (__found) + { + _DifferenceType __i; + // This will vectorize + for (__i = 0; __i < __block_size; ++__i) + { + if (__lane[__i]) + break; + } + return std::make_pair(__first1 + __i, __first2 + __i); + } + __first1 += __block_size; + __first2 += __block_size; + } + + //Keep remainder scalar + for (; __last1 != __first1; ++__first1, ++__first2) + if (__pred(*(__first1), *(__first2))) + return std::make_pair(__first1, __first2); + + return std::make_pair(__last1, __last2); +#endif //__PSTL_EARLYEXIT_PRESENT +} + +template +_DifferenceType +__simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept +{ + _DifferenceType __count = 0; + __PSTL_PRAGMA_SIMD_REDUCTION(+ : __count) + for (_DifferenceType __i = 0; __i < __n; ++__i) + if (__pred(*(__index + __i))) + ++__count; + + return __count; +} + +template +_OutputIterator +__simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, + _BinaryPredicate __pred) noexcept +{ + if (__n == 0) + return __result; + + _DifferenceType __cnt = 1; + __result[0] = __first[0]; + + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 1; __i < __n; ++__i) + { + __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) + if (!__pred(__first[__i], __first[__i - 1])) + { + __result[__cnt] = __first[__i]; + ++__cnt; + } + } + return __result + __cnt; +} + +template +_OutputIterator +__simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept +{ + __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + __assigner(__first + __i, __result + __i); + return __result + __n; +} + +template +_OutputIterator +__simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept +{ + _DifferenceType __cnt = 0; + + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + { + __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) + if (__pred(__first[__i])) + { + __result[__cnt] = __first[__i]; + ++__cnt; + } + } + return __result + __cnt; +} + +template +_DifferenceType +__simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept +{ + _DifferenceType __count = 0; + + __PSTL_PRAGMA_SIMD_REDUCTION(+ : __count) + for (_DifferenceType __i = 0; __i < __n; ++__i) + { + __mask[__i] = !__pred(__first[__i], __first[__i - 1]); + __count += __mask[__i]; + } + return __count; +} + +template +_DifferenceType +__simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept +{ + _DifferenceType __count = 0; + + __PSTL_PRAGMA_SIMD_REDUCTION(+ : __count) + for (_DifferenceType __i = 0; __i < __n; ++__i) + { + __mask[__i] = __pred(__first[__i]); + __count += __mask[__i]; + } + return __count; +} + +template +void +__simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask, + _Assigner __assigner) noexcept +{ + _DifferenceType __cnt = 0; + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + { + if (__mask[__i]) + { + __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) + { + __assigner(__first + __i, __result + __cnt); + ++__cnt; + } + } + } +} + +template +void +__simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, bool* __mask) noexcept +{ + _DifferenceType __cnt_true = 0, __cnt_false = 0; + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + { + __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1) + if (__mask[__i]) + { + __out_true[__cnt_true] = __first[__i]; + ++__cnt_true; + } + else + { + __out_false[__cnt_false] = __first[__i]; + ++__cnt_false; + } + } +} + +template +_Index +__simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept +{ + __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + __first[__i] = __value; + return __first + __n; +} + +template +_Index +__simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept +{ + __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __size; ++__i) + __first[__i] = __g(); + return __first + __size; +} + +template +_Index +__simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept +{ + if (__last - __first < 2) + return __last; + + typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType; + _DifferenceType __i = 0; + +#if __PSTL_EARLYEXIT_PRESENT + //Some compiler versions fail to compile the following loop when iterators are used. Indices are used instead + const _DifferenceType __n = __last - __first - 1; + __PSTL_PRAGMA_VECTOR_UNALIGNED + __PSTL_PRAGMA_SIMD_EARLYEXIT + for (; __i < __n; ++__i) + if (__pred(__first[__i], __first[__i + 1])) + break; + + return __i < __n ? __first + __i : __last; +#else + // Experiments show good block sizes like this + //TODO: to consider tuning block_size for various data types + const _DifferenceType __block_size = 8; + alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; + while (__last - __first >= __block_size) + { + _DifferenceType __found = 0; + __PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part + __PSTL_PRAGMA_SIMD_REDUCTION(| + : __found) for (__i = 0; __i < __block_size - 1; ++__i) + { + //TODO: to improve SIMD vectorization + const _DifferenceType __t = __pred(*(__first + __i), *(__first + __i + 1)); + __lane[__i] = __t; + __found |= __t; + } + + //Process a pair of elements on a boundary of a data block + if (__first + __block_size < __last && __pred(*(__first + __i), *(__first + __i + 1))) + __lane[__i] = __found = 1; + + if (__found) + { + if (__or_semantic) + return __first; + + // This will vectorize + for (__i = 0; __i < __block_size; ++__i) + if (__lane[__i]) + break; + return __first + __i; //As far as found is true a __result (__lane[__i] is true) is guaranteed + } + __first += __block_size; + } + //Process the rest elements + for (; __last - __first > 1; ++__first) + if (__pred(*__first, *(__first + 1))) + return __first; + + return __last; +#endif +} + +// It was created to reduce the code inside std::enable_if +template +using is_arithmetic_plus = std::integral_constant::value && + std::is_same<_BinaryOperation, std::plus<_Tp>>::value>; + +template +typename std::enable_if::value, _Tp>::type +__simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept +{ + __PSTL_PRAGMA_SIMD_REDUCTION(+ : __init) + for (_DifferenceType __i = 0; __i < __n; ++__i) + __init += __f(__i); + return __init; +} + +template +typename std::enable_if::value, _Tp>::type +__simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept +{ + const std::size_t __block_size = __lane_size / sizeof(_Tp); + if (__n > 2 * __block_size && __block_size > 1) + { + alignas(__lane_size) char __lane_[__lane_size]; + _Tp* __lane = reinterpret_cast<_Tp*>(__lane_); + + // initializer + __PSTL_PRAGMA_SIMD + for (_Size __i = 0; __i < __block_size; ++__i) + { + ::new (__lane + __i) _Tp(__binary_op(__f(__i), __f(__block_size + __i))); + } + // main loop + _Size __i = 2 * __block_size; + const _Size last_iteration = __block_size * (__n / __block_size); + for (; __i < last_iteration; __i += __block_size) + { + __PSTL_PRAGMA_SIMD + for (_Size __j = 0; __j < __block_size; ++__j) + { + __lane[__j] = __binary_op(__lane[__j], __f(__i + __j)); + } + } + // remainder + __PSTL_PRAGMA_SIMD + for (_Size __j = 0; __j < __n - last_iteration; ++__j) + { + __lane[__j] = __binary_op(__lane[__j], __f(last_iteration + __j)); + } + // combiner + for (_Size __i = 0; __i < __block_size; ++__i) + { + __init = __binary_op(__init, __lane[__i]); + } + // destroyer + __PSTL_PRAGMA_SIMD + for (_Size __i = 0; __i < __block_size; ++__i) + { + __lane[__i].~_Tp(); + } + } + else + { + for (_Size __i = 0; __i < __n; ++__i) + { + __init = __binary_op(__init, __f(__i)); + } + } + return __init; +} + +// Exclusive scan for "+" and arithmetic types +template +typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type +__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, + _BinaryOperation, /*Inclusive*/ std::false_type) +{ + __PSTL_PRAGMA_SIMD_SCAN(+ : __init) + for (_Size __i = 0; __i < __n; ++__i) + { + __result[__i] = __init; + __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init) + __init += __unary_op(__first[__i]); + } + 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 +template +struct _Combiner +{ + _Tp __value; + _BinaryOp* __bin_op; // Here is a pointer to function because of default ctor + + _Combiner() : __value{}, __bin_op(nullptr) {} + _Combiner(const _Tp& value, const _BinaryOp* bin_op) : __value(value), __bin_op(const_cast<_BinaryOp*>(bin_op)) {} + _Combiner(const _Combiner& __obj) : __value{}, __bin_op(__obj.__bin_op) {} + + void + operator()(const _Combiner& __obj) + { + __value = (*__bin_op)(__value, __obj.__value); + } +}; + +// Exclusive scan for other binary operations and types +template +typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type +__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, + _BinaryOperation __binary_op, /*Inclusive*/ std::false_type) +{ + typedef _Combiner<_Tp, _BinaryOperation> _CombinerType; + _CombinerType __init_{__init, &__binary_op}; + + __PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType) + + __PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_) + for (_Size __i = 0; __i < __n; ++__i) + { + __result[__i] = __init_.__value; + __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init_) + __PSTL_PRAGMA_FORCEINLINE + __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i])); + } + return std::make_pair(__result + __n, __init_.__value); +} + +// Inclusive scan for "+" and arithmetic types +template +typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type +__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, + _BinaryOperation, /*Inclusive*/ std::true_type) +{ + __PSTL_PRAGMA_SIMD_SCAN(+ : __init) + for (_Size __i = 0; __i < __n; ++__i) + { + __init += __unary_op(__first[__i]); + __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init) + __result[__i] = __init; + } + return std::make_pair(__result + __n, __init); +} + +// Inclusive scan for other binary operations and types +template +typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type +__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, + _BinaryOperation __binary_op, std::true_type) +{ + typedef _Combiner<_Tp, _BinaryOperation> _CombinerType; + _CombinerType __init_{__init, &__binary_op}; + + __PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType) + + __PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_) + for (_Size __i = 0; __i < __n; ++__i) + { + __PSTL_PRAGMA_FORCEINLINE + __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i])); + __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init_) + __result[__i] = __init_.__value; + } + return std::make_pair(__result + __n, __init_.__value); +} + +// [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. +template +_ForwardIterator +__simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept +{ + if (__n == 0) + { + return __first; + } + + typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType; + struct _ComplexType + { + _ValueType __min_val; + _Size __min_ind; + _Compare* __min_comp; + + _ComplexType() : __min_val{}, __min_ind{}, __min_comp(nullptr) {} + _ComplexType(const _ValueType& val, const _Compare* comp) + : __min_val(val), __min_ind(0), __min_comp(const_cast<_Compare*>(comp)) + { + } + _ComplexType(const _ComplexType& __obj) + : __min_val(__obj.__min_val), __min_ind(__obj.__min_ind), __min_comp(__obj.__min_comp) + { + } + + __PSTL_PRAGMA_DECLARE_SIMD + void + operator()(const _ComplexType& __obj) + { + if (!(*__min_comp)(__min_val, __obj.__min_val) && + ((*__min_comp)(__obj.__min_val, __min_val) || __obj.__min_ind - __min_ind < 0)) + { + __min_val = __obj.__min_val; + __min_ind = __obj.__min_ind; + } + } + }; + + _ComplexType __init{*__first, &__comp}; + + __PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType) + + __PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init) + for (_Size __i = 1; __i < __n; ++__i) + { + const _ValueType __min_val = __init.__min_val; + const _ValueType __current = __first[__i]; + if (__comp(__current, __min_val)) + { + __init.__min_val = __current; + __init.__min_ind = __i; + } + } + return __first + __init.__min_ind; +} + +// [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible. +// complexity [violation] - We will have at most (2*(__n-1) + 4*number_of_lanes) comparisons instead of at most [1.5*(__n-1)]. +template +std::pair<_ForwardIterator, _ForwardIterator> +__simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept +{ + if (__n == 0) + { + return std::make_pair(__first, __first); + } + typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType; + + struct _ComplexType + { + _ValueType __min_val; + _ValueType __max_val; + _Size __min_ind; + _Size __max_ind; + _Compare* __minmax_comp; + + _ComplexType() : __min_val{}, __max_val{}, __min_ind{}, __max_ind{}, __minmax_comp(nullptr) {} + _ComplexType(const _ValueType& min_val, const _ValueType& max_val, const _Compare* comp) + : __min_val(min_val), __max_val(max_val), __min_ind(0), __max_ind(0), + __minmax_comp(const_cast<_Compare*>(comp)) + { + } + _ComplexType(const _ComplexType& __obj) + : __min_val(__obj.__min_val), __max_val(__obj.__max_val), __min_ind(__obj.__min_ind), + __max_ind(__obj.__max_ind), __minmax_comp(__obj.__minmax_comp) + { + } + + void + operator()(const _ComplexType& __obj) + { + // min + if ((*__minmax_comp)(__obj.__min_val, __min_val)) + { + __min_val = __obj.__min_val; + __min_ind = __obj.__min_ind; + } + else if (!(*__minmax_comp)(__min_val, __obj.__min_val)) + { + __min_val = __obj.__min_val; + __min_ind = (__min_ind - __obj.__min_ind < 0) ? __min_ind : __obj.__min_ind; + } + + // max + if ((*__minmax_comp)(__max_val, __obj.__max_val)) + { + __max_val = __obj.__max_val; + __max_ind = __obj.__max_ind; + } + else if (!(*__minmax_comp)(__obj.__max_val, __max_val)) + { + __max_val = __obj.__max_val; + __max_ind = (__max_ind - __obj.__max_ind < 0) ? __obj.__max_ind : __max_ind; + } + } + }; + + _ComplexType __init{*__first, *__first, &__comp}; + + __PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType); + + __PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init) + for (_Size __i = 1; __i < __n; ++__i) + { + auto __min_val = __init.__min_val; + auto __max_val = __init.__max_val; + auto __current = __first + __i; + if (__comp(*__current, __min_val)) + { + __init.__min_val = *__current; + __init.__min_ind = __i; + } + else if (!__comp(*__current, __max_val)) + { + __init.__max_val = *__current; + __init.__max_ind = __i; + } + } + return std::make_pair(__first + __init.__min_ind, __first + __init.__max_ind); +} + +template +std::pair<_OutputIterator1, _OutputIterator2> +__simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true, + _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept +{ + _DifferenceType __cnt_true = 0, __cnt_false = 0; + + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 0; __i < __n; ++__i) + { + __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1) + if (__pred(__first[__i])) + { + __out_true[__cnt_true] = __first[__i]; + ++__cnt_true; + } + else + { + __out_false[__cnt_false] = __first[__i]; + ++__cnt_false; + } + } + return std::make_pair(__out_true + __cnt_true, __out_false + __cnt_false); +} + +template +_ForwardIterator1 +__simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred) noexcept +{ + typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferencType; + + const _DifferencType __n1 = __last - __first; + const _DifferencType __n2 = __s_last - __s_first; + if (__n1 == 0 || __n2 == 0) + { + return __last; // according to the standard + } + + // Common case + // If first sequence larger than second then we'll run simd_first with parameters of first sequence. + // Otherwise, vice versa. + if (__n1 < __n2) + { + for (; __first != __last; ++__first) + { + if (__simd_or(__s_first, __n2, + __internal::__equal_value_by_pred(*__first, __pred))) + { + return __first; + } + } + } + else + { + for (; __s_first != __s_last; ++__s_first) + { + const auto __result = __simd_first(__first, _DifferencType(0), __n1, + [__s_first, &__pred](_ForwardIterator1 __it, _DifferencType __i) { + return __pred(__it[__i], *__s_first); + }); + if (__result != __last) + { + return __result; + } + } + } + return __last; +} + +template +_RandomAccessIterator +__simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept +{ + // find first element we need to remove + auto __current = + __simd_first(__first, _DifferenceType(0), __n, + [&__pred](_RandomAccessIterator __it, _DifferenceType __i) { return __pred(__it[__i]); }); + __n -= __current - __first; + + // if we have in sequence only one element that pred(__current[1]) != false we can exit the function + if (__n < 2) + { + return __current; + } + + _DifferenceType __cnt = 0; + __PSTL_PRAGMA_SIMD + for (_DifferenceType __i = 1; __i < __n; ++__i) + { + __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1) + if (!__pred(__current[__i])) + { + __current[__cnt] = std::move(__current[__i]); + ++__cnt; + } + } + return __current + __cnt; +} +} // namespace __unseq_backend +} // namespace __pstl + +#endif /* __PSTL_unseq_backend_simd_H */ diff --git a/libstdc++-v3/include/pstl/utils.h b/libstdc++-v3/include/pstl/utils.h new file mode 100644 index 0000000..00ccc62 --- /dev/null +++ b/libstdc++-v3/include/pstl/utils.h @@ -0,0 +1,222 @@ +// -*- C++ -*- +//===-- utils.h -----------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_utils_H +#define __PSTL_utils_H + +#include +#include + +namespace __pstl +{ +namespace __internal +{ + +template +typename std::result_of<_Fp()>::type +__except_handler(_Fp __f) +{ + try + { + return __f(); + } + catch (const std::bad_alloc&) + { + throw; // re-throw bad_alloc according to the standard [algorithms.parallel.exceptions] + } + catch (...) + { + std::terminate(); // Good bye according to the standard [algorithms.parallel.exceptions] + } +} + +template +void +__invoke_if(std::true_type, _Fp __f) +{ + __f(); +} + +template +void +__invoke_if(std::false_type, _Fp __f) +{ +} + +template +void +__invoke_if_not(std::false_type, _Fp __f) +{ + __f(); +} + +template +void +__invoke_if_not(std::true_type, _Fp __f) +{ +} + +template +typename std::result_of<_F1()>::type +__invoke_if_else(std::true_type, _F1 __f1, _F2 __f2) +{ + return __f1(); +} + +template +typename std::result_of<_F2()>::type +__invoke_if_else(std::false_type, _F1 __f1, _F2 __f2) +{ + return __f2(); +} + +//! Unary operator that returns reference to its argument. +struct __no_op +{ + template + _Tp&& + operator()(_Tp&& __a) const + { + return std::forward<_Tp>(__a); + } +}; + +//! Logical negation of a predicate +template +class __not_pred +{ + _Pred _M_pred; + + public: + explicit __not_pred(_Pred __pred) : _M_pred(__pred) {} + + template + bool + operator()(_Args&&... __args) + { + return !_M_pred(std::forward<_Args>(__args)...); + } +}; + +template +class __reorder_pred +{ + _Pred _M_pred; + + public: + explicit __reorder_pred(_Pred __pred) : _M_pred(__pred) {} + + template + bool + operator()(_FTp&& __a, _STp&& __b) + { + return _M_pred(std::forward<_STp>(__b), std::forward<_FTp>(__a)); + } +}; + +//! "==" comparison. +/** Not called "equal" to avoid (possibly unfounded) concerns about accidental invocation via + argument-dependent name lookup by code expecting to find the usual std::equal. */ +class __pstl_equal +{ + public: + explicit __pstl_equal() {} + + template + bool + operator()(_Xp&& __x, _Yp&& __y) const + { + return std::forward<_Xp>(__x) == std::forward<_Yp>(__y); + } +}; + +//! "<" comparison. +class __pstl_less +{ + public: + explicit __pstl_less() {} + + template + bool + operator()(_Xp&& __x, _Yp&& __y) const + { + return std::forward<_Xp>(__x) < std::forward<_Yp>(__y); + } +}; + +//! Like a polymorphic lambda for pred(...,value) +template +class __equal_value_by_pred +{ + const _Tp& _M_value; + _Predicate _M_pred; + + public: + __equal_value_by_pred(const _Tp& __value, _Predicate __pred) : _M_value(__value), _M_pred(__pred) {} + + template + bool + operator()(_Arg&& __arg) + { + return _M_pred(std::forward<_Arg>(__arg), _M_value); + } +}; + +//! Like a polymorphic lambda for ==value +template +class __equal_value +{ + const _Tp& _M_value; + + public: + explicit __equal_value(const _Tp& __value) : _M_value(__value) {} + + template + bool + operator()(_Arg&& __arg) const + { + return std::forward<_Arg>(__arg) == _M_value; + } +}; + +//! Logical negation of ==value +template +class __not_equal_value +{ + const _Tp& _M_value; + + public: + explicit __not_equal_value(const _Tp& __value) : _M_value(__value) {} + + template + bool + operator()(_Arg&& __arg) const + { + return !(std::forward<_Arg>(__arg) == _M_value); + } +}; + +template +_ForwardIterator +__cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp) +{ + if (__a < __b) + { // we should return closer iterator + return __comp(*__b, *__a) ? __b : __a; + } + else + { + return __comp(*__a, *__b) ? __a : __b; + } +} + +} // namespace __internal +} // namespace __pstl + +#endif /* __PSTL_utils_H */ diff --git a/libstdc++-v3/include/std/algorithm b/libstdc++-v3/include/std/algorithm index 955a5d4..73c87d5 100644 --- a/libstdc++-v3/include/std/algorithm +++ b/libstdc++-v3/include/std/algorithm @@ -61,6 +61,21 @@ #include #include +#if __cplusplus > 201402L +// Parallel STL algorithms +# if __PSTL_EXECUTION_POLICIES_DEFINED +// If has already been included, pull in implementations +# include +# else +// Otherwise just pull in forward declarations +# include +# define __PSTL_ALGORITHM_FORWARD_DECLARED 1 +# endif + +// Feature test macro for parallel algorithms +# define __cpp_lib_parallel_algorithm 201703L +#endif // C++17 + #ifdef _GLIBCXX_PARALLEL # include #endif diff --git a/libstdc++-v3/include/std/execution b/libstdc++-v3/include/std/execution new file mode 100644 index 0000000..2d821e5 --- /dev/null +++ b/libstdc++-v3/include/std/execution @@ -0,0 +1,56 @@ +// -*- C++ -*- + +// Copyright (C) 2018-2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +#ifndef _GLIBCXX_EXECUTION +#define _GLIBCXX_EXECUTION 1 + +#pragma GCC system_header + +#if __cplusplus >= 201703L +# include +# include + +# define __PSTL_EXECUTION_POLICIES_DEFINED 1 + +// Algorithm implementation +# if __PSTL_ALGORITHM_FORWARD_DECLARED +# include +# endif + +// Numeric implementation +# if __PSTL_NUMERIC_FORWARD_DECLARED +# include +# endif + +// Memory implementation +# if __PSTL_NUMERIC_FORWARD_DECLARED +# include +# endif + +// Feature test macro for parallel algorithms +# define __cpp_lib_parallel_algorithm 201603L + +#endif // C++17 + +#endif /* _GLIBCXX_EXECUTION */ diff --git a/libstdc++-v3/include/std/memory b/libstdc++-v3/include/std/memory index 00a85ee..57ccf93 100644 --- a/libstdc++-v3/include/std/memory +++ b/libstdc++-v3/include/std/memory @@ -363,4 +363,18 @@ _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif // C++11 +#if __cplusplus > 201402L +// Parallel STL algorithms +# if __PSTL_EXECUTION_POLICIES_DEFINED +// If has already been included, pull in implementations +# include +# else +// Otherwise just pull in forward declarations +# include +# endif + +// Feature test macro for parallel algorithms +# define __cpp_lib_parallel_algorithm 201703L +#endif // C++17 + #endif /* _GLIBCXX_MEMORY */ diff --git a/libstdc++-v3/include/std/numeric b/libstdc++-v3/include/std/numeric index ce02ee3..ffd9eae 100644 --- a/libstdc++-v3/include/std/numeric +++ b/libstdc++-v3/include/std/numeric @@ -205,5 +205,19 @@ _GLIBCXX_END_NAMESPACE_VERSION #endif // C++14 +#if __cplusplus > 201402L +// Parallel STL algorithms +# if __PSTL_EXECUTION_POLICIES_DEFINED +// If has already been included, pull in implementations +# include +# else +// Otherwise just pull in forward declarations +# include +# define __PSTL_NUMERIC_FORWARD_DECLARED 1 +# endif + +// Feature test macro for parallel algorithms +# define __cpp_lib_parallel_algorithm 201703L +#endif // C++17 #endif /* _GLIBCXX_NUMERIC */ diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index 668b477..9da3854 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -145,6 +145,7 @@ #define __cpp_lib_unordered_map_try_emplace 201411 #define __cpp_lib_variant 201606L #define __cpp_lib_void_t 201411 +#define __cpp_lib_parallel_algorithm 201603L #if __cplusplus > 201703L // c++2a diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_construct.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_construct.cc new file mode 100644 index 0000000..9ce2369 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_construct.cc @@ -0,0 +1,130 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- uninitialized_construct.pass.cpp ----------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for uninitialized_default_construct, uninitialized_default_construct_n, +// uninitialized_value_construct, uninitialized_value_construct_n + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/memory" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +// function of checking correctness for uninitialized.construct.value +template +bool +IsCheckValueCorrectness(Iterator begin, Iterator end) +{ + for (; begin != end; ++begin) + { + if (*begin != T()) + { + return false; + } + } + return true; +} + +struct test_uninit_construct +{ + template + void + operator()(Policy&& exec, Iterator begin, Iterator end, size_t n, /*is_trivial=*/std::false_type) + { + typedef typename std::iterator_traits::value_type T; + // it needs for cleaning memory that was filled by default constructors in unique_ptr p(new T[n]) + // and for cleaning memory after last calling of uninitialized_value_construct_n. + // It is important for non-trivial types + std::destroy_n(exec, begin, n); + + // reset counter of constructors + T::SetCount(0); + // run algorithm + std::uninitialized_default_construct(exec, begin, end); + // compare counter of constructors to length of container + EXPECT_TRUE(T::Count() == n, "wrong uninitialized_default_construct"); + // destroy objects for testing new algorithms on same memory + std::destroy(exec, begin, end); + + std::uninitialized_default_construct_n(exec, begin, n); + EXPECT_TRUE(T::Count() == n, "wrong uninitialized_default_construct_n"); + std::destroy_n(exec, begin, n); + + std::uninitialized_value_construct(exec, begin, end); + EXPECT_TRUE(T::Count() == n, "wrong uninitialized_value_construct"); + std::destroy(exec, begin, end); + + std::uninitialized_value_construct_n(exec, begin, n); + EXPECT_TRUE(T::Count() == n, "wrong uninitialized_value_construct_n"); + } + + template + void + operator()(Policy&& exec, Iterator begin, Iterator end, size_t n, /*is_trivial=*/std::true_type) + { + typedef typename std::iterator_traits::value_type T; + + std::uninitialized_default_construct(exec, begin, end); + std::destroy(exec, begin, end); + + std::uninitialized_default_construct_n(exec, begin, n); + std::destroy_n(exec, begin, n); + + std::uninitialized_value_construct(exec, begin, end); + // check correctness for uninitialized.construct.value + EXPECT_TRUE(IsCheckValueCorrectness(begin, end), "wrong uninitialized_value_construct"); + std::destroy(exec, begin, end); + + std::uninitialized_value_construct_n(exec, begin, n); + EXPECT_TRUE(IsCheckValueCorrectness(begin, end), "wrong uninitialized_value_construct_n"); + std::destroy_n(exec, begin, n); + } +}; + +template +void +test_uninit_construct_by_type() +{ + std::size_t N = 100000; + for (size_t n = 0; n <= N; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + std::unique_ptr p(new T[n]); + invoke_on_all_policies(test_uninit_construct(), p.get(), std::next(p.get(), n), n, std::is_trivial()); + } +} + +int32_t +main() +{ + + // for user-defined types +#if !__PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN + test_uninit_construct_by_type>(); + test_uninit_construct_by_type>>(); +#endif + + // for trivial types + test_uninit_construct_by_type(); + test_uninit_construct_by_type(); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_copy_move.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_copy_move.cc new file mode 100644 index 0000000..52a5a0b --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_copy_move.cc @@ -0,0 +1,152 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- uninitialized_copy_move.pass.cpp ----------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for uninitialized_copy, uninitialized_copy_n, uninitialized_move, uninitialized_move_n + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/memory" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +// function of checking correctness for uninitialized.construct.value +template +bool +IsCheckValueCorrectness(InputIterator first1, OutputIterator first2, Size n) +{ + for (Size i = 0; i < n; ++i, ++first1, ++first2) + { + if (*first1 != *first2) + { + return false; + } + } + return true; +} + +struct test_uninitialized_copy_move +{ + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, size_t n, + /*is_trivial=*/std::false_type) + { + typedef typename std::iterator_traits::value_type T; + // it needs for cleaning memory that was filled by default constructors in unique_ptr p(new T[n]) + // and for cleaning memory after last calling of uninitialized_value_construct_n. + // It is important for non-trivial types + std::destroy_n(exec, out_first, n); + + // reset counter of constructors + T::SetCount(0); + // run algorithm + std::uninitialized_copy(exec, first, last, out_first); + // compare counter of constructors to length of container + EXPECT_TRUE(T::Count() == n, "wrong uninitialized_copy"); + // destroy objects for testing new algorithms on same memory + std::destroy_n(exec, out_first, n); + + std::uninitialized_copy_n(exec, first, n, out_first); + EXPECT_TRUE(T::Count() == n, "wrong uninitialized_copy_n"); + std::destroy_n(exec, out_first, n); + + // For move + std::uninitialized_move(exec, first, last, out_first); + // compare counter of constructors to length of container + EXPECT_TRUE(T::MoveCount() == n, "wrong uninitialized_move"); + // destroy objects for testing new algorithms on same memory + std::destroy_n(exec, out_first, n); + + std::uninitialized_move_n(exec, first, n, out_first); + EXPECT_TRUE(T::MoveCount() == n, "wrong uninitialized_move_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 + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, + size_t n, /*is_trivial=*/std::true_type) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, size_t n, /*is_trivial=*/std::true_type) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, size_t n, + /*is_trivial=*/std::true_type) + { + typedef typename std::iterator_traits::value_type T; + + std::uninitialized_copy(exec, first, last, out_first); + EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_copy"); + std::destroy_n(exec, out_first, n); + + std::uninitialized_copy_n(exec, first, n, out_first); + EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_copy_n"); + std::destroy_n(exec, out_first, n); + + std::uninitialized_move(exec, first, last, out_first); + EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_move"); + std::destroy_n(exec, out_first, n); + + std::uninitialized_move_n(exec, first, n, out_first); + EXPECT_TRUE(IsCheckValueCorrectness(first, out_first, n), "wrong uninitialized_move_n"); + std::destroy_n(exec, out_first, n); + } +}; + +template +void +test_uninitialized_copy_move_by_type() +{ + std::size_t N = 100000; + for (size_t n = 0; n <= N; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [=](size_t k) -> T { return T(k); }); + std::unique_ptr p(new T[n]); + invoke_on_all_policies(test_uninitialized_copy_move(), in.begin(), in.end(), p.get(), n, std::is_trivial()); + } +} + +int32_t +main() +{ + + // for trivial types + test_uninitialized_copy_move_by_type(); + test_uninitialized_copy_move_by_type(); + + // 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 && \ + !__PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN + test_uninitialized_copy_move_by_type>(); +#endif + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_fill_destroy.cc b/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_fill_destroy.cc new file mode 100644 index 0000000..31ea484 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/specialized_algorithms/pstl/uninitialized_fill_destroy.cc @@ -0,0 +1,102 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- uninitialized_fill_destroy.pass.cpp -------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/memory" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_uninitialized_fill_destroy +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, const T& in, std::size_t n, std::false_type) + { + using namespace std; + { + T::SetCount(0); + uninitialized_fill(exec, first, last, in); + size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; }); + EXPECT_TRUE(n == count, "wrong work of uninitialized_fill"); + destroy(exec, first, last); + EXPECT_TRUE(T::Count() == 0, "wrong work of destroy"); + } + + { + auto res = uninitialized_fill_n(exec, first, n, in); + EXPECT_TRUE(res == last, "wrong result of uninitialized_fill_n"); + size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; }); + EXPECT_TRUE(n == count, "wrong work of uninitialized_fill_n"); + destroy_n(exec, first, n); + EXPECT_TRUE(T::Count() == 0, "wrong work of destroy_n"); + } + } + template + void + operator()(Policy&& exec, Iterator first, Iterator last, const T& in, std::size_t n, std::true_type) + { + using namespace std; + { + destroy(exec, first, last); + uninitialized_fill(exec, first, last, in); + size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; }); + EXPECT_EQ(n, count, "wrong work of uninitialized:_fill"); + } + { + destroy_n(exec, first, n); + auto res = uninitialized_fill_n(exec, first, n, in); + size_t count = count_if(first, last, [&in](T& x) -> bool { return x == in; }); + EXPECT_EQ(n, count, "wrong work of uninitialized_fill_n"); + EXPECT_TRUE(res == last, "wrong result of uninitialized_fill_n"); + } + } +}; + +template +void +test_uninitialized_fill_destroy_by_type() +{ + std::size_t N = 100000; + for (size_t n = 0; n <= N; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + std::unique_ptr p(new T[n]); + invoke_on_all_policies(test_uninitialized_fill_destroy(), p.get(), std::next(p.get(), n), T(), n, + std::is_trivial()); + } +} + +int32_t +main() +{ + // for trivial types + test_uninitialized_fill_destroy_by_type(); + test_uninitialized_fill_destroy_by_type(); + + // for user-defined types + test_uninitialized_fill_destroy_by_type>(); + test_uninitialized_fill_destroy_by_type>(); + std::cout << done() << std::endl; + + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_merge/inplace_merge.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_merge/inplace_merge.cc new file mode 100644 index 0000000..ed4a3c3 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_merge/inplace_merge.cc @@ -0,0 +1,164 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- inplace_merge.pass.cpp --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include +#include "pstl/execution" +#include "pstl/algorithm" + +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_one_policy +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2, + Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, + BiDirIt1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) + { + } +#endif + + // inplace_merge works with bidirectional iterators at least + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2, Size n, Size m, + Generator1 generator1, Generator2 generator2, Compare comp) + { + + using T = typename std::iterator_traits::value_type; + const BiDirIt1 mid1 = std::next(first1, m); + fill_data(first1, mid1, generator1); + fill_data(mid1, last1, generator2); + + const BiDirIt1 mid2 = std::next(first2, m); + fill_data(first2, mid2, generator1); + fill_data(mid2, last2, generator2); + + std::inplace_merge(first1, mid1, last1, comp); + std::inplace_merge(exec, first2, mid2, last2, comp); + EXPECT_EQ_N(first1, first2, n, "wrong effect from inplace_merge with predicate"); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2, Size n, Size m, + Generator1 generator1, Generator2 generator2, Compare comp) + { + } +}; + +template +void +test_by_type(Generator1 generator1, Generator2 generator2, Compare comp) +{ + using namespace std; + size_t max_size = 100000; + Sequence in1(max_size, [](size_t v) { return T(v); }); + Sequence exp(max_size, [](size_t v) { return T(v); }); + size_t m; + + for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + m = 0; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m, + generator1, generator2, comp); + + m = n / 3; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m, + generator1, generator2, comp); + + m = 2 * n / 3; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m, + generator1, generator2, comp); + } +} + +template +struct LocalWrapper +{ + explicit LocalWrapper(int32_t k) : my_val(k) {} + LocalWrapper(LocalWrapper&& input) { my_val = std::move(input.my_val); } + LocalWrapper& + operator=(LocalWrapper&& input) + { + my_val = std::move(input.my_val); + return *this; + } + bool + operator<(const LocalWrapper& w) const + { + return my_val < w.my_val; + } + friend bool + operator==(const LocalWrapper& x, const LocalWrapper& y) + { + return x.my_val == y.my_val; + } + friend std::ostream& + operator<<(std::ostream& stream, const LocalWrapper& input) + { + return stream << input.my_val; + } + + private: + T my_val; +}; + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + invoke_if(exec, [&]() { inplace_merge(exec, iter, iter, iter, non_const(std::less())); }); + } +}; + +int32_t +main() +{ + test_by_type([](int32_t i) { return -2 * i; }, [](int32_t i) { return -(2 * i + 1); }, + [](const float64_t x, const float64_t y) { return x > y; }); + + test_by_type([](int32_t i) { return 10 * i; }, [](int32_t i) { return i + 1; }, std::less()); + + test_by_type>([](int32_t i) { return LocalWrapper(2 * i + 1); }, + [](int32_t i) { return LocalWrapper(2 * i); }, + std::less>()); + + test_algo_basic_single(run_for_rnd_bi>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_merge/merge.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_merge/merge.cc new file mode 100644 index 0000000..01f9a02 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_merge/merge.cc @@ -0,0 +1,123 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- merge.pass.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include +#include +#include "pstl/execution" +#include "pstl/algorithm" + +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_merge +{ + template + void + operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, + OutputIterator out_first, OutputIterator out_last, Compare comp) + { + using namespace std; + { + const auto res = merge(exec, first1, last1, first2, last2, out_first, comp); + EXPECT_TRUE(res == out_last, "wrong return result from merge with predicate"); + EXPECT_TRUE(is_sorted(out_first, res, comp), "wrong result from merge with predicate"); + EXPECT_TRUE(includes(out_first, res, first1, last1, comp), "first sequence is not a part of result"); + EXPECT_TRUE(includes(out_first, res, first2, last2, comp), "second sequence is not a part of result"); + } + { + const auto res = merge(exec, first1, last1, first2, last2, out_first); + EXPECT_TRUE(res == out_last, "wrong return result from merge"); + EXPECT_TRUE(is_sorted(out_first, res), "wrong result from merge"); + } + } + + // for reverse iterators + template + void + operator()(Policy&& exec, std::reverse_iterator first1, std::reverse_iterator last1, + std::reverse_iterator first2, std::reverse_iterator last2, + std::reverse_iterator out_first, std::reverse_iterator out_last, + Compare comp) + { + using namespace std; + typedef typename std::iterator_traits>::value_type T; + const auto res = merge(exec, first1, last1, first2, last2, out_first, std::greater()); + + EXPECT_TRUE(res == out_last, "wrong return result from merge with predicate"); + EXPECT_TRUE(is_sorted(out_first, res, std::greater()), "wrong result from merge with predicate"); + EXPECT_TRUE(includes(out_first, res, first1, last1, std::greater()), + "first sequence is not a part of result"); + EXPECT_TRUE(includes(out_first, res, first2, last2, std::greater()), + "second sequence is not a part of result"); + } +}; + +template +void +test_merge_by_type(Generator1 generator1, Generator2 generator2) +{ + using namespace std; + size_t max_size = 100000; + Sequence in1(max_size, generator1); + Sequence in2(max_size / 2, generator2); + Sequence out(in1.size() + in2.size()); + std::sort(in1.begin(), in1.end()); + std::sort(in2.begin(), in2.end()); + + for (size_t size = 0; size <= max_size; size = size <= 16 ? size + 1 : size_t(3.1415 * size)) + { + invoke_on_all_policies(test_merge(), in1.cbegin(), in1.cbegin() + size, in2.data(), in2.data() + size / 2, + out.begin(), out.begin() + 1.5 * size, std::less()); + invoke_on_all_policies(test_merge(), in1.data(), in1.data() + size, in2.cbegin(), in2.cbegin() + size / 2, + out.begin(), out.begin() + 3 * size / 2, std::less()); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputIterator out_iter) + { + merge(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less())); + } +}; + +int32_t +main() +{ + test_merge_by_type([](size_t v) { return (v % 2 == 0 ? v : -v) * 3; }, [](size_t v) { return v * 2; }); + test_merge_by_type([](size_t v) { return float64_t(v); }, [](size_t v) { return float64_t(v - 100); }); + +#if !__PSTL_ICC_16_17_TEST_64_TIMEOUT + test_merge_by_type>([](size_t v) { return Wrapper(v % 100); }, + [](size_t v) { return Wrapper(v % 10); }); +#endif + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_if.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_if.cc new file mode 100644 index 0000000..b76fe1b --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_if.cc @@ -0,0 +1,154 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- copy_if.pass.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for copy_if and remove_copy_if +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +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 + template + void + operator()(__pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, + Predicate pred, T trash) + { + } + template + void + operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, + OutputIterator2 expected_last, Size n, Predicate pred, T trash) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, + Predicate pred, T trash) + { + // Cleaning + std::fill_n(expected_first, n, trash); + std::fill_n(out_first, n, trash); + + // Run copy_if + auto i = copy_if(first, last, expected_first, pred); + auto k = copy_if(exec, first, last, out_first, pred); + EXPECT_EQ_N(expected_first, out_first, n, "wrong copy_if effect"); + for (size_t j = 0; j < GuardSize; ++j) + { + ++k; + } + EXPECT_TRUE(out_last == k, "wrong return value from copy_if"); + + // Cleaning + std::fill_n(expected_first, n, trash); + std::fill_n(out_first, n, trash); + // Run remove_copy_if + i = remove_copy_if(first, last, expected_first, [=](const T& x) { return !pred(x); }); + k = remove_copy_if(exec, first, last, out_first, [=](const T& x) { return !pred(x); }); + EXPECT_EQ_N(expected_first, out_first, n, "wrong remove_copy_if effect"); + for (size_t j = 0; j < GuardSize; ++j) + { + ++k; + } + EXPECT_TRUE(out_last == k, "wrong return value from remove_copy_if"); + } +}; + +template +void +test(T trash, Predicate pred, Convert convert, bool check_weakness = true) +{ + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + // count is number of output elements, plus a handful + // more for sake of detecting buffer overruns. + size_t count = GuardSize; + Sequence in(n, [&](size_t k) -> T { + T val = convert(n ^ k); + count += pred(val) ? 1 : 0; + return val; + }); + + Sequence out(count, [=](size_t) { return trash; }); + Sequence expected(count, [=](size_t) { return trash; }); + if (check_weakness) + { + auto expected_result = copy_if(in.cfbegin(), in.cfend(), expected.begin(), pred); + size_t m = expected_result - expected.begin(); + EXPECT_TRUE(n / 4 <= m && m <= 3 * (n + 1) / 4, "weak test for copy_if"); + } + invoke_on_all_policies(run_copy_if(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), count, pred, trash); + invoke_on_all_policies(run_copy_if(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), + expected.end(), count, pred, trash); + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + copy_if(exec, input_iter, input_iter, out_iter, non_const(is_even)); + + invoke_if(exec, [&]() { remove_copy_if(exec, input_iter, input_iter, out_iter, non_const(is_even)); }); + } +}; + +int32_t +main() +{ + test(-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); }); + + test(-666, [](const int32_t& x) { return x != 42; }, + [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? int32_t(j + 1) : 42; }); + +#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN + test(Number(42, OddTag()), IsMultiple(3, OddTag()), [](int32_t j) { return Number(j, OddTag()); }); +#endif + +#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN + test(-666, [](const int32_t& x) { return true; }, [](size_t j) { return j; }, false); +#endif + + test_algo_basic_double(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_move.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_move.cc new file mode 100644 index 0000000..ac265c0 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/copy_move.cc @@ -0,0 +1,208 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- copy_move.pass.cpp ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for copy, move and copy_n + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct run_copy +{ + +#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 + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, + Size n, T trash) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, + OutputIterator2 expected_last, Size size, Size n, T trash) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, + Size n, T trash) + { + // Cleaning + std::fill_n(expected_first, size, trash); + std::fill_n(out_first, size, trash); + + // Run copy + copy(first, last, expected_first); + auto k = copy(exec, first, last, out_first); + for (size_t j = 0; j < GuardSize; ++j) + ++k; + EXPECT_EQ_N(expected_first, out_first, size, "wrong effect from copy"); + EXPECT_TRUE(out_last == k, "wrong return value from copy"); + + // Cleaning + std::fill_n(out_first, size, trash); + // Run copy_n + k = copy_n(exec, first, n, out_first); + for (size_t j = 0; j < GuardSize; ++j) + ++k; + EXPECT_EQ_N(expected_first, out_first, size, "wrong effect from copy_n"); + EXPECT_TRUE(out_last == k, "wrong return value from copy_n"); + } +}; + +template +struct run_move +{ + +#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 + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, + Size n, T trash) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, + OutputIterator2 expected_last, Size size, Size n, T trash) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, + Size n, T trash) + { + // Cleaning + std::fill_n(expected_first, size, trash); + std::fill_n(out_first, size, trash); + + // Run move + move(first, last, expected_first); + auto k = move(exec, first, last, out_first); + for (size_t j = 0; j < GuardSize; ++j) + ++k; + EXPECT_EQ_N(expected_first, out_first, size, "wrong effect from move"); + EXPECT_TRUE(out_last == k, "wrong return value from move"); + } +}; + +template +struct run_move> +{ + +#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 + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, + Size n, Wrapper trash) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, + OutputIterator2 expected_last, Size size, Size n, Wrapper trash) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, + Size n, Wrapper trash) + { + // Cleaning + std::fill_n(out_first, size, trash); + Wrapper::SetMoveCount(0); + + // Run move + auto k = move(exec, first, last, out_first); + for (size_t j = 0; j < GuardSize; ++j) + ++k; + EXPECT_TRUE(Wrapper::MoveCount() == size, "wrong effect from move"); + EXPECT_TRUE(out_last == k, "wrong return value from move"); + } +}; + +template +void +test(T trash, Convert convert) +{ + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + // count is number of output elements, plus a handful + // more for sake of detecting buffer overruns. + Sequence in(n, [&](size_t k) -> T { + T val = convert(n ^ k); + return val; + }); + + const size_t outN = n + GuardSize; + Sequence out(outN, [=](size_t) { return trash; }); + Sequence expected(outN, [=](size_t) { return trash; }); + invoke_on_all_policies(run_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), outN, n, trash); + invoke_on_all_policies(run_copy(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), + expected.end(), outN, n, trash); + invoke_on_all_policies(run_move(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), n, n, trash); + + // For this test const iterator isn't suitable + // because const rvalue-reference call copy assignment operator + } +} + +int32_t +main() +{ + test(-666, [](size_t j) { return int32_t(j); }); + test>(Wrapper(-666.0), [](int32_t j) { return Wrapper(j); }); + +#if !__PSTL_ICC_16_17_TEST_64_TIMEOUT + test(-666.0, [](size_t j) { return float64_t(j); }); + test(Number(42, OddTag()), [](int32_t j) { return Number(j, OddTag()); }); +#endif + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/fill.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/fill.cc new file mode 100644 index 0000000..fd29a61 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/fill.cc @@ -0,0 +1,108 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- fill.pass.cpp -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_fill +{ + template + bool + check(It first, It last, const T& value) + { + for (; first != last; ++first) + if (*first != value) + return false; + return true; + } + + template + void + operator()(Policy&& exec, Iterator first, Iterator last, const T& value) + { + fill(first, last, T(value + 1)); // initialize memory with different value + + fill(exec, first, last, value); + EXPECT_TRUE(check(first, last, value), "fill wrong result"); + } +}; + +struct test_fill_n +{ + template + bool + check(It first, Size n, const T& value) + { + for (Size i = 0; i < n; ++i, ++first) + if (*first != value) + return false; + return true; + } + + template + void + operator()(Policy&& exec, Iterator first, Size n, const T& value) + { + fill_n(first, n, T(value + 1)); // initialize memory with different value + + const Iterator one_past_last = fill_n(exec, first, n, value); + const Iterator expected_return = std::next(first, n); + + EXPECT_TRUE(expected_return == one_past_last, "fill_n should return Iterator to one past the element assigned"); + EXPECT_TRUE(check(first, n, value), "fill_n wrong result"); + + //n == -1 + const Iterator res = fill_n(exec, first, -1, value); + EXPECT_TRUE(res == first, "fill_n wrong result for n == -1"); + } +}; + +template +void +test_fill_by_type(std::size_t n) +{ + Sequence in(n, [](std::size_t v) -> T { return T(0); }); //fill with zeros + T value = -1; + + invoke_on_all_policies(test_fill(), in.begin(), in.end(), value); + invoke_on_all_policies(test_fill_n(), in.begin(), n, value); +} + +int32_t +main() +{ + + const std::size_t N = 100000; + + for (std::size_t n = 0; n < N; n = n < 16 ? n + 1 : size_t(3.1415 * n)) + { + test_fill_by_type(n); + test_fill_by_type(n); + } + + std::cout << done() << std::endl; + + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/generate.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/generate.cc new file mode 100644 index 0000000..ebd922d --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/generate.cc @@ -0,0 +1,111 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- generate.pass.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct Generator_count +{ + const T def_val = T(-1); + T + operator()() + { + return def_val; + } + T + default_value() const + { + return def_val; + } +}; + +struct test_generate +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, Size n) + { + using namespace std; + typedef typename std::iterator_traits::value_type T; + + // Try random-access iterator + { + Generator_count g; + generate(exec, first, last, g); + EXPECT_TRUE(std::count(first, last, g.default_value()) == n, "generate wrong result for generate"); + std::fill(first, last, T(0)); + } + + { + Generator_count g; + const auto m = n / 2; + auto last = generate_n(exec, first, m, g); + EXPECT_TRUE(std::count(first, last, g.default_value()) == m && last == std::next(first, m), + "generate_n wrong result for generate_n"); + std::fill(first, last, T(0)); + } + } +}; + +template +void +test_generate_by_type() +{ + for (size_t n = 0; n <= 100000; n = n < 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [](size_t v) -> T { return T(0); }); //fill by zero + + invoke_on_all_policies(test_generate(), in.begin(), in.end(), in.size()); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto gen = []() { return T(0); }; + + generate(exec, iter, iter, non_const(gen)); + generate_n(exec, iter, 0, non_const(gen)); + } +}; + +int32_t +main() +{ + + test_generate_by_type(); + test_generate_by_type(); + + test_algo_basic_single(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/is_partitioned.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/is_partitioned.cc new file mode 100644 index 0000000..1f7315c --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/is_partitioned.cc @@ -0,0 +1,108 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- is_partitioned.pass.cpp -------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_one_policy +{ + //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 + + template + void + operator()(pstl::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Predicate pred) + { + const bool expected = std::is_partitioned(begin1, end1, pred); + const bool actual = std::is_partitioned(exec, begin1, end1, pred); + EXPECT_TRUE(actual == expected, "wrong return result from is_partitioned"); + } +}; + +template +void +test(Predicate pred) +{ + + const std::size_t max_n = 1000000; + Sequence in(max_n, [](std::size_t k) { return T(k); }); + + for (std::size_t n1 = 0; n1 <= max_n; n1 = n1 <= 16 ? n1 + 1 : std::size_t(3.1415 * n1)) + { + invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n1, pred); + std::partition(in.begin(), in.begin() + n1, pred); + invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cbegin() + n1, pred); + } +} + +template +struct LocalWrapper +{ + explicit LocalWrapper(std::size_t k) : my_val(k) {} + + private: + T my_val; +}; + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + invoke_if(exec, [&]() { is_partitioned(exec, iter, iter, non_const(is_even)); }); + } +}; + +int32_t +main() +{ + test([](const float64_t x) { return x < 0; }); + test([](const int32_t x) { return x > 1000; }); + test([](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 + test>([](const LocalWrapper& x) { return true; }); +#endif + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/partition.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/partition.cc new file mode 100644 index 0000000..607ba9b --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/partition.cc @@ -0,0 +1,187 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- partition.pass.cpp ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for stable_partition and partition +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +#include +#include + +using namespace TestUtils; + +template +struct DataType +{ + explicit DataType(int32_t k) : my_val(k) {} + DataType(DataType&& input) { my_val = std::move(input.my_val); } + DataType& + operator=(DataType&& input) + { + my_val = std::move(input.my_val); + return *this; + } + T + get_val() const + { + return my_val; + } + + friend std::ostream& + operator<<(std::ostream& stream, const DataType& input) + { + return stream << input.my_val; + } + + private: + T my_val; +}; + +template +typename std::enable_if::value_type>::value, bool>::type +is_equal(Iterator first, Iterator last, Iterator d_first) +{ + return std::equal(first, last, d_first); +} + +template +typename std::enable_if::value_type>::value, bool>::type +is_equal(Iterator first, Iterator last, Iterator d_first) +{ + return true; +} + +struct test_one_policy +{ +#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 + template + void + operator()(__pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, + Size n, UnaryOp unary_op, Generator generator) + { + } + + template + void + operator()(__pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, + 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 + template + void + operator()(__pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, + Size n, UnaryOp unary_op, Generator generator) + { + } + + template + void + operator()(__pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, + BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator) + { + } +#endif + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size n, + UnaryOp unary_op, Generator generator) + { + // partition + { + fill_data(first, last, generator); + BiDirIt actual_ret = std::partition(exec, first, last, unary_op); + EXPECT_TRUE(std::all_of(first, actual_ret, unary_op) && !std::any_of(actual_ret, last, unary_op), + "wrong effect from partition"); + } + // stable_partition + { + fill_data(exp_first, exp_last, generator); + BiDirIt exp_ret = std::stable_partition(exp_first, exp_last, unary_op); + fill_data(first, last, generator); + BiDirIt actual_ret = std::stable_partition(exec, first, last, unary_op); + + EXPECT_TRUE(std::distance(first, actual_ret) == std::distance(exp_first, exp_ret), + "wrong result from stable_partition"); + EXPECT_TRUE((is_equal(exp_first, exp_last, first)), "wrong effect from stable_partition"); + } + } + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size n, + UnaryOp unary_op, Generator generator) + { + } +}; + +template +void +test_by_type(Generator generator, UnaryPred pred) +{ + + using namespace std; + size_t max_size = 100000; + Sequence in(max_size, [](size_t v) { return T(v); }); + Sequence exp(max_size, [](size_t v) { return T(v); }); + + for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n, exp.begin(), exp.begin() + n, n, pred, + generator); + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + invoke_if(exec, [&]() { + partition(exec, iter, iter, non_const(is_even)); + stable_partition(exec, iter, iter, non_const(is_even)); + }); + } +}; + +int32_t +main() +{ +#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN + test_by_type([](int32_t i) { return i; }, [](int32_t) { return true; }); +#endif + test_by_type([](int32_t i) { return -i; }, [](const float64_t x) { return x < 0; }); + test_by_type([](int32_t i) { return i + 1; }, [](int64_t x) { return x % 3 == 0; }); + test_by_type>([](int32_t i) { return DataType(2 * i + 1); }, + [](const DataType& x) { return x.get_val() < 0; }); + + test_algo_basic_single(run_for_rnd_bi()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/partition_copy.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/partition_copy.cc new file mode 100644 index 0000000..13ceaba --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/partition_copy.cc @@ -0,0 +1,124 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- partition_copy.pass.cpp -------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for stable_partition and partition_copy +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +#include +#include + +using namespace TestUtils; + +struct test_partition_copy +{ + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator true_first, + OutputIterator true_last, OutputIterator2 false_first, OutputIterator2 false_last, UnaryOp unary_op) + { + + auto actual_ret = std::partition_copy(exec, first, last, true_first, false_first, 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"); + EXPECT_TRUE(std::distance(false_first, actual_ret.second) == + std::count_if(first, last, __pstl::__internal::__not_pred(unary_op)), + "partition_copy has wrong effect from false sequence"); + } + + //dummy specialization by iterator type and policy type, in case of broken configuration +#if __PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN + template + void + operator()(pstl::execution::unsequenced_policy, std::reverse_iterator first, + std::reverse_iterator last, std::reverse_iterator true_first, + std::reverse_iterator true_last, std::reverse_iterator false_first, + OutputIterator2 false_last, UnaryOp unary_op) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, std::reverse_iterator first, + std::reverse_iterator last, std::reverse_iterator true_first, + std::reverse_iterator true_last, std::reverse_iterator false_first, + OutputIterator2 false_last, UnaryOp unary_op) + { + } +#endif +}; + +template +void +test(UnaryPred pred) +{ + + const std::size_t max_size = 100000; + Sequence in(max_size, [](std::size_t v) -> T { return T(v); }); + Sequence actual_true(max_size); + Sequence actual_false(max_size); + for (std::size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : std::size_t(3.1415 * n)) + { + + // for non-const input iterators + invoke_on_all_policies(test_partition_copy(), in.begin(), in.begin() + n, actual_true.begin(), + actual_true.begin() + n, actual_false.begin(), actual_false.begin() + n, pred); + + // for const input iterators + invoke_on_all_policies(test_partition_copy(), in.cbegin(), in.cbegin() + n, actual_true.begin(), + actual_true.begin() + n, actual_false.begin(), actual_false.begin() + n, pred); + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + + partition_copy(exec, input_iter, input_iter, out_iter, out_iter, non_const(is_even)); + } +}; + +int32_t +main() +{ + test([](const int32_t value) { return value % 2; }); + +#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN + test([](const int32_t value) { return true; }); +#endif + + test([](const float64_t value) { return value > 2 << 6; }); + test>([](const Wrapper& value) -> bool { return value.get_my_field() != nullptr; }); + + test_algo_basic_double(run_for_rnd_bi()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/remove.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/remove.cc new file mode 100644 index 0000000..0ca54af --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/remove.cc @@ -0,0 +1,161 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- remove.pass.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Test for remove, remove_if +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct run_remove +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, + const T& value) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, OutputIterator out_last, OutputIterator expected_first, + OutputIterator expected_last, Size n, const T& value) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size, + const T& value) + { + // Cleaning + std::copy(first, last, expected_first); + std::copy(first, last, out_first); + + // Run remove + OutputIterator i = remove(expected_first, expected_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_EQ_N(expected_first, out_first, std::distance(expected_first, i), "wrong remove effect"); + } +}; + +struct run_remove_if +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, + Predicate pred) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, OutputIterator out_last, OutputIterator expected_first, + OutputIterator expected_last, Size n, Predicate pred) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size, + Predicate pred) + { + // Cleaning + std::copy(first, last, expected_first); + std::copy(first, last, out_first); + + // Run remove_if + OutputIterator i = remove_if(expected_first, expected_last, pred); + OutputIterator k = remove_if(exec, out_first, out_last, pred); + EXPECT_TRUE(std::distance(expected_first, i) == std::distance(out_first, k), + "wrong return value from remove_if"); + EXPECT_EQ_N(expected_first, out_first, std::distance(expected_first, i), "wrong remove_if effect"); + } +}; + +template +void +test(T trash, const T& value, Predicate pred, Convert convert) +{ + const std::size_t max_size = 100000; + Sequence out(max_size, [trash](size_t) { return trash; }); + Sequence expected(max_size, [trash](size_t) { return trash; }); + + for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence data(n, [&](size_t k) -> T { return convert(k); }); + + invoke_on_all_policies(run_remove(), data.begin(), data.end(), out.begin(), out.begin() + n, expected.begin(), + expected.begin() + n, n, value); + invoke_on_all_policies(run_remove_if(), data.begin(), data.end(), out.begin(), out.begin() + n, + expected.begin(), expected.begin() + n, n, pred); + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + + invoke_if(exec, [&]() { remove_if(exec, iter, iter, non_const(is_even)); }); + } +}; + +int32_t +main() +{ +#if !__PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN + test(666, 42, [](int32_t val) { return true; }, [](size_t j) { return j; }); +#endif + + test(666, 2001, [](const int32_t& val) { return val != 2001; }, + [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 2001 : -1 - int32_t(j); }); + test(-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); }); + +#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN + test(Number(-666, OddTag()), Number(42, OddTag()), IsMultiple(3, OddTag()), + [](int32_t j) { return Number(j, OddTag()); }); +#endif + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/remove_copy.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/remove_copy.cc new file mode 100644 index 0000000..c5883c6 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/remove_copy.cc @@ -0,0 +1,98 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- remove_copy.pass.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct run_remove_copy +{ + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, + const T& value, T trash) + { + // Cleaning + std::fill_n(expected_first, n, trash); + std::fill_n(out_first, n, trash); + + // Run copy_if + auto i = remove_copy(first, last, expected_first, value); + auto k = remove_copy(exec, first, last, out_first, value); + EXPECT_EQ_N(expected_first, out_first, n, "wrong remove_copy effect"); + for (size_t j = 0; j < GuardSize; ++j) + { + ++k; + } + EXPECT_TRUE(out_last == k, "wrong return value from remove_copy"); + } +}; + +template +void +test(T trash, const T& value, Convert convert, bool check_weakness = true) +{ + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + // count is number of output elements, plus a handful + // more for sake of detecting buffer overruns. + size_t count = GuardSize; + Sequence in(n, [&](size_t k) -> T { + T x = convert(n ^ k); + count += !(x == value) ? 1 : 0; + return x; + }); + using namespace std; + + Sequence out(count, [=](size_t) { return trash; }); + Sequence expected(count, [=](size_t) { return trash; }); + if (check_weakness) + { + auto expected_result = remove_copy(in.cfbegin(), in.cfend(), expected.begin(), value); + size_t m = expected_result - expected.begin(); + EXPECT_TRUE(n / 4 <= m && m <= 3 * (n + 1) / 4, "weak test for remove_copy"); + } + invoke_on_all_policies(run_remove_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), count, value, trash); + invoke_on_all_policies(run_remove_copy(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), + expected.end(), count, value, trash); + } +} + +int32_t +main() +{ + + test(-666.0, 8.5, [](size_t j) { return ((j + 1) % 7 & 2) != 0 ? 8.5 : float64_t(j % 32 + j); }); + + test(-666, 42, [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 42 : -1 - int32_t(j); }); + + test(Number(42, OddTag()), Number(2001, OddTag()), + [](int32_t j) { return ((j + 1) % 3 & 2) != 0 ? Number(2001, OddTag()) : Number(j, OddTag()); }); + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/replace.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/replace.cc new file mode 100644 index 0000000..4d68591 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/replace.cc @@ -0,0 +1,167 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- replace.pass.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +// This class is needed to check the self-copying +struct copy_int +{ + int32_t value; + int32_t copied_times = 0; + explicit copy_int(int32_t val = 0) { value = val; } + + copy_int& + operator=(const copy_int& other) + { + if (&other == this) + copied_times++; + else + { + value = other.value; + copied_times = other.copied_times; + } + return *this; + } + + bool + operator==(const copy_int& other) const + { + return (value == other.value); + } +}; + +template +struct test_one_policy +{ + std::size_t len; + Iterator data_b; + Iterator data_e; + test_one_policy(Iterator data_, std::size_t len_) + { + len = len_; + data_b = data_; + data_e = std::next(data_b, len); + } + template + void + operator()(ExecutionPolicy&& exec, Iterator1 expected_b, Iterator1 expected_e, Iterator2 actual_b, + Iterator2 actual_e, Predicate pred, const T& value, const T& old_value) + { + using namespace std; + + copy(data_b, data_e, expected_b); + copy(data_b, data_e, actual_b); + + replace(expected_b, expected_e, old_value, value); + replace(exec, actual_b, actual_e, old_value, value); + + EXPECT_TRUE((check(actual_b, actual_e)), "wrong result of self assignment check"); + EXPECT_TRUE(equal(expected_b, expected_e, actual_b), "wrong result of replace"); + + copy(data_b, data_e, expected_b); + copy(data_b, data_e, actual_b); + + replace_if(expected_b, expected_e, pred, value); + replace_if(exec, actual_b, actual_e, pred, value); + EXPECT_TRUE(equal(expected_b, expected_e, actual_b), "wrong result of replace_if"); + } + + template + bool + check(Iterator1 b, Iterator1 e) + { + return true; + } + + template + typename std::enable_if::value, bool>::type_t + check(Iterator1 b, Iterator1 e) + { + return std::all_of(b, e, [](const copy_int& elem) { return elem.copied_times == 0; }); + } +}; + +template +void +test(Pred pred) +{ + typedef typename Sequence::iterator iterator_type; + + const std::size_t max_len = 100000; + + const T1 value = T1(0); + const T1 new_value = T1(666); + + Sequence expected(max_len); + Sequence actual(max_len); + + Sequence data(max_len, [&value](std::size_t i) { + if (i % 3 == 2) + { + return T1(i); + } + else + { + return value; + } + }); + + for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len)) + { + test_one_policy temp(data.begin(), len); + + invoke_on_all_policies(temp, expected.begin(), expected.begin() + len, actual.begin(), actual.begin() + len, + pred, new_value, value); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + invoke_if(exec, [&]() { replace_if(exec, iter, iter, non_const(is_even), T(0)); }); + } +}; + +int32_t +main() +{ + test(__pstl::__internal::__equal_value(666)); + test([](const uint16_t& elem) { return elem % 3 < 2; }); + test([](const float64_t& elem) { return elem * elem - 3.5 * elem > 10; }); + test([](const copy_int& val) { return val.value / 5 > 2; }); + + test_algo_basic_single(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/replace_copy.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/replace_copy.cc new file mode 100644 index 0000000..8ff476d --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/replace_copy.cc @@ -0,0 +1,112 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- replace_copy.pass.cpp ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for replace_copy and replace_copy_if + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_replace_copy +{ + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, + Predicate pred, const T& old_value, const T& new_value, T trash) + { + // Cleaning + std::fill_n(expected_first, n, trash); + std::fill_n(out_first, n, trash); + // Run replace_copy + auto i = std::replace_copy(first, last, expected_first, old_value, new_value); + auto k = std::replace_copy(exec, first, last, out_first, old_value, new_value); + EXPECT_EQ_N(expected_first, out_first, n, "wrong replace_copy effect"); + EXPECT_TRUE(out_last == k, "wrong return value from replace_copy"); + + // Cleaning + std::fill_n(expected_first, n, trash); + std::fill_n(out_first, n, trash); + // Run replace_copy_if + i = replace_copy_if(first, last, expected_first, pred, new_value); + k = replace_copy_if(exec, first, last, out_first, pred, new_value); + EXPECT_EQ_N(expected_first, out_first, n, "wrong replace_copy_if effect"); + EXPECT_TRUE(out_last == k, "wrong return value from replace_copy_if"); + } +}; + +template +void +test(T trash, const T& old_value, const T& new_value, Predicate pred, Convert convert) +{ + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [&](size_t k) -> T { return convert(n ^ k); }); + Sequence out(n, [=](size_t) { return trash; }); + Sequence expected(n, [=](size_t) { return trash; }); + + invoke_on_all_policies(test_replace_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), out.size(), pred, old_value, new_value, trash); + invoke_on_all_policies(test_replace_copy(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), + expected.end(), out.size(), pred, old_value, new_value, trash); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + + invoke_if(exec, [&]() { replace_copy_if(exec, input_iter, input_iter, out_iter, non_const(is_even), T(0)); }); + } +}; + +int32_t +main() +{ + + test(-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); }); + + test(-666, 42, 99, [](const int32_t& x) { return x != 42; }, + [](size_t j) { return ((j + 1) % 5 & 2) != 0 ? 42 : -1 - int32_t(j); }); + +#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN + test(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()); }); +#endif + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate.cc new file mode 100644 index 0000000..88ec2c7 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate.cc @@ -0,0 +1,181 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- rotate.pass.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct wrapper +{ + T t; + int move_count; + explicit wrapper(T t_) : t(t_), move_count(0) {} + wrapper& + operator=(const T& t_) + { + t = t_; + return *this; + } + + wrapper(const wrapper& a) : move_count(0) { t = a.t; } + + wrapper& + operator=(wrapper& a) + { + t = a.t; + return *this; + } + + wrapper& + operator=(wrapper&& a) + { + t = a.t; + move_count += 1; + return *this; + } +}; + +template +struct compare +{ + bool + operator()(const T& a, const T& b) + { + return a == b; + } +}; + +template +struct compare> +{ + bool + operator()(const wrapper& a, const wrapper& b) + { + return a.t == b.t; + } +}; +#include + +struct test_one_policy +{ + +#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 + template + void + operator()(__pstl::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b, + Iterator actual_e, Size shift) + { + } + template + void + operator()(__pstl::execution::parallel_unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b, + Iterator actual_e, Size shift) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator data_b, Iterator data_e, Iterator actual_b, Iterator actual_e, + Size shift) + { + using namespace std; + using T = typename iterator_traits::value_type; + Iterator actual_m = std::next(actual_b, shift); + + copy(data_b, data_e, actual_b); + Iterator actual_return = rotate(exec, actual_b, actual_m, actual_e); + + EXPECT_TRUE(actual_return == std::next(actual_b, std::distance(actual_m, actual_e)), "wrong result of rotate"); + auto comparator = compare(); + bool check = std::equal(actual_return, actual_e, data_b, comparator); + check = check && std::equal(actual_b, actual_return, std::next(data_b, shift), comparator); + + EXPECT_TRUE(check, "wrong effect of rotate"); + EXPECT_TRUE(check_move(exec, actual_b, actual_e, shift), "wrong move test of rotate"); + } + + template + typename std::enable_if< + is_same_iterator_category::value && + !std::is_same::value && + std::is_same::value_type, wrapper>::value, + bool>::type + check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift) + { + bool result = all_of(b, e, [](wrapper& a) { + bool temp = a.move_count > 0; + a.move_count = 0; + return temp; + }); + return shift == 0 || result; + } + + template + typename std::enable_if< + !(is_same_iterator_category::value && + !std::is_same::value && + std::is_same::value_type, wrapper>::value), + bool>::type + check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift) + { + return true; + } +}; + +template +void +test() +{ + const int32_t max_len = 100000; + + Sequence actual(max_len, [](std::size_t i) { return T(i); }); + Sequence data(max_len, [](std::size_t i) { return T(i); }); + + for (int32_t len = 0; len < max_len; len = len <= 16 ? len + 1 : int32_t(3.1415 * len)) + { + int32_t shifts[] = {0, 1, 2, len / 3, (2 * len) / 3, len - 1}; + for (auto shift : shifts) + { + if (shift >= 0 && shift < len) + { + invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(), + actual.begin() + len, shift); + } + } + } +} + +int32_t +main() +{ + test(); + test>(); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate_copy.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate_copy.cc new file mode 100644 index 0000000..35165d0 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/rotate_copy.cc @@ -0,0 +1,154 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- rotate_copy.pass.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct wrapper; + +template +bool +compare(const wrapper& a, const wrapper& b) +{ + return a.t == b.t; +} + +template +bool +compare(const T& a, const T& b) +{ + return a == b; +} + +template +struct wrapper +{ + explicit wrapper(T t_) : t(t_) {} + wrapper& + operator=(const T& t_) + { + t = t_; + return *this; + } + friend bool + compare(const wrapper& a, const wrapper& b); + + private: + T t; +}; + +template +struct comparator +{ + using T1 = typename std::iterator_traits::value_type; + using T2 = typename std::iterator_traits::value_type; + bool + operator()(T1 a, T2 b) + { + T temp = a; + return compare(temp, b); + } +}; + +struct test_one_policy +{ + +#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 + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, + Iterator2 actual_e, std::size_t shift) + { + } + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, + Iterator2 actual_e, std::size_t shift) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e, + std::size_t shift) + { + using namespace std; + using T = typename iterator_traits::value_type; + Iterator1 data_m = std::next(data_b, shift); + + fill(actual_b, actual_e, T(-123)); + Iterator2 actual_return = rotate_copy(exec, data_b, data_m, data_e, actual_b); + + EXPECT_TRUE(actual_return == actual_e, "wrong result of rotate_copy"); + auto comparer = comparator(); + bool check = std::equal(data_m, data_e, actual_b, comparer); + check = check && std::equal(data_b, data_m, std::next(actual_b, std::distance(data_m, data_e)), comparer); + + EXPECT_TRUE(check, "wrong effect of rotate_copy"); + } +}; + +template +void +test() +{ + + const std::size_t max_len = 100000; + + Sequence actual(max_len, [](std::size_t i) { return T1(i); }); + + Sequence data(max_len, [](std::size_t i) { return T1(i); }); + + for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len)) + { + std::size_t shifts[] = {0, 1, 2, len / 3, (2 * len) / 3, len - 1}; + for (std::size_t shift : shifts) + { + if (shift > 0 && shift < len) + { + invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(), + actual.begin() + len, shift); + invoke_on_all_policies(test_one_policy(), data.cbegin(), data.cbegin() + len, actual.begin(), + actual.begin() + len, shift); + } + } + } +} + +int32_t +main() +{ + test(); + test(); + test(); + test, wrapper>(); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/swap_ranges.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/swap_ranges.cc new file mode 100644 index 0000000..3a19f36 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/swap_ranges.cc @@ -0,0 +1,141 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- swap_ranges.pass.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct wrapper +{ + T t; + std::size_t number_of_swaps = 0; + wrapper() {} + explicit wrapper(T t_) : t(t_) {} + template + void + operator=(const U& b) + { + t = b; + } + bool + operator==(const wrapper& a) const + { + return t == a.t; + } +}; + +template +void +swap(wrapper& a, wrapper& b) +{ + std::swap(a.t, b.t); + a.number_of_swaps++; + b.number_of_swaps++; +} + +template +struct check_swap +{ + bool + operator()(T& a) + { + return true; + } +}; + +template +struct check_swap> +{ + bool + operator()(wrapper& a) + { + bool temp = (a.number_of_swaps == 1); + a.number_of_swaps = 0; + return temp; + } +}; + +struct test_one_policy +{ + template + void + operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e) + { + using namespace std; + using T_ref = typename iterator_traits::reference; + using T = typename iterator_traits::value_type; + + iota(data_b, data_e, 0); + iota(actual_b, actual_e, std::distance(data_b, data_e)); + + Iterator2 actual_return = swap_ranges(exec, data_b, data_e, actual_b); + bool check_return = (actual_return == actual_e); + EXPECT_TRUE(check_return, "wrong result of swap_ranges"); + if (check_return) + { + std::size_t i = 0; + bool check = all_of(actual_b, actual_e, [&i](T_ref a) { return a == T(i++); }) && + all_of(data_b, data_e, [&i](T_ref a) { return a == T(i++); }); + + EXPECT_TRUE(check, "wrong effect of swap_ranges"); + + if (check) + { + bool swap_check = + all_of(data_b, data_e, check_swap()) && all_of(actual_b, actual_e, check_swap()); + EXPECT_TRUE(swap_check, "wrong effect of swap_ranges swap check"); + } + } + } +}; + +template +void +test() +{ + const std::size_t max_len = 100000; + + Sequence data(max_len); + Sequence actual(max_len); + + for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len)) + { + invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(), + actual.begin() + len); + } +} + +int32_t +main() +{ + test>(); + test>(); + test(); + test(); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_binary.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_binary.cc new file mode 100644 index 0000000..37b2d12 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_binary.cc @@ -0,0 +1,128 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- transform_binary.pass.cpp -----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +class TheOperation +{ + Out val; + + public: + TheOperation(Out v) : val(v) {} + Out + operator()(const In1& x, const In2& y) const + { + return Out(val + x - y); + } +}; + +template +void +check_and_reset(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator out_first) +{ + typedef typename std::iterator_traits::value_type Out; + typename std::iterator_traits::difference_type k = 0; + for (; first1 != last1; ++first1, ++first2, ++out_first, ++k) + { + // check + Out expected = Out(1.5) + *first1 - *first2; + Out actual = *out_first; + if (std::is_floating_point::value) + { + EXPECT_TRUE((expected > actual ? expected - actual : actual - expected) < 1e7, + "wrong value in output sequence"); + } + else + { + EXPECT_EQ(expected, actual, "wrong value in output sequence"); + } + // reset + *out_first = k % 7 != 4 ? 7 * k - 5 : 0; + } +} + +struct test_one_policy +{ + template + void + operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, + OutputIterator out_first, OutputIterator out_last, BinaryOp op) + { + auto orrr = std::transform(exec, first1, last1, first2, out_first, op); + check_and_reset(first1, last1, first2, out_first); + } +}; + +template +void +test(Predicate pred) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in1(n, [](size_t k) { return k % 5 != 1 ? 3 * k - 7 : 0; }); + Sequence in2(n, [](size_t k) { return k % 7 != 2 ? 5 * k - 5 : 0; }); + + Sequence out(n, [](size_t k) { return -1; }); + + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.begin(), in2.end(), out.begin(), + out.end(), pred); + invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cend(), in2.cbegin(), in2.cend(), out.begin(), + out.end(), pred); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + invoke_if(exec, [&]() { + InputIterator input_iter2 = input_iter; + transform(exec, input_iter, input_iter, input_iter2, out_iter, non_const(std::plus())); + }); + } +}; + +int32_t +main() +{ + //const operator() + test(TheOperation(1)); + test(TheOperation(1.5)); + //non-const operator() + test(non_const(TheOperation(1.5))); + test(non_const(TheOperation(1.5))); + //lambda + test([](const int8_t& x, const float64_t& y) { return int8_t(int8_t(1.5) + x - y); }); + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_unary.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_unary.cc new file mode 100644 index 0000000..2224c0a --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/transform_unary.cc @@ -0,0 +1,98 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- transform_unary.pass.cpp ------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +void +check_and_reset(InputIterator first, InputIterator last, OutputIterator out_first) +{ + typedef typename std::iterator_traits::value_type Out; + typename std::iterator_traits::difference_type k = 0; + for (; first != last; ++first, ++out_first, ++k) + { + // check + Out expected = 1 - *first; + Out actual = *out_first; + EXPECT_EQ(expected, actual, "wrong value in output sequence"); + // reset + *out_first = k % 7 != 4 ? 7 * k - 5 : 0; + } +} + +struct test_one_policy +{ + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, UnaryOp op) + { + auto orr = std::transform(exec, first, last, out_first, op); + EXPECT_TRUE(out_last == orr, "transform returned wrong iterator"); + check_and_reset(first, last, out_first); + } +}; + +template +void +test() +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [](int32_t k) { return k % 5 != 1 ? 3 * k - 7 : 0; }); + + Sequence out(n); + + const auto flip = Complement(1); + invoke_on_all_policies(test_one_policy(), in.begin(), in.end(), out.begin(), out.end(), flip); + invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cend(), out.begin(), out.end(), flip); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + invoke_if(exec, [&]() { transform(exec, input_iter, input_iter, out_iter, non_const(std::negate())); }); + } +}; + +int32_t +main() +{ + test(); + test(); + test(); + test(); + test(); + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/unique.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/unique.cc new file mode 100644 index 0000000..c879048 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/unique.cc @@ -0,0 +1,164 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- unique.pass.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Test for unique +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct run_unique +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, + ForwardIt last2, Generator generator) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, + ForwardIt last2, Generator generator) + { + } + + template + void + operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, + ForwardIt last2, BinaryPred pred, Generator generator) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, + ForwardIt last2, BinaryPred pred, Generator generator) + { + } +#endif + + template + void + operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, Generator generator) + { + using namespace std; + + // Preparation + fill_data(first1, last1, generator); + fill_data(first2, last2, generator); + + ForwardIt i = unique(first1, last1); + ForwardIt k = unique(exec, first2, last2); + + auto n = std::distance(first1, i); + EXPECT_TRUE(std::distance(first2, k) == n, "wrong return value from unique without predicate"); + EXPECT_EQ_N(first1, first2, n, "wrong effect from unique without predicate"); + } + + template + void + operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, BinaryPred pred, + Generator generator) + { + using namespace std; + + // Preparation + fill_data(first1, last1, generator); + fill_data(first2, last2, generator); + + ForwardIt i = unique(first1, last1, pred); + ForwardIt k = unique(exec, first2, last2, pred); + + auto n = std::distance(first1, i); + EXPECT_TRUE(std::distance(first2, k) == n, "wrong return value from unique with predicate"); + EXPECT_EQ_N(first1, first2, n, "wrong effect from unique with predicate"); + } +}; + +template +void +test(Generator generator, Predicate pred) +{ + const std::size_t max_size = 1000000; + Sequence in(max_size, [](size_t v) { return T(v); }); + Sequence exp(max_size, [](size_t v) { return T(v); }); + + for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + invoke_on_all_policies(run_unique(), exp.begin(), exp.begin() + n, in.begin(), in.begin() + n, generator); + invoke_on_all_policies(run_unique(), exp.begin(), exp.begin() + n, in.begin(), in.begin() + n, pred, generator); + } +} + +template +struct LocalWrapper +{ + T my_val; + + explicit LocalWrapper(T k) : my_val(k) {} + LocalWrapper(LocalWrapper&& input) : my_val(std::move(input.my_val)) {} + LocalWrapper& + operator=(LocalWrapper&& input) + { + my_val = std::move(input.my_val); + return *this; + } + friend bool + operator==(const LocalWrapper& x, const LocalWrapper& y) + { + return x.my_val == y.my_val; + } +}; + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + invoke_if(exec, [&]() { unique(exec, iter, iter, non_const(std::equal_to())); }); + } +}; + +int32_t +main() +{ +#if !__PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN + test([](size_t j) { return j / 3; }, + [](const int32_t& val1, const int32_t& val2) { return val1 * val1 == val2 * val2; }); + test([](size_t) { return float64_t(1); }, + [](const float64_t& val1, const float64_t& val2) { return val1 != val2; }); +#endif + test>([](size_t j) { return LocalWrapper(j); }, + [](const LocalWrapper& val1, const LocalWrapper& val2) { + return val1.my_val != val2.my_val; + }); + + test_algo_basic_single(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/unique_copy_equal.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/unique_copy_equal.cc new file mode 100644 index 0000000..1b66d26 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_modifying_operations/unique_copy_equal.cc @@ -0,0 +1,142 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- unique_copy_equal.pass.cpp ----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for unique_copy +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +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 + template + void + operator()(__pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, + Predicate pred, T trash) + { + } + + template + void + operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, + OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, + OutputIterator2 expected_last, Size n, Predicate pred, T trash) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, + Predicate pred, T trash) + { + // Cleaning + std::fill_n(expected_first, n, trash); + std::fill_n(out_first, n, trash); + + // Run unique_copy + auto i = unique_copy(first, last, expected_first); + auto k = unique_copy(exec, first, last, out_first); + EXPECT_EQ_N(expected_first, out_first, n, "wrong unique_copy effect"); + for (size_t j = 0; j < GuardSize; ++j) + { + ++k; + } + EXPECT_TRUE(out_last == k, "wrong return value from unique_copy"); + + // Cleaning + std::fill_n(expected_first, n, trash); + std::fill_n(out_first, n, trash); + // Run unique_copy with predicate + i = unique_copy(first, last, expected_first, pred); + k = unique_copy(exec, first, last, out_first, pred); + EXPECT_EQ_N(expected_first, out_first, n, "wrong unique_copy with predicate effect"); + for (size_t j = 0; j < GuardSize; ++j) + { + ++k; + } + EXPECT_TRUE(out_last == k, "wrong return value from unique_copy with predicate"); + } +}; + +template +void +test(T trash, BinaryPredicate pred, Convert convert, bool check_weakness = true) +{ + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + // count is number of output elements, plus a handful + // more for sake of detecting buffer overruns. + Sequence in(n, [&](size_t k) -> T { return convert(k ^ n); }); + using namespace std; + size_t count = GuardSize; + for (size_t k = 0; k < in.size(); ++k) + count += k == 0 || !pred(in[k], in[k - 1]) ? 1 : 0; + Sequence out(count, [=](size_t) { return trash; }); + Sequence expected(count, [=](size_t) { return trash; }); + if (check_weakness) + { + auto expected_result = unique_copy(in.begin(), in.end(), expected.begin(), pred); + size_t m = expected_result - expected.begin(); + EXPECT_TRUE(n / (n < 10000 ? 4 : 6) <= m && m <= (3 * n + 1) / 4, "weak test for unique_copy"); + } + invoke_on_all_policies(run_unique_copy(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), count, pred, trash); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + unique_copy(exec, input_iter, input_iter, out_iter, non_const(std::equal_to())); + } +}; + +int32_t +main(int32_t argc, char* argv[]) +{ + test(Number(42, OddTag()), std::equal_to(), + [](int32_t j) { return Number(3 * j / 13 ^ (j & 8), OddTag()); }); + + test(float32_t(42), std::equal_to(), + [](int32_t j) { return float32_t(5 * j / 23 ^ (j / 7)); }); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN + test(float32_t(42), [](float32_t x, float32_t y) { return false; }, + [](int32_t j) { return float32_t(j); }, false); +#endif + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/adjacent_find.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/adjacent_find.cc new file mode 100644 index 0000000..1ec6690 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/adjacent_find.cc @@ -0,0 +1,122 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- adjacent_find.pass.cpp --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_adjacent_find +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, Pred pred) + { + using namespace std; + + auto k = std::adjacent_find(first, last, pred); + auto i = adjacent_find(exec, first, last, pred); + EXPECT_TRUE(i == k, "wrong return value from adjacent_find with predicate"); + + i = adjacent_find(exec, first, last); + EXPECT_TRUE(i == k, "wrong return value from adjacent_find without predicate"); + } +}; + +template +void +test_adjacent_find_by_type() +{ + + size_t counts[] = {2, 3, 500}; + for (int32_t c = 0; c < const_size(counts); ++c) + { + + for (int32_t e = 0; e < (counts[c] >= 64 ? 64 : (counts[c] == 2 ? 1 : 2)); ++e) + { + Sequence in(counts[c], [](int32_t v) -> T { return T(v); }); //fill 0...n + in[e] = in[e + 1] = -1; //make an adjacent pair + + auto i = std::adjacent_find(in.cbegin(), in.cend(), std::equal_to()); + EXPECT_TRUE(i == in.cbegin() + e, "std::adjacent_find returned wrong result"); + + invoke_on_all_policies(test_adjacent_find(), in.begin(), in.end(), std::equal_to()); + invoke_on_all_policies(test_adjacent_find(), in.cbegin(), in.cend(), std::equal_to()); + } + } + + //special cases: size=0, size=1; + for (int32_t expect = 0; expect < 1; ++expect) + { + Sequence in(expect, [](int32_t v) -> T { return T(v); }); //fill 0...n + auto i = std::adjacent_find(in.cbegin(), in.cend(), std::equal_to()); + EXPECT_TRUE(i == in.cbegin() + expect, "std::adjacent_find returned wrong result"); + + invoke_on_all_policies(test_adjacent_find(), in.begin(), in.end(), std::equal_to()); + invoke_on_all_policies(test_adjacent_find(), in.cbegin(), in.cend(), std::equal_to()); + } + + //special cases: + Sequence a1 = {5, 5, 5, 6, 7, 8, 9}; + invoke_on_all_policies(test_adjacent_find(), a1.begin(), a1.end(), std::equal_to()); + invoke_on_all_policies(test_adjacent_find(), a1.begin() + 1, a1.end(), std::equal_to()); + + invoke_on_all_policies(test_adjacent_find(), a1.cbegin(), a1.cend(), std::equal_to()); + invoke_on_all_policies(test_adjacent_find(), a1.cbegin() + 1, a1.cend(), std::equal_to()); + + Sequence a2 = {5, 6, 7, 8, 9, 9}; + invoke_on_all_policies(test_adjacent_find(), a2.begin(), a2.end(), std::equal_to()); + invoke_on_all_policies(test_adjacent_find(), a2.begin(), a2.end() - 1, std::equal_to()); + + invoke_on_all_policies(test_adjacent_find(), a2.cbegin(), a2.cend(), std::equal_to()); + invoke_on_all_policies(test_adjacent_find(), a2.cbegin(), a2.cend() - 1, std::equal_to()); + + Sequence a3 = {5, 6, 6, 6, 7, 9, 9, 9, 9}; + invoke_on_all_policies(test_adjacent_find(), a3.begin(), a3.end(), std::equal_to()); + + invoke_on_all_policies(test_adjacent_find(), a3.cbegin(), a3.cend(), std::equal_to()); +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + adjacent_find(exec, iter, iter, non_const(std::equal_to())); + } +}; + +int32_t +main() +{ + + test_adjacent_find_by_type(); + test_adjacent_find_by_type(); + + test_algo_basic_single(run_for_rnd_bi>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/all_of.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/all_of.cc new file mode 100644 index 0000000..0e2ac01 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/all_of.cc @@ -0,0 +1,124 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- all_of.pass.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +/* + TODO: consider implementing the following tests for a better code coverage + - correctness + - bad input argument (if applicable) + - data corruption around/of input and output + - correctly work with nested parallelism + - check that algorithm does not require anything more than is described in its requirements section +*/ + +using namespace TestUtils; + +struct test_all_of +{ + template + void + operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected) + { + + auto actualr = std::all_of(exec, begin, end, pred); + EXPECT_EQ(expected, actualr, "result for all_of"); + } +}; + +template +struct Parity +{ + bool parity; + + public: + Parity(bool parity_) : parity(parity_) {} + bool + operator()(T value) const + { + return (size_t(value) ^ parity) % 2 == 0; + } +}; + +template +void +test(size_t bits) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + + // Sequence of odd values + Sequence in(n, [n, bits](size_t k) { return T(2 * HashBits(n, bits - 1) ^ 1); }); + + // Even value, or false when T is bool. + T spike(2 * HashBits(n, bits - 1)); + Sequence inCopy(in); + + invoke_on_all_policies(test_all_of(), in.begin(), in.end(), Parity(1), true); + invoke_on_all_policies(test_all_of(), in.cbegin(), in.cend(), Parity(1), true); + EXPECT_EQ(in, inCopy, "all_of modified input sequence"); + if (n > 0) + { + // Sprinkle in a miss + in[2 * n / 3] = spike; + invoke_on_all_policies(test_all_of(), in.begin(), in.end(), Parity(1), false); + invoke_on_all_policies(test_all_of(), in.cbegin(), in.cend(), Parity(1), false); + + // Sprinkle in a few more misses + in[n / 2] = spike; + in[n / 3] = spike; + invoke_on_all_policies(test_all_of(), in.begin(), in.end(), Parity(1), false); + invoke_on_all_policies(test_all_of(), in.cbegin(), in.cend(), Parity(1), false); + } + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + all_of(exec, iter, iter, non_const(is_even)); + } +}; + +int32_t +main() +{ + test(8 * sizeof(int32_t)); + test(8 * sizeof(uint16_t)); + test(53); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN + test(1); +#endif + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/any_of.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/any_of.cc new file mode 100644 index 0000000..87e0797 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/any_of.cc @@ -0,0 +1,110 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- any_of.pass.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +/* + TODO: consider implementing the following tests for a better code coverage + - correctness + - bad input argument (if applicable) + - data corruption around/of input and output + - correctly work with nested parallelism + - check that algorithm does not require anything more than is described in its requirements section +*/ + +using namespace TestUtils; + +struct test_any_of +{ + template + void + operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected) + { + + auto actualr = std::any_of(exec, begin, end, pred); + EXPECT_EQ(expected, actualr, "result for any_of"); + } +}; + +template +void +test(size_t bits) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + + // Sequence of odd values + Sequence in(n, [n, bits](size_t k) { return T(2 * HashBits(n, bits - 1) ^ 1); }); + + // Even value, or false when T is bool. + T spike(2 * HashBits(n, bits - 1)); + Sequence inCopy(in); + + invoke_on_all_policies(test_any_of(), in.begin(), in.end(), is_equal_to(spike), false); + invoke_on_all_policies(test_any_of(), in.cbegin(), in.cend(), is_equal_to(spike), false); + EXPECT_EQ(in, inCopy, "any_of modified input sequence"); + if (n > 0) + { + // Sprinkle in a hit + in[2 * n / 3] = spike; + invoke_on_all_policies(test_any_of(), in.begin(), in.end(), is_equal_to(spike), true); + invoke_on_all_policies(test_any_of(), in.cbegin(), in.cend(), is_equal_to(spike), true); + + // Sprinkle in a few more hits + in[n / 2] = spike; + in[n / 3] = spike; + invoke_on_all_policies(test_any_of(), in.begin(), in.end(), is_equal_to(spike), true); + invoke_on_all_policies(test_any_of(), in.cbegin(), in.cend(), is_equal_to(spike), true); + } + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + any_of(exec, iter, iter, non_const(is_even)); + } +}; + +int32_t +main() +{ + test(8 * sizeof(int32_t)); + test(8 * sizeof(uint16_t)); + test(53); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN + test(1); +#endif + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/count.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/count.cc new file mode 100644 index 0000000..4f2c0dd --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/count.cc @@ -0,0 +1,115 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- count.pass.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for count and count_if +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_count +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, T needle) + { + auto expected = std::count(first, last, needle); + auto result = std::count(exec, first, last, needle); + EXPECT_EQ(expected, result, "wrong count result"); + } +}; + +struct test_count_if +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred) + { + auto expected = std::count_if(first, last, pred); + auto result = std::count_if(exec, first, last, pred); + EXPECT_EQ(expected, result, "wrong count_if result"); + } +}; + +template +class IsEqual +{ + T value; + + public: + IsEqual(T value_, OddTag) : value(value_) {} + bool + operator()(const T& x) const + { + return x == value; + } +}; + +template +void +test(T needle, Predicate pred, Convert convert) +{ + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [=](size_t k) -> In { + // Sprinkle "42" and "50" early, so that short sequences have non-zero count. + return convert((n - k - 1) % 3 == 0 ? 42 : (n - k - 2) % 5 == 0 ? 50 : 3 * (int(k) % 1000 - 500)); + }); + invoke_on_all_policies(test_count(), in.begin(), in.end(), needle); + invoke_on_all_policies(test_count_if(), in.begin(), in.end(), pred); + + invoke_on_all_policies(test_count(), in.cbegin(), in.cend(), needle); + invoke_on_all_policies(test_count_if(), in.cbegin(), in.cend(), pred); + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + count_if(exec, iter, iter, non_const(is_even)); + } +}; + +int32_t +main() +{ + test(42, IsEqual(50, OddTag()), [](int32_t j) { return j; }); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN + test(42, [](const int32_t& x) { return true; }, [](int32_t j) { return j; }); +#endif + test(42, IsEqual(50, OddTag()), [](int32_t j) { return float64_t(j); }); + test(Number(42, OddTag()), IsEqual(Number(50, OddTag()), OddTag()), + [](int32_t j) { return Number(j, OddTag()); }); + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/equal.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/equal.cc new file mode 100644 index 0000000..2b51fc4 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/equal.cc @@ -0,0 +1,175 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- equal.pass.cpp ----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +#define CPP14_ENABLED 0 + +struct UserType +{ + float32_t f; + float64_t d; + int32_t i; + size_t key; + + bool + operator()(UserType a, UserType b) + { + return a.key < b.key; + } + bool + operator<(UserType a) + { + return a.key < key; + } + bool + operator>=(UserType a) + { + return a.key <= key; + } + bool + operator<=(UserType a) + { + return a.key >= key; + } + bool + operator==(UserType a) + { + return a.key == key; + } + bool + operator==(UserType a) const + { + return a.key == key; + } + bool + operator!=(UserType a) + { + return a.key != key; + } + UserType operator!() + { + UserType tmp; + tmp.key = !key; + return tmp; + } + friend std::ostream& + operator<<(std::ostream& stream, const UserType a) + { + stream << a.key; + return stream; + } + + UserType() : key(-1), f(0.0f), d(0.0), i(0) {} + UserType(size_t Number) : key(Number), f(0.0f), d(0.0), i(0) {} + UserType& + operator=(const UserType& other) + { + key = other.key; + return *this; + } + UserType(const UserType& other) : key(other.key), f(other.f), d(other.d), i(other.i) {} + UserType(UserType&& other) : key(other.key), f(other.f), d(other.d), i(other.i) + { + other.key = -1; + other.f = 0.0f; + other.d = 0.0; + other.i = 0; + } +}; + +struct test_one_policy +{ + template + void + operator()(ExecutionPolicy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, bool is_true_equal) + { + using namespace std; + + auto expected = equal(first1, last1, first2); + auto actual = equal(exec, first1, last1, first2); + EXPECT_EQ(expected, actual, "result for equal for random-access iterator, checking against std::equal()"); + + // testing bool + EXPECT_TRUE(is_true_equal == actual, "result for equal for random-access iterator, bool"); + +//add C++14 equal symantics tests +//add more cases for inCopy size less than in +#if CPP14_ENABLED + auto actualr14 = std::equal(in.cbegin(), in.cend(), inCopy.cbegin(), inCopy.cend()); + EXPECT_EQ(expected, actualr14, "result for equal for random-access iterator"); +#endif + } +}; + +template +void +test(size_t bits) +{ + for (size_t n = 1; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + + // Sequence of odd values + Sequence in(n, [bits](size_t k) { return T(2 * HashBits(k, bits - 1) ^ 1); }); + Sequence inCopy(in); + + invoke_on_all_policies(test_one_policy(), in.begin(), in.end(), inCopy.begin(), true); + invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cend(), inCopy.cbegin(), true); + + // testing bool !equal() + inCopy[0] = !inCopy[0]; + invoke_on_all_policies(test_one_policy(), in.begin(), in.end(), inCopy.begin(), false); + invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cend(), inCopy.cbegin(), false); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter) + { + equal(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to())); + } +}; + +int32_t +main() +{ + + test(8 * sizeof(int32_t)); + test(8 * sizeof(uint16_t)); + test(53); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN + test(1); +#endif + test(256); + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find.cc new file mode 100644 index 0000000..29e3ca0 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find.cc @@ -0,0 +1,103 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- find.pass.cpp -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for find +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_find +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Value value) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value) + { + } +#endif + + template + void + operator()(Policy&& exec, Iterator first, Iterator last, Value value) + { + auto i = std::find(first, last, value); + auto j = find(exec, first, last, value); + EXPECT_TRUE(i == j, "wrong return value from find"); + } +}; + +template +void +test(Value value, Hit hit, Miss miss) +{ + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [&](size_t k) -> T { return miss(n ^ k); }); + // Try different find positions, including not found. + // By going backwards, we can add extra matches that are *not* supposed to be found. + // The decreasing exponential gives us O(n) total work for the loop since each find takes O(m) time. + for (size_t m = n; m > 0; m *= 0.6) + { + if (m < n) + in[m] = hit(n ^ m); + invoke_on_all_policies(test_find(), in.begin(), in.end(), value); + invoke_on_all_policies(test_find(), in.cbegin(), in.cend(), value); + } + } +} + +// Type defined for sake of checking that std::find works with asymmetric ==. +class Weird +{ + Number value; + + public: + friend bool + operator==(Number x, Weird y) + { + return x == y.value; + } + Weird(int32_t val, OddTag) : value(val, OddTag()) {} +}; + +int32_t +main() +{ + // Note that the "hit" and "miss" functions here avoid overflow issues. + test(Weird(42, OddTag()), [](int32_t j) { return Number(42, OddTag()); }, // hit + [](int32_t j) { return Number(j == 42 ? 0 : j, OddTag()); }); // miss + + // Test with value that is equal to two different bit patterns (-0.0 and 0.0) + test(-0.0, [](int32_t j) { return j & 1 ? 0.0 : -0.0; }, // hit + [](int32_t j) { return j == 0 ? ~j : j; }); // miss + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_end.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_end.cc new file mode 100644 index 0000000..42bfe0f --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_end.cc @@ -0,0 +1,130 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- find_end.pass.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_one_policy +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, + Predicate pred) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, + Predicate pred) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, Predicate pred) + { + using namespace std; + // For find_end + { + auto expected = find_end(b, e, bsub, esub, pred); + auto actual = find_end(exec, b, e, bsub, esub); + EXPECT_TRUE(actual == expected, "wrong return result from find_end"); + + actual = find_end(exec, b, e, bsub, esub, pred); + EXPECT_TRUE(actual == expected, "wrong return result from find_end with a predicate"); + } + + // For search + { + auto expected = search(b, e, bsub, esub, pred); + auto actual = search(exec, b, e, bsub, esub); + EXPECT_TRUE(actual == expected, "wrong return result from search"); + + actual = search(exec, b, e, bsub, esub, pred); + EXPECT_TRUE(actual == expected, "wrong return result from search with a predicate"); + } + } +}; + +template +void +test(const std::size_t bits) +{ + + const std::size_t max_n1 = 1000; + const std::size_t max_n2 = (max_n1 * 10) / 8; + Sequence in(max_n1, [max_n1, bits](std::size_t k) { return T(2 * HashBits(max_n1, bits - 1) ^ 1); }); + Sequence sub(max_n2, [max_n1, bits](std::size_t k) { return T(2 * HashBits(max_n1, bits - 1)); }); + for (std::size_t n1 = 0; n1 <= max_n1; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1)) + { + std::size_t sub_n[] = {0, 1, 3, n1, (n1 * 10) / 8}; + std::size_t res[] = {0, 1, n1 / 2, n1}; + for (auto n2 : sub_n) + { + for (auto r : res) + { + std::size_t i = r, isub = 0; + for (; i < n1 & isub < n2; ++i, ++isub) + in[i] = sub[isub]; + invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n1, sub.begin(), sub.begin() + n2, + std::equal_to()); + invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cbegin() + n1, sub.cbegin(), + sub.cbegin() + n2, std::equal_to()); + } + } + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter) + { + invoke_if(exec, [&]() { + find_end(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to())); + search(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to())); + }); + } +}; + +int32_t +main() +{ + test(8 * sizeof(int32_t)); + test(8 * sizeof(uint16_t)); + test(53); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN + test(1); +#endif + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_first_of.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_first_of.cc new file mode 100644 index 0000000..4d4a539 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_first_of.cc @@ -0,0 +1,119 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- find_first_of.pass.cpp --------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_one_policy +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, + Predicate pred) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, + Predicate pred) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, Predicate pred) + { + using namespace std; + Iterator1 expected = find_first_of(b, e, bsub, esub, pred); + Iterator1 actual = find_first_of(exec, b, e, bsub, esub, pred); + EXPECT_TRUE(actual == expected, "wrong return result from find_first_of with a predicate"); + + expected = find_first_of(b, e, bsub, esub); + actual = find_first_of(exec, b, e, bsub, esub); + EXPECT_TRUE(actual == expected, "wrong return result from find_first_of"); + } +}; + +template +void +test(Predicate pred) +{ + + const std::size_t max_n1 = 1000; + const std::size_t max_n2 = (max_n1 * 10) / 8; + Sequence in1(max_n1, [](std::size_t k) { return T(1); }); + Sequence in2(max_n2, [](std::size_t k) { return T(0); }); + for (std::size_t n1 = 0; n1 <= max_n1; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1)) + { + std::size_t sub_n[] = {0, 1, n1 / 3, n1, (n1 * 10) / 8}; + for (const auto n2 : sub_n) + { + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.data(), in2.data() + n2, pred); + + in2[n2 / 2] = T(1); + invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + n1, in2.data(), in2.data() + n2, + pred); + + if (n2 >= 3) + { + in2[2 * n2 / 3] = T(1); + invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + n1, in2.begin(), + in2.begin() + n2, pred); + in2[2 * n2 / 3] = T(0); + } + in2[n2 / 2] = T(0); + } + } + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + max_n1 / 10, in1.data(), + in1.data() + max_n1 / 10, pred); +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter) + { + invoke_if(exec, [&]() { + find_first_of(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::equal_to())); + }); + } +}; + +int32_t +main() +{ + test(std::equal_to()); + test(std::not_equal_to()); + test([](const float64_t x, const float64_t y) { return x * x == y * y; }); + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_if.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_if.cc new file mode 100644 index 0000000..aa4b0bf --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/find_if.cc @@ -0,0 +1,116 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- find_if.pass.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for find_if and find_if_not +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_find_if +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred, + NotPredicate not_pred) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred, + NotPredicate not_pred) + { + } +#endif + + template + void + operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred, NotPredicate not_pred) + { + auto i = std::find_if(first, last, pred); + auto j = find_if(exec, first, last, pred); + EXPECT_TRUE(i == j, "wrong return value from find_if"); + auto i_not = find_if_not(exec, first, last, not_pred); + EXPECT_TRUE(i_not == i, "wrong return value from find_if_not"); + } +}; + +template +void +test(Predicate pred, Hit hit, Miss miss) +{ + auto not_pred = [pred](T x) { return !pred(x); }; + // Try sequences of various lengths. + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [&](size_t k) -> T { return miss(n ^ k); }); + // Try different find positions, including not found. + // By going backwards, we can add extra matches that are *not* supposed to be found. + // The decreasing exponential gives us O(n) total work for the loop since each find takes O(m) time. + for (size_t m = n; m > 0; m *= 0.6) + { + if (m < n) + in[m] = hit(n ^ m); + invoke_on_all_policies(test_find_if(), in.begin(), in.end(), pred, not_pred); + invoke_on_all_policies(test_find_if(), in.cbegin(), in.cend(), pred, not_pred); + } + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + + invoke_if(exec, [&]() { + find_if(exec, iter, iter, non_const(is_even)); + find_if_not(exec, iter, iter, non_const(is_even)); + }); + } +}; + +int32_t +main() +{ +#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN + // Note that the "hit" and "miss" functions here avoid overflow issues. + test(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 +#endif + + // Try type for which algorithm can really be vectorized. + test([](float32_t x) { return x >= 0; }, [](float32_t j) { return j * j; }, + [](float32_t j) { return -1 - j * j; }); + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/for_each.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/for_each.cc new file mode 100644 index 0000000..dc9e146 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/for_each.cc @@ -0,0 +1,109 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- for_each.pass.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct Gen +{ + Type + operator()(std::size_t k) + { + return Type(k % 5 != 1 ? 3 * k - 7 : 0); + }; +}; + +template +struct Flip +{ + int32_t val; + Flip(int32_t y) : val(y) {} + T + operator()(T& x) const + { + return x = val - x; + } +}; + +struct test_one_policy +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, Iterator expected_first, Iterator expected_last, Size n) + { + typedef typename std::iterator_traits::value_type T; + + // Try for_each + std::for_each(expected_first, expected_last, Flip(1)); + for_each(exec, first, last, Flip(1)); + EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each"); + + // Try for_each_n + std::for_each_n(__pstl::execution::seq, expected_first, n, Flip(1)); + for_each_n(exec, first, n, Flip(1)); + EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each_n"); + } +}; + +template +void +test() +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence inout(n, Gen()); + Sequence expected(n, Gen()); + invoke_on_all_policies(test_one_policy(), inout.begin(), inout.end(), expected.begin(), expected.end(), + inout.size()); + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + invoke_if(exec, [&]() { + auto f = [](typename std::iterator_traits::reference x) { x = x + 1; }; + + for_each(exec, iter, iter, non_const(f)); + for_each_n(exec, iter, 0, non_const(f)); + }); + } +}; + +int32_t +main() +{ + test(); + test(); + test(); + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/mismatch.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/mismatch.cc new file mode 100644 index 0000000..50a6120 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/mismatch.cc @@ -0,0 +1,143 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- mismatch.pass.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/algorithm" +#include "pstl/numeric" +#include "pstl/memory" + +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_mismatch +{ + template + void + operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2) + { + using namespace std; + typedef typename iterator_traits::value_type T; + { + const auto expected = std::mismatch(first1, last1, first2, std::equal_to()); + const auto res3 = mismatch(exec, first1, last1, first2, std::equal_to()); + EXPECT_TRUE(expected == res3, "wrong return result from mismatch"); + const auto res4 = mismatch(exec, first1, last1, first2); + EXPECT_TRUE(expected == res4, "wrong return result from mismatch"); + } + } + template + void + operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2) + { + using namespace std; + typedef typename iterator_traits::value_type T; + { + const auto expected = mismatch(__pstl::execution::seq, first1, last1, first2, last2, std::equal_to()); + const auto res1 = mismatch(exec, first1, last1, first2, last2, std::equal_to()); + EXPECT_TRUE(expected == res1, "wrong return result from mismatch"); + const auto res2 = mismatch(exec, first1, last1, first2, last2); + EXPECT_TRUE(expected == res2, "wrong return result from mismatch"); + } + } +}; + +template +void +test_mismatch_by_type() +{ + using namespace std; + for (size_t size = 0; size <= 100000; size = size <= 16 ? size + 1 : size_t(3.1415 * size)) + { + const T val = T(-1); + Sequence in(size, [](size_t v) -> T { return T(v % 100); }); + { + Sequence in2(in); + invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin(), in2.end()); + invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin()); + + const size_t min_size = 3; + if (size > min_size) + { + const size_t idx_for_1 = size / min_size; + in[idx_for_1] = val, in[idx_for_1 + 1] = val, in[idx_for_1 + 2] = val; + invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin(), in2.end()); + invoke_on_all_policies(test_mismatch(), in.begin(), in.end(), in2.begin()); + } + + const size_t idx_for_2 = 500; + if (size >= idx_for_2 - 1) + { + in2[size / idx_for_2] = val; + invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin(), in2.cend()); + invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin()); + } + } + { + Sequence in2(100, [](size_t v) -> T { return T(v); }); + invoke_on_all_policies(test_mismatch(), in2.begin(), in2.end(), in.begin(), in.end()); + // We can't call std::mismatch with semantic below when size of second sequence less than size of first sequence + if (in2.size() <= in.size()) + invoke_on_all_policies(test_mismatch(), in2.begin(), in2.end(), in.begin()); + + const size_t idx = 97; + in2[idx] = val; + in2[idx + 1] = val; + invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin(), in2.cend()); + if (in.size() <= in2.size()) + invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin()); + } + { + Sequence in2({}); + invoke_on_all_policies(test_mismatch(), in2.begin(), in2.end(), in.begin(), in.end()); + + invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin(), in2.cend()); + if (in.size() == 0) + invoke_on_all_policies(test_mismatch(), in.cbegin(), in.cend(), in2.cbegin()); + } + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter) + { + mismatch(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::less())); + } +}; + +int32_t +main() +{ + + test_mismatch_by_type(); + test_mismatch_by_type(); + test_mismatch_by_type>(); + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/none_of.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/none_of.cc new file mode 100644 index 0000000..a06ac3d --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/none_of.cc @@ -0,0 +1,108 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- none_of.pass.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +/* + TODO: consider implementing the following tests for a better code coverage + - correctness + - bad input argument (if applicable) + - data corruption around/of input and output + - correctly work with nested parallelism + - check that algorithm does not require anything more than is described in its requirements section +*/ + +using namespace TestUtils; + +struct test_none_of +{ + template + void + operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected) + { + + auto actualr = std::none_of(exec, begin, end, pred); + EXPECT_EQ(expected, actualr, "result for none_of"); + } +}; + +template +void +test(size_t bits) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + + // Sequence of odd values + Sequence in(n, [n, bits](size_t k) { return T(2 * HashBits(n, bits - 1) ^ 1); }); + + // Even value, or false when T is bool. + T spike(2 * HashBits(n, bits - 1)); + + invoke_on_all_policies(test_none_of(), in.begin(), in.end(), is_equal_to(spike), true); + invoke_on_all_policies(test_none_of(), in.cbegin(), in.cend(), is_equal_to(spike), true); + if (n > 0) + { + // Sprinkle in a hit + in[2 * n / 3] = spike; + invoke_on_all_policies(test_none_of(), in.begin(), in.end(), is_equal_to(spike), false); + invoke_on_all_policies(test_none_of(), in.cbegin(), in.cend(), is_equal_to(spike), false); + + // Sprinkle in a few more hits + in[n / 3] = spike; + in[n / 2] = spike; + invoke_on_all_policies(test_none_of(), in.begin(), in.end(), is_equal_to(spike), false); + invoke_on_all_policies(test_none_of(), in.cbegin(), in.cend(), is_equal_to(spike), false); + } + } +} + +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + auto is_even = [&](float64_t v) { + uint32_t i = (uint32_t)v; + return i % 2 == 0; + }; + none_of(exec, iter, iter, non_const(is_even)); + } +}; + +int32_t +main() +{ + test(8 * sizeof(int32_t)); + test(8 * sizeof(uint16_t)); + test(53); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN + test(1); +#endif + + test_algo_basic_single(run_for_rnd_fw()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/nth_element.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/nth_element.cc new file mode 100644 index 0000000..4e25442 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/nth_element.cc @@ -0,0 +1,185 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- nth_element.pass.cpp ----------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include +#include +#include "pstl/execution" +#include "pstl/algorithm" + +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +// User defined type with minimal requirements +template +struct DataType +{ + explicit DataType(int32_t k) : my_val(k) {} + DataType(DataType&& input) + { + my_val = std::move(input.my_val); + input.my_val = T(0); + } + DataType& + operator=(DataType&& input) + { + my_val = std::move(input.my_val); + input.my_val = T(0); + return *this; + } + T + get_val() const + { + return my_val; + } + + friend std::ostream& + operator<<(std::ostream& stream, const DataType& input) + { + return stream << input.my_val; + } + + private: + T my_val; +}; + +template +bool +is_equal(const DataType& x, const DataType& y) +{ + return x.get_val() == y.get_val(); +} + +template +bool +is_equal(const T& x, const T& y) +{ + return x == y; +} + +struct test_one_policy +{ +#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 + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2, + Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) + { + } + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2, + Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) + { + } +#endif + + // nth_element works only with random access iterators + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator1 first2, Iterator1 last2, Size n, Size m, + Generator1 generator1, Generator2 generator2, Compare comp) + { + + using T = typename std::iterator_traits::value_type; + const Iterator1 mid1 = std::next(first1, m); + const Iterator1 mid2 = std::next(first2, m); + + fill_data(first1, mid1, generator1); + fill_data(mid1, last1, generator2); + fill_data(first2, mid2, generator1); + fill_data(mid2, last2, generator2); + std::nth_element(first1, mid1, last1, comp); + std::nth_element(exec, first2, mid2, last2, comp); + if (m > 0 && m < n) + { + EXPECT_TRUE(is_equal(*mid1, *mid2), "wrong result from nth_element with predicate"); + } + EXPECT_TRUE(std::find_first_of(first2, mid2, mid2, last2, [comp](T& x, T& y) { return comp(y, x); }) == mid2, + "wrong effect from nth_element with predicate"); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator1 first2, Iterator1 last2, Size n, Size m, + Generator1 generator1, Generator2 generator2, Compare comp) + { + } +}; + +template +void +test_by_type(Generator1 generator1, Generator2 generator2, Compare comp) +{ + using namespace std; + size_t max_size = 10000; + Sequence in1(max_size, [](size_t v) { return T(v); }); + Sequence exp(max_size, [](size_t v) { return T(v); }); + size_t m; + + for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + m = 0; + invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m, + generator1, generator2, comp); + m = n / 7; + invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m, + generator1, generator2, comp); + m = 3 * n / 5; + invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m, + generator1, generator2, comp); + } + invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + max_size, in1.begin(), in1.begin() + max_size, + max_size, max_size, generator1, generator2, comp); +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + invoke_if(exec, [&]() { nth_element(exec, iter, iter, iter, non_const(std::less())); }); + } +}; + +int32_t +main() +{ + test_by_type([](int32_t i) { return 10 * i; }, [](int32_t i) { return i + 1; }, std::less()); + test_by_type([](int32_t) { return 0; }, [](int32_t) { return 0; }, std::less()); + + test_by_type([](int32_t i) { return -2 * i; }, [](int32_t i) { return -(2 * i + 1); }, + [](const float64_t x, const float64_t y) { return x > y; }); + + test_by_type>( + [](int32_t i) { return DataType(2 * i + 1); }, [](int32_t i) { return DataType(2 * i); }, + [](const DataType& x, const DataType& y) { return x.get_val() < y.get_val(); }); + + test_algo_basic_single(run_for_rnd>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse.cc new file mode 100644 index 0000000..7348c99 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse.cc @@ -0,0 +1,112 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- reverse.pass.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_one_policy +{ +#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 + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, + Iterator2 actual_e) + { + } + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, + Iterator2 actual_e) + { + } +#endif + + template + typename std::enable_if::value>::type + operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e) + { + using namespace std; + + copy(data_b, data_e, actual_b); + + reverse(exec, actual_b, actual_e); + + bool check = equal(data_b, data_e, reverse_iterator(actual_e)); + + EXPECT_TRUE(check, "wrong result of reverse"); + } + + template + typename std::enable_if::value>::type + operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e) + { + } +}; + +template +void +test() +{ + const std::size_t max_len = 100000; + + Sequence actual(max_len); + + Sequence data(max_len, [](std::size_t i) { return T(i); }); + + for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len)) + { + invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(), + actual.begin() + len); + } +} + +template +struct wrapper +{ + T t; + wrapper() {} + explicit wrapper(T t_) : t(t_) {} + bool + operator==(const wrapper& a) const + { + return t == a.t; + } +}; + +int32_t +main() +{ + test(); + test(); + test(); +#if !__PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN + test>(); +#endif + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse_copy.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse_copy.cc new file mode 100644 index 0000000..10b5f75 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/reverse_copy.cc @@ -0,0 +1,141 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- reverse_copy.pass.cpp ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct wrapper +{ + T t; + wrapper() {} + explicit wrapper(T t_) : t(t_) {} + wrapper& + operator=(const T& t_) + { + t = t_; + return *this; + } + bool + operator==(const wrapper& t_) const + { + return t == t_.t; + } +}; + +template +bool +eq(const wrapper& a, const wrapper& b) +{ + return a.t == b.t; +} + +template +bool +eq(const T1& a, const T2& b) +{ + return a == b; +} + +// we need to save state here, because we need to test with different types of iterators +// due to the caller invoke_on_all_policies does forcing modification passed iterator type to cover additional usage cases. +template +struct test_one_policy +{ + Iterator data_b; + Iterator data_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 || \ + __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e) + { + } + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 actual_b, Iterator1 actual_e) + { + using namespace std; + using T = typename iterator_traits::value_type; + using DifferenceType = typename iterator_traits::difference_type; + + fill(actual_b, actual_e, T(-123)); + Iterator1 actual_return = reverse_copy(exec, data_b, data_e, actual_b); + + EXPECT_TRUE(actual_return == actual_e, "wrong result of reverse_copy"); + + const auto n = std::distance(data_b, data_e); + Sequence res(n); + std::copy(std::reverse_iterator(data_e), std::reverse_iterator(data_b), res.begin()); + + EXPECT_EQ_N(res.begin(), actual_b, n, "wrong effect of reverse_copy"); + } +}; + +template +void +test() +{ + typedef typename Sequence::iterator iterator_type; + typedef typename Sequence::const_bidirectional_iterator cbi_iterator_type; + + const std::size_t max_len = 100000; + + Sequence actual(max_len); + + Sequence data(max_len, [](std::size_t i) { return T1(i); }); + + for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len)) + { + invoke_on_all_policies(test_one_policy(data.begin(), data.begin() + len), actual.begin(), + actual.begin() + len); + invoke_on_all_policies(test_one_policy(data.cbibegin(), std::next(data.cbibegin(), len)), + actual.begin(), actual.begin() + len); + } +} + +int32_t +main() +{ + // clang-3.8 fails to correctly auto vectorize the loop in some cases of different types of container's elements, + // for example: int32_t and int8_t. This issue isn't detected for clang-3.9 and newer versions. + test(); + test(); + test(); + test, wrapper>(); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/search_n.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/search_n.cc new file mode 100644 index 0000000..b096833 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_nonmodifying/search_n.cc @@ -0,0 +1,116 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- search_n.pass.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_one_policy +{ +#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 + template + void + operator()(pstl::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred) + { + } + template + void + operator()(pstl::execution::parallel_unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, + Predicate pred) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator b, Iterator e, Size count, const T& value, Predicate pred) + { + using namespace std; + auto expected = search_n(b, e, count, value, pred); + auto actual = search_n(exec, b, e, count, value); + EXPECT_TRUE(actual == expected, "wrong return result from search_n"); + + actual = search_n(exec, b, e, count, value, pred); + EXPECT_TRUE(actual == expected, "wrong return result from search_n with a predicate"); + } +}; + +template +void +test() +{ + + const std::size_t max_n1 = 100000; + const T value = T(1); + for (std::size_t n1 = 0; n1 <= max_n1; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1)) + { + std::size_t sub_n[] = {0, 1, 3, n1, (n1 * 10) / 8}; + std::size_t res[] = {0, 1, n1 / 2, n1}; + for (auto n2 : sub_n) + { + // Some of standard libraries return "first" in this case. We return "last" according to the standard + if (n2 == 0) + { + continue; + } + for (auto r : res) + { + Sequence in(n1, [n1](std::size_t k) { return T(0); }); + std::size_t i = r, isub = 0; + for (; i < n1 & isub < n2; ++i, ++isub) + in[i] = value; + + invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n1, n2, value, std::equal_to()); + invoke_on_all_policies(test_one_policy(), in.cbegin(), in.cbegin() + n1, n2, value, std::equal_to()); + } + } + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + invoke_if(exec, [&]() { search_n(exec, iter, iter, 0, T(0), non_const(std::equal_to())); }); + } +}; + +int32_t +main() +{ + test(); + test(); + test(); +#if !__PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN + test(); +#endif + + test_algo_basic_single(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/includes.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/includes.cc new file mode 100644 index 0000000..2e7dc8f --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/includes.cc @@ -0,0 +1,115 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- includes.pass.cpp -------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct Num +{ + T val; + explicit Num(const T& v) : val(v) {} + + //for "includes" checks + template + bool + operator<(const Num& v1) const + { + return val < v1.val; + } + + //The types Type1 and Type2 must be such that an object of type InputIt can be dereferenced and then implicitly converted to both of them + template + operator Num() const + { + return Num((T1)val); + } +}; + +struct test_one_policy +{ + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, + Compare comp) + { + + auto expect_res = std::includes(first1, last1, first2, last2, comp); + auto res = std::includes(exec, first1, last1, first2, last2, comp); + + EXPECT_TRUE(expect_res == res, "wrong result for includes"); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, + Compare comp) + { + } +}; + +template +void +test_includes(Compare compare) +{ + + const std::size_t n_max = 1000000; + + // The rand()%(2*n+1) encourages generation of some duplicates. + std::srand(42); + + for (std::size_t n = 0; n < n_max; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + for (std::size_t m = 0; m < n_max; m = m <= 16 ? m + 1 : size_t(2.71828 * m)) + { + //prepare the input ranges + Sequence in1(n, [](std::size_t k) { return rand() % (2 * k + 1); }); + Sequence in2(m, [](std::size_t k) { return rand() % (k + 1); }); + + std::sort(in1.begin(), in1.end(), compare); + std::sort(in2.begin(), in2.end(), compare); + + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(), compare); + + //test w/ non constant predicate + if (n < 5 && m < 5) + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(), + non_const(compare)); + } + } +} + +int32_t +main() +{ + + test_includes(__pstl::__internal::__pstl_less()); + test_includes, Num>([](const Num& x, const Num& y) { return x < y; }); + std::cout << done() << std::endl; + + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/is_heap.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/is_heap.cc new file mode 100644 index 0000000..14d4118 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/is_heap.cc @@ -0,0 +1,152 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- is_heap.pass.cpp --------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for is_heap, is_heap_until +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" +#include + +using namespace TestUtils; + +struct WithCmpOp +{ + int32_t _first; + int32_t _second; + WithCmpOp() : _first(0), _second(0){}; + explicit WithCmpOp(int32_t x) : _first(x), _second(x){}; + bool + operator<(const WithCmpOp& rhs) const + { + return this->_first < rhs._first; + } +}; + +struct test_is_heap +{ +#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 + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred) + { + } + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred) + { + } +#endif + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred) + { + using namespace std; + // is_heap + { + bool expected = is_heap(first, last); + bool actual = is_heap(exec, first, last); + EXPECT_TRUE(expected == actual, "wrong return value from is_heap"); + } + // is_heap with predicate + { + bool expected = is_heap(first, last, pred); + bool actual = is_heap(exec, first, last, pred); + EXPECT_TRUE(expected == actual, "wrong return value from is_heap with predicate"); + } + // is_heap_until + { + Iterator expected = is_heap_until(first, last); + Iterator actual = is_heap_until(exec, first, last); + EXPECT_TRUE(expected == actual, "wrong return value from is_heap_until"); + } + // is_heap_until with predicate + { + const Iterator expected = is_heap_until(first, last, pred); + const auto y = std::distance(first, expected); + const Iterator actual = is_heap_until(exec, first, last, pred); + const auto x = std::distance(first, actual); + EXPECT_TRUE(expected == actual, "wrong return value from is_heap_until with predicate"); + } + } + + // is_heap, is_heap_until works only with random access iterators + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred) + { + } +}; + +template +void +test_is_heap_by_type(Comp comp) +{ + using namespace std; + + const size_t max_size = 100000; + for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [](size_t v) -> T { return T(v); }); + + invoke_on_all_policies(test_is_heap(), in.begin(), in.end(), comp); + + std::make_heap(in.begin(), in.begin() + n / 4, comp); + invoke_on_all_policies(test_is_heap(), in.cbegin(), in.cend(), comp); + + std::make_heap(in.begin(), in.begin() + n / 3, comp); + invoke_on_all_policies(test_is_heap(), in.begin(), in.end(), comp); + + std::make_heap(in.begin(), in.end(), comp); + invoke_on_all_policies(test_is_heap(), in.cbegin(), in.cend(), comp); + } + + Sequence in(max_size / 10, [](size_t v) -> T { return T(1); }); + invoke_on_all_policies(test_is_heap(), in.begin(), in.end(), comp); +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + invoke_if(exec, [&]() { + is_heap(exec, iter, iter, non_const(std::less())); + is_heap_until(exec, iter, iter, non_const(std::less())); + }); + } +}; + +int32_t +main() +{ + test_is_heap_by_type(std::greater()); + test_is_heap_by_type(std::less()); + test_is_heap_by_type([](uint64_t x, uint64_t y) { return x % 100 < y % 100; }); + + test_algo_basic_single(run_for_rnd>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/is_sorted.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/is_sorted.cc new file mode 100644 index 0000000..11fa230 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/is_sorted.cc @@ -0,0 +1,108 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- is_sorted.pass.cpp ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_is_sorted +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, bool exam) + { + using namespace std; + typedef typename std::iterator_traits::value_type T; + + //try random-access iterator + bool res = is_sorted(exec, first, last); + EXPECT_TRUE(exam == res, "is_sorted wrong result for random-access iterator"); + auto iexam = is_sorted_until(first, last); + auto ires = is_sorted_until(exec, first, last); + EXPECT_TRUE(iexam == ires, "is_sorted_until wrong result for random-access iterator"); + + //try random-access iterator with a predicate + res = is_sorted(exec, first, last, std::less()); + EXPECT_TRUE(exam == res, "is_sorted wrong result for random-access iterator"); + iexam = is_sorted_until(first, last, std::less()); + ires = is_sorted_until(exec, first, last, std::less()); + EXPECT_TRUE(iexam == ires, "is_sorted_until wrong result for random-access iterator"); + } +}; + +template +void +test_is_sorted_by_type() +{ + + Sequence in(99999, [](size_t v) -> T { return T(v); }); //fill 0..n + + invoke_on_all_policies(test_is_sorted(), in.begin(), in.end(), std::is_sorted(in.begin(), in.end())); + invoke_on_all_policies(test_is_sorted(), in.cbegin(), in.cend(), std::is_sorted(in.begin(), in.end())); + + in[in.size() / 2] = -1; + invoke_on_all_policies(test_is_sorted(), in.begin(), in.end(), std::is_sorted(in.begin(), in.end())); + invoke_on_all_policies(test_is_sorted(), in.cbegin(), in.cend(), std::is_sorted(in.begin(), in.end())); + + in[1] = -1; + invoke_on_all_policies(test_is_sorted(), in.begin(), in.end(), std::is_sorted(in.begin(), in.end())); + invoke_on_all_policies(test_is_sorted(), in.cbegin(), in.cend(), std::is_sorted(in.begin(), in.end())); + + //an empty container + Sequence in0(0); + invoke_on_all_policies(test_is_sorted(), in0.begin(), in0.end(), std::is_sorted(in0.begin(), in0.end())); + invoke_on_all_policies(test_is_sorted(), in0.cbegin(), in0.cend(), std::is_sorted(in0.begin(), in0.end())); + + //non-descending order + Sequence in1(9, [](size_t v) -> T { return T(0); }); + invoke_on_all_policies(test_is_sorted(), in1.begin(), in1.end(), std::is_sorted(in1.begin(), in1.end())); + invoke_on_all_policies(test_is_sorted(), in1.cbegin(), in1.cend(), std::is_sorted(in1.begin(), in1.end())); +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + is_sorted(exec, iter, iter, std::less()); + is_sorted_until(exec, iter, iter, std::less()); + } +}; + +int32_t +main() +{ + + test_is_sorted_by_type(); + test_is_sorted_by_type(); + + test_is_sorted_by_type>(); + + test_algo_basic_single(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/lexicographical_compare.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/lexicographical_compare.cc new file mode 100644 index 0000000..7cc6a1c --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/lexicographical_compare.cc @@ -0,0 +1,183 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- lexicographical_compare.pass.cpp ----------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_one_policy +{ + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Iterator2 begin2, Iterator2 end2, + Predicate pred) + { + const bool expected = std::lexicographical_compare(begin1, end1, begin2, end2, pred); + const bool actual = std::lexicographical_compare(exec, begin1, end1, begin2, end2, pred); + EXPECT_TRUE(actual == expected, "wrong return result from lexicographical compare with predicate"); + } + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Iterator2 begin2, Iterator2 end2) + { + const bool expected = std::lexicographical_compare(begin1, end1, begin2, end2); + const bool actual = std::lexicographical_compare(exec, begin1, end1, begin2, end2); + EXPECT_TRUE(actual == expected, "wrong return result from lexicographical compare without predicate"); + } +}; + +template +void +test(Predicate pred) +{ + + const std::size_t max_n = 1000000; + Sequence in1(max_n, [](std::size_t k) { return T1(k); }); + Sequence in2(2 * max_n, [](std::size_t k) { return T2(k); }); + + std::size_t n2; + + // Test case: Call algorithm's version without predicate. + invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + max_n, in2.cbegin() + 3 * max_n / 10, + in2.cbegin() + 5 * max_n / 10); + + // Test case: If one range is a prefix of another, the shorter range is lexicographically less than the other. + std::size_t max_n2 = max_n / 10; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + max_n, in2.cbegin(), in2.cbegin() + max_n2, + pred); + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + max_n, in2.begin() + max_n2, + in2.begin() + 3 * max_n2, pred); + + // Test case: If one range is a prefix of another, the shorter range is lexicographically less than the other. + max_n2 = 2 * max_n; + invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + max_n, in2.begin(), in2.begin() + max_n2, + pred); + + for (std::size_t n1 = 0; n1 <= max_n; n1 = n1 <= 16 ? n1 + 1 : std::size_t(3.1415 * n1)) + { + // Test case: If two ranges have equivalent elements and are of the same length, then the ranges are lexicographically equal. + n2 = n1; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred); + + n2 = n1; + // Test case: two ranges have different elements and are of the same length (second sequence less than first) + std::size_t ind = n1 / 2; + in2[ind] = T2(-1); + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred); + in2[ind] = T2(ind); + + // Test case: two ranges have different elements and are of the same length (first sequence less than second) + ind = n1 / 5; + in1[ind] = T1(-1); + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.cbegin(), in2.cbegin() + n2, pred); + in1[ind] = T1(ind); + } +} + +template +void +test_string(Predicate pred) +{ + + const std::size_t max_n = 1000000; + std::string in1 = ""; + std::string in2 = ""; + for (std::size_t n1 = 0; n1 <= max_n; ++n1) + { + in1 += n1; + } + + for (std::size_t n1 = 0; n1 <= 2 * max_n; ++n1) + { + in2 += n1; + } + + std::size_t n2; + + for (std::size_t n1 = 0; n1 < in1.size(); n1 = n1 <= 16 ? n1 + 1 : std::size_t(3.1415 * n1)) + { + // Test case: If two ranges have equivalent elements and are of the same length, then the ranges are lexicographically equal. + n2 = n1; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred); + + n2 = n1; + // Test case: two ranges have different elements and are of the same length (second sequence less than first) + in2[n1 / 2] = 'a'; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.begin(), in2.begin() + n2, pred); + + // Test case: two ranges have different elements and are of the same length (first sequence less than second) + in1[n1 / 5] = 'a'; + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n1, in2.cbegin(), in2.cbegin() + n2, pred); + } + invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cbegin() + max_n, in2.cbegin() + 3 * max_n / 10, + in2.cbegin() + 5 * max_n / 10); +} + +template +struct LocalWrapper +{ + explicit LocalWrapper(std::size_t k) : my_val(k) {} + bool + operator<(const LocalWrapper& w) const + { + return my_val < w.my_val; + } + + private: + T my_val; +}; + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, FirstIterator first_iter, SecondInterator second_iter) + { + invoke_if(exec, [&]() { + lexicographical_compare(exec, first_iter, first_iter, second_iter, second_iter, non_const(std::less())); + }); + } +}; + +int32_t +main() +{ + test(std::less()); + test(std::greater()); +#if !__PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN + test([](const float64_t x, const int32_t y) { return x * x < y * y; }); +#endif + test, LocalWrapper>( + [](const LocalWrapper& x, const LocalWrapper& y) { return x < y; }); + test_string([](const char x, const char y) { return x < y; }); + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc new file mode 100644 index 0000000..e194a1d --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc @@ -0,0 +1,202 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- minmax_element.pass.cpp -------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +#include +#include +#include + +using namespace TestUtils; + +struct check_minelement +{ + template + void + operator()(Policy&& exec, Iterator begin, Iterator end) + { + typedef typename std::iterator_traits::value_type T; + const Iterator expect = std::min_element(begin, end); + const Iterator result = std::min_element(exec, begin, end); + const Iterator result_pred = std::min_element(exec, begin, end, std::less()); + EXPECT_TRUE(expect == result, "wrong return result from min_element"); + EXPECT_TRUE(expect == result_pred, "wrong return result from min_element"); + } +}; + +struct check_maxelement +{ + template + void + operator()(Policy&& exec, Iterator begin, Iterator end) + { + typedef typename std::iterator_traits::value_type T; + const Iterator expect = std::max_element(begin, end); + const Iterator result = std::max_element(exec, begin, end); + const Iterator result_pred = std::max_element(exec, begin, end, std::less()); + EXPECT_TRUE(expect == result, "wrong return result from max_element"); + EXPECT_TRUE(expect == result_pred, "wrong return result from max_element"); + } +}; + +struct check_minmaxelement +{ + template + void + operator()(Policy&& exec, Iterator begin, Iterator end) + { + typedef typename std::iterator_traits::value_type T; + const std::pair expect = std::minmax_element(begin, end); + const std::pair got = std::minmax_element(exec, begin, end); + const std::pair got_pred = std::minmax_element(exec, begin, end, std::less()); + EXPECT_TRUE(expect.first == got.first, "wrong return result from minmax_element (min part)"); + EXPECT_TRUE(expect.second == got.second, "wrong return result from minmax_element (max part)"); + EXPECT_TRUE(expect == got_pred, "wrong return result from minmax_element"); + } +}; + +template +struct sequence_wrapper +{ + TestUtils::Sequence seq; + const T min_value; + const T max_value; + static const std::size_t bits = 30; // We assume that T can handle signed 2^bits+1 value + + // TestUtils::HashBits returns value between 0 and (1< T { return T(TestUtils::HashBits(i, bits)); }); + } + + // sets first one at position `at` and bunch of them farther + void + set_desired_value(std::size_t at, T value) + { + if (seq.size() == 0) + return; + seq[at] = value; + + //Producing serveral red herrings + for (std::size_t i = at + 1; i < seq.size(); i += 1 + TestUtils::HashBits(i, 5)) + seq[i] = value; + } +}; + +template +void +test_by_type(std::size_t n) +{ + sequence_wrapper wseq(n); + + // to avoid overtesing we use std::set to leave only unique indexes + std::set targets{0}; + if (n > 1) + { + targets.insert(1); + targets.insert(2.718282 * n / 3); + targets.insert(n / 2); + targets.insert(n / 7.389056); + targets.insert(n - 1); // last + } + + for (std::set::iterator it = targets.begin(); it != targets.end(); ++it) + { + wseq.pattern_fill(); + wseq.set_desired_value(*it, wseq.min_value); + TestUtils::invoke_on_all_policies(check_minelement(), wseq.seq.cbegin(), wseq.seq.cend()); + TestUtils::invoke_on_all_policies(check_minelement(), wseq.seq.begin(), wseq.seq.end()); + + wseq.set_desired_value(*it, wseq.max_value); + TestUtils::invoke_on_all_policies(check_maxelement(), wseq.seq.cbegin(), wseq.seq.cend()); + TestUtils::invoke_on_all_policies(check_maxelement(), wseq.seq.begin(), wseq.seq.end()); + + if (targets.size() > 1) + { + for (std::set::reverse_iterator rit = targets.rbegin(); rit != targets.rend(); ++rit) + { + if (*rit == *it) // we requires at least 2 unique indexes in targets + break; + wseq.pattern_fill(); + wseq.set_desired_value(*it, wseq.min_value); // setting minimum element + wseq.set_desired_value(*rit, wseq.max_value); // setting maximum element + TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.cbegin(), wseq.seq.cend()); + TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.begin(), wseq.seq.end()); + } + } + else + { // we must check this corner case; it can not be tested in loop above + TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.cbegin(), wseq.seq.cend()); + TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.begin(), wseq.seq.end()); + } + } +} + +// should provide minimal requirements only +struct OnlyLessCompare +{ + int32_t val; + OnlyLessCompare() : val(0) {} + OnlyLessCompare(int32_t val_) : val(val_) {} + bool + operator<(const OnlyLessCompare& other) const + { + return val < other.val; + } +}; + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + max_element(exec, iter, iter, non_const(std::less())); + min_element(exec, iter, iter, non_const(std::less())); + minmax_element(exec, iter, iter, non_const(std::less())); + } +}; + +int32_t +main() +{ + using TestUtils::float64_t; + const std::size_t N = 100000; + + for (std::size_t n = 0; n < N; n = n < 16 ? n + 1 : size_t(3.14159 * n)) + { + test_by_type(n); + test_by_type(n); + } + + test_algo_basic_single(run_for_rnd_fw>()); + + std::cout << TestUtils::done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/partial_sort.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/partial_sort.cc new file mode 100644 index 0000000..674f5a3 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/partial_sort.cc @@ -0,0 +1,160 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- partial_sort.pass.cpp ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + + +#include + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +static std::atomic count_val; +static std::atomic count_comp; + +template +struct Num +{ + T val; + + Num() { ++count_val; } + Num(T v) : val(v) { ++count_val; } + Num(const Num& v) : val(v.val) { ++count_val; } + Num(Num&& v) : val(v.val) { ++count_val; } + ~Num() { --count_val; } + Num& + operator=(const Num& v) + { + val = v.val; + return *this; + } + operator T() const { return val; } + bool + operator<(const Num& v) const + { + ++count_comp; + return val < v.val; + } +}; + +struct test_brick_partial_sort +{ + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, InputIterator first, InputIterator last, InputIterator exp_first, InputIterator exp_last, + Compare compare) + { + + typedef typename std::iterator_traits::value_type T; + + // The rand()%(2*n+1) encourages generation of some duplicates. + std::srand(42); + const std::size_t n = last - first; + for (std::size_t k = 0; k < n; ++k) + { + first[k] = T(rand() % (2 * n + 1)); + } + std::copy(first, last, exp_first); + + for (std::size_t p = 0; p < n; p = p <= 16 ? p + 1 : std::size_t(31.415 * p)) + { + auto m1 = first + p; + auto m2 = exp_first + p; + + std::partial_sort(exp_first, m2, exp_last, compare); + count_comp = 0; + std::partial_sort(exec, first, m1, last, compare); + 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; + if (m1 - first > 1) + { + auto complex = std::ceil(n * std::log(float32_t(m1 - first))); +#if __PSTL_USE_PAR_POLICIES + auto p = tbb::this_task_arena::max_concurrency(); +#else + auto p = 1; +#endif + +#ifdef _DEBUG + if (count_comp > complex * p) + { + std::cout << "complexity exceeded" << std::endl; + } +#endif + } + } + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, InputIterator first, InputIterator last, InputIterator exp_first, InputIterator exp_last, + Compare compare) + { + } +}; + +template +void +test_partial_sort(Compare compare) +{ + + const std::size_t n_max = 100000; + Sequence in(n_max); + Sequence exp(n_max); + for (std::size_t n = 0; n < n_max; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + invoke_on_all_policies(test_brick_partial_sort(), in.begin(), in.begin() + n, exp.begin(), exp.begin() + n, + compare); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + partial_sort(exec, iter, iter, iter, non_const(std::less())); + } +}; + +int32_t +main() +{ + count_val = 0; + + test_partial_sort>([](Num x, Num y) { return x < y; }); + + EXPECT_TRUE(count_val == 0, "cleanup error"); + + test_partial_sort( + [](int32_t x, int32_t y) { return x > y; }); // Reversed so accidental use of < will be detected. + + test_algo_basic_single(run_for_rnd>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/partial_sort_copy.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/partial_sort_copy.cc new file mode 100644 index 0000000..431c859 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/partial_sort_copy.cc @@ -0,0 +1,199 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- partial_sort_copy.pass.cpp ----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Tests for partial_sort_copy + +#include +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct Num +{ + T val; + + Num() : val(0) {} + Num(T v) : val(v) {} + Num(const Num& v) : val(v.val) {} + Num(Num&& v) : val(v.val) {} + Num& + operator=(const Num& v) + { + val = v.val; + return *this; + } + operator T() const { return val; } + bool + operator<(const Num& v) const + { + return val < v.val; + } +}; + +template +struct test_one_policy +{ + RandomAccessIterator d_first; + RandomAccessIterator d_last; + RandomAccessIterator exp_first; + RandomAccessIterator exp_last; + // 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) + : d_first(b1), d_last(e1), exp_first(b2), exp_last(e2) + { + } +#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 + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, + const T& trash, Compare compare) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, + const T& trash, Compare compare) + { + } + + template + void + operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, + const T& trash) + { + } + + template + void + operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, + const T& trash) + { + } +#endif + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, Size n1, Size n2, const T& trash, + Compare compare) + { + prepare_data(first, last, n1, trash); + RandomAccessIterator exp = std::partial_sort_copy(first, last, exp_first, exp_last, compare); + RandomAccessIterator res = std::partial_sort_copy(exec, first, last, d_first, d_last, compare); + + EXPECT_TRUE((exp - exp_first) == (res - d_first), "wrong result from partial_sort_copy with predicate"); + EXPECT_EQ_N(exp_first, d_first, n2, "wrong effect from partial_sort_copy with predicate"); + } + + template + void + operator()(Policy&& exec, InputIterator first, InputIterator last, Size n1, Size n2, const T& trash) + { + prepare_data(first, last, n1, trash); + RandomAccessIterator exp = std::partial_sort_copy(first, last, exp_first, exp_last); + RandomAccessIterator res = std::partial_sort_copy(exec, first, last, d_first, d_last); + + EXPECT_TRUE((exp - exp_first) == (res - d_first), "wrong result from partial_sort_copy without predicate"); + EXPECT_EQ_N(exp_first, d_first, n2, "wrong effect from partial_sort_copy without predicate"); + } + + private: + template + void + prepare_data(InputIterator first, InputIterator last, Size n1, const T& trash) + { + // The rand()%(2*n+1) encourages generation of some duplicates. + std::srand(42); + std::generate(first, last, [n1]() { return T(rand() % (2 * n1 + 1)); }); + + std::fill(exp_first, exp_last, trash); + std::fill(d_first, d_last, trash); + } +}; + +template +void +test_partial_sort_copy(Compare compare) +{ + + typedef typename Sequence::iterator iterator_type; + const std::size_t n_max = 100000; + Sequence in(n_max); + Sequence out(2 * n_max); + Sequence exp(2 * n_max); + std::size_t n1 = 0; + std::size_t n2; + T trash = T(-666); + for (; n1 < n_max; n1 = n1 <= 16 ? n1 + 1 : size_t(3.1415 * n1)) + { + // If both sequences are equal + n2 = n1; + invoke_on_all_policies( + test_one_policy(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2), in.begin(), + in.begin() + n1, n1, n2, trash, compare); + + // If first sequence is greater than second + n2 = n1 / 3; + invoke_on_all_policies( + test_one_policy(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2), in.begin(), + in.begin() + n1, n1, n2, trash, compare); + + // If first sequence is less than second + n2 = 2 * n1; + invoke_on_all_policies( + test_one_policy(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2), in.begin(), + in.begin() + n1, n1, n2, trash, compare); + } + // Test partial_sort_copy without predicate + n1 = n_max; + n2 = 2 * n1; + invoke_on_all_policies(test_one_policy(out.begin(), out.begin() + n2, exp.begin(), exp.begin() + n2), + in.begin(), in.begin() + n1, n1, n2, trash); +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + invoke_if(exec, [&]() { + partial_sort_copy(exec, input_iter, input_iter, out_iter, out_iter, non_const(std::less())); + }); + } +}; + +int32_t +main() +{ + test_partial_sort_copy>([](Num x, Num y) { return x < y; }); + test_partial_sort_copy([](int32_t x, int32_t y) { return x > y; }); + + test_algo_basic_double(run_for_rnd>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/set.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/set.cc new file mode 100644 index 0000000..4b9e7aa --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/set.cc @@ -0,0 +1,171 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- set.pass.cpp ------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct Num +{ + T val; + + Num() : val{} {} + Num(const T& v) : val(v) {} + + //for "includes" checks + template + bool + operator<(const Num& v1) const + { + return val < v1.val; + } + + //The types Type1 and Type2 must be such that an object of type InputIt can be dereferenced and then implicitly converted to both of them + template + operator Num() const + { + return Num((T1)val); + } + + friend bool + operator==(const Num& v1, const Num& v2) + { + return v1.val == v2.val; + } +}; + +struct test_one_policy +{ + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, + Compare comp) + { + using T1 = typename std::iterator_traits::value_type; + + auto n1 = std::distance(first1, last1); + auto n2 = std::distance(first2, last2); + auto n = n1 + n2; + Sequence expect(n); + Sequence out(n); + + //1. set_union + auto expect_res = std::set_union(first1, last1, first2, last2, expect.begin(), comp); + auto res = std::set_union(exec, first1, last1, first2, last2, out.begin(), comp); + + EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_union"); + EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res), "wrong set_union effect"); + + //2. set_intersection + expect_res = std::set_intersection(first1, last1, first2, last2, expect.begin(), comp); + res = std::set_intersection(exec, first1, last1, first2, last2, out.begin(), comp); + + EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_intersection"); + EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res), "wrong set_intersection effect"); + + //3. set_difference + expect_res = std::set_difference(first1, last1, first2, last2, expect.begin(), comp); + res = std::set_difference(exec, first1, last1, first2, last2, out.begin(), comp); + + EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_difference"); + EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res), "wrong set_difference effect"); + + //4. set_symmetric_difference + expect_res = std::set_symmetric_difference(first1, last1, first2, last2, expect.begin(), comp); + res = std::set_symmetric_difference(exec, first1, last1, first2, last2, out.begin(), comp); + + EXPECT_TRUE(expect_res - expect.begin() == res - out.begin(), "wrong result for set_symmetric_difference"); + EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res), + "wrong set_symmetric_difference effect"); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, + Compare comp) + { + } +}; + +template +void +test_set(Compare compare) +{ + + const std::size_t n_max = 100000; + + // The rand()%(2*n+1) encourages generation of some duplicates. + std::srand(4200); + + for (std::size_t n = 0; n < n_max; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + for (std::size_t m = 0; m < n_max; m = m <= 16 ? m + 1 : size_t(2.71828 * m)) + { + //prepare the input ranges + Sequence in1(n, [n](std::size_t k) { return rand() % (2 * k + 1); }); + Sequence in2(m, [m](std::size_t k) { return (m % 2) * rand() + rand() % (k + 1); }); + + std::sort(in1.begin(), in1.end(), compare); + std::sort(in2.begin(), in2.end(), compare); + + invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.cbegin(), in2.cend(), compare); + } + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter) + { + set_difference(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less())); + + set_intersection(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less())); + + set_symmetric_difference(exec, input_iter, input_iter, input_iter, input_iter, out_iter, + non_const(std::less())); + + set_union(exec, input_iter, input_iter, input_iter, input_iter, out_iter, non_const(std::less())); + } +}; + +int32_t +main() +{ + + test_set(__pstl::__internal::__pstl_less()); + test_set, Num>([](const Num& x, const Num& y) { return x < y; }); + + test_algo_basic_double(run_for_rnd_fw>()); + + std::cout << done() << std::endl; + + return 0; +} diff --git a/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/sort.cc b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/sort.cc new file mode 100644 index 0000000..e0c55df --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/sort.cc @@ -0,0 +1,255 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- sort.pass.cpp -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/algorithm" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; +#define _CRT_SECURE_NO_WARNINGS + +#include + +static bool Stable; + +//! Number of extant keys +static std::atomic KeyCount; + +//! One more than highest index in array to be sorted. +static uint32_t LastIndex; + +//! Keeping Equal() static and a friend of ParanoidKey class (C++, paragraphs 3.5/7.1.1) +class ParanoidKey; +static bool +Equal(const ParanoidKey& x, const ParanoidKey& y); + +//! A key to be sorted, with lots of checking. +class ParanoidKey +{ + //! Value used by comparator + int32_t value; + //! Original position or special value (Empty or Dead) + int32_t index; + //! Special value used to mark object without a comparable value, e.g. after being moved from. + static const int32_t Empty = -1; + //! Special value used to mark destroyed objects. + static const int32_t Dead = -2; + // True if key object has comparable value + bool + isLive() const + { + return (uint32_t)(index) < LastIndex; + } + // True if key object has been constructed. + bool + isConstructed() const + { + return isLive() || index == Empty; + } + + public: + ParanoidKey() + { + ++KeyCount; + index = Empty; + value = Empty; + } + ParanoidKey(const ParanoidKey& k) : value(k.value), index(k.index) + { + EXPECT_TRUE(k.isLive(), "source for copy-constructor is dead"); + ++KeyCount; + } + ~ParanoidKey() + { + EXPECT_TRUE(isConstructed(), "double destruction"); + index = Dead; + --KeyCount; + } + ParanoidKey& + operator=(const ParanoidKey& k) + { + EXPECT_TRUE(k.isLive(), "source for copy-assignment is dead"); + EXPECT_TRUE(isConstructed(), "destination for copy-assignment is dead"); + value = k.value; + index = k.index; + return *this; + } + ParanoidKey(int32_t index, int32_t value, OddTag) : index(index), value(value) {} + ParanoidKey(ParanoidKey&& k) : value(k.value), index(k.index) + { + EXPECT_TRUE(k.isConstructed(), "source for move-construction is dead"); +// std::stable_sort() fails in move semantics on paranoid test before VS2015 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 + k.index = Empty; +#endif + ++KeyCount; + } + ParanoidKey& + operator=(ParanoidKey&& k) + { + EXPECT_TRUE(k.isConstructed(), "source for move-assignment is dead"); + EXPECT_TRUE(isConstructed(), "destination for move-assignment is dead"); + value = k.value; + index = k.index; +// std::stable_sort() fails in move semantics on paranoid test before VS2015 +#if !defined(_MSC_VER) || _MSC_VER >= 1900 + k.index = Empty; +#endif + return *this; + } + friend class KeyCompare; + friend bool + Equal(const ParanoidKey& x, const ParanoidKey& y); +}; + +class KeyCompare +{ + enum statusType + { + //! Special value used to mark defined object. + Live = 0xabcd, + //! Special value used to mark destroyed objects. + Dead = -1 + } status; + + public: + KeyCompare(OddTag) : status(Live) {} + ~KeyCompare() { status = Dead; } + bool + operator()(const ParanoidKey& j, const ParanoidKey& k) const + { + EXPECT_TRUE(status == Live, "key comparison object not defined"); + EXPECT_TRUE(j.isLive(), "first key to operator() is not live"); + EXPECT_TRUE(k.isLive(), "second key to operator() is not live"); + return j.value < k.value; + } +}; + +// Equal is equality comparison used for checking result of sort against expected result. +static bool +Equal(const ParanoidKey& x, const ParanoidKey& y) +{ + return (x.value == y.value && !Stable) || (x.index == y.index); +} + +static bool +Equal(float32_t x, float32_t y) +{ + return x == y; +} + +static bool +Equal(int32_t x, int32_t y) +{ + return x == y; +} + +struct test_sort_with_compare +{ + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, OutputIterator tmp_first, OutputIterator tmp_last, OutputIterator2 expected_first, + OutputIterator2 expected_last, InputIterator first, InputIterator last, Size n, Compare compare) + { + using namespace std; + copy_n(first, n, expected_first); + copy_n(first, n, tmp_first); + if (Stable) + std::stable_sort(expected_first + 1, expected_last - 1, compare); + else + std::sort(expected_first + 1, expected_last - 1, compare); + int32_t count0 = KeyCount; + if (Stable) + stable_sort(exec, tmp_first + 1, tmp_last - 1, compare); + else + sort(exec, tmp_first + 1, tmp_last - 1, compare); + + for (size_t i = 0; i < n; ++i, ++expected_first, ++tmp_first) + { + // Check that expected[i] is equal to tmp[i] + EXPECT_TRUE(Equal(*expected_first, *tmp_first), "bad sort"); + } + int32_t count1 = KeyCount; + EXPECT_EQ(count0, count1, "key cleanup error"); + } + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, OutputIterator tmp_first, OutputIterator tmp_last, OutputIterator2 expected_first, + OutputIterator2 expected_last, InputIterator first, InputIterator last, Size n, Compare compare) + { + } +}; + +template +void +test_sort(Compare compare, Convert convert) +{ + for (size_t n = 0; n < 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + LastIndex = n + 2; + // The rand()%(2*n+1) encourages generation of some duplicates. + // Sequence is padded with an extra element at front and back, to detect overwrite bugs. + Sequence in(n + 2, [=](size_t k) { return convert(k, rand() % (2 * n + 1)); }); + Sequence expected(in); + Sequence tmp(in); + invoke_on_all_policies(test_sort_with_compare(), tmp.begin(), tmp.end(), expected.begin(), expected.end(), + in.begin(), in.end(), in.size(), compare); + } +} + +template +struct test_non_const +{ + template + void + operator()(Policy&& exec, Iterator iter) + { + sort(exec, iter, iter, non_const(std::less())); + stable_sort(exec, iter, iter, non_const(std::less())); + } +}; + +int32_t +main() +{ + std::srand(42); + for (int32_t kind = 0; kind < 2; ++kind) + { + Stable = kind != 0; + test_sort(KeyCompare(OddTag()), + [](size_t k, size_t val) { return ParanoidKey(k, val, OddTag()); }); + test_sort([](float32_t x, float32_t y) { return x < y; }, + [](size_t, size_t val) { return float32_t(val); }); + test_sort( + [](int32_t x, int32_t y) { return x > y; }, // Reversed so accidental use of < will be detected. + [](size_t, size_t val) { return int32_t(val); }); + } + + test_algo_basic_single(run_for_rnd>()); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/adjacent_difference.cc b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/adjacent_difference.cc new file mode 100644 index 0000000..01a3fb6 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/adjacent_difference.cc @@ -0,0 +1,179 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- adjacent_difference.pass.cpp --------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include + +#include "pstl/execution" +#include "pstl/algorithm" +#include "pstl/numeric" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +template +struct wrapper +{ + T t; + explicit wrapper(T t_) : t(t_) {} + template + wrapper(const wrapper& a) + { + t = a.t; + } + template + void + operator=(const wrapper& a) + { + t = a.t; + } + wrapper + operator-(const wrapper& a) const + { + return wrapper(t - a.t); + } +}; + +template +bool +compare(const T& a, const T& b) +{ + return a == b; +} + +template +bool +compare(const wrapper& a, const wrapper& b) +{ + return a.t == b.t; +} + +template +typename std::enable_if::value, bool>::type +compute_and_check(Iterator1 first, Iterator1 last, Iterator2 d_first, T, Function f) +{ + using T2 = typename std::iterator_traits::value_type; + + if (first == last) + return true; + + T2 temp(*first); + if (!compare(temp, *d_first)) + return false; + Iterator1 second = std::next(first); + + ++d_first; + for (; second != last; ++first, ++second, ++d_first) + { + T2 temp(f(*second, *first)); + if (!compare(temp, *d_first)) + return false; + } + + return true; +} + +// we don't want to check equality here +// because we can't be sure it will be strictly equal for floating point types +template +typename std::enable_if::value, bool>::type +compute_and_check(Iterator1 first, Iterator1 last, Iterator2 d_first, T, Function) +{ + return true; +} + +struct test_one_policy +{ +#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 + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, + Iterator2 actual_e, T trash, Function f) + { + } + template + typename std::enable_if::value, void>::type + operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, + Iterator2 actual_e, T trash, Function f) + { + } +#endif + + template + void + operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e, + T trash, Function f) + { + using namespace std; + using T2 = typename std::iterator_traits::value_type; + + fill(actual_b, actual_e, trash); + + Iterator2 actual_return = adjacent_difference(exec, data_b, data_e, actual_b); + EXPECT_TRUE(compute_and_check(data_b, data_e, actual_b, T2(0), std::minus()), + "wrong effect of adjacent_difference"); + EXPECT_TRUE(actual_return == actual_e, "wrong result of adjacent_difference"); + + fill(actual_b, actual_e, trash); + + actual_return = adjacent_difference(exec, data_b, data_e, actual_b, f); + EXPECT_TRUE(compute_and_check(data_b, data_e, actual_b, T2(0), f), + "wrong effect of adjacent_difference with functor"); + EXPECT_TRUE(actual_return == actual_e, "wrong result of adjacent_difference with functor"); + } +}; + +template +void +test(Pred pred) +{ + typedef typename Sequence::iterator iterator_type; + + const std::size_t max_len = 100000; + + const T2 value = T2(77); + const T1 trash = T1(31); + + Sequence actual(max_len, [](std::size_t i) { return T1(i); }); + + Sequence data(max_len, [&value](std::size_t i) { return i % 3 == 2 ? T2(i * i) : value; }); + + for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len)) + { + invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(), + actual.begin() + len, trash, pred); + invoke_on_all_policies(test_one_policy(), data.cbegin(), data.cbegin() + len, actual.begin(), + actual.begin() + len, trash, pred); + } +} + +int32_t +main() +{ + test([](uint32_t a, uint32_t b) { return a - b; }); + test([](int64_t a, int64_t b) { return a / (b + 1); }); + test([](float32_t a, float32_t b) { return (a + b) / 2; }); + test, wrapper>( + [](const wrapper& a, const wrapper& b) { return a - b; }); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/reduce.cc b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/reduce.cc new file mode 100644 index 0000000..9ecef9c --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/reduce.cc @@ -0,0 +1,121 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- reduce.pass.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/numeric" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +struct test_long_forms_for_one_policy +{ + template + void + operator()(Policy&& exec, Iterator first, Iterator last, T init, BinaryOp binary, T expected) + { + T result_r = std::reduce(exec, first, last, init, binary); + EXPECT_EQ(expected, result_r, "bad result from reduce(exec, first, last, init, binary_op)"); + } +}; + +template +void +test_long_form(T init, BinaryOp binary_op, F f) +{ + // Try sequences of various lengths + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + T expected(init); + Sequence in(n, [n, f](size_t k) { return f((int32_t(k ^ n) % 1000 - 500)); }); + for (size_t k = 0; k < n; ++k) + expected = binary_op(expected, in[k]); + + using namespace std; + + T result = transform_reduce_serial(in.cfbegin(), in.cfend(), init, binary_op, [](const T& t) { return t; }); + EXPECT_EQ(expected, result, "bad result from reduce(first, last, init, binary_op_op)"); + + 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); + } +} + +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 + template + void + operator()(__pstl::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected) + { + } + template + void + operator()(__pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected) + { + } +#endif + + template + void + operator()(Policy&& exec, Iterator first, Iterator last, Sum init, Sum expected) + { + using namespace std; + + Sum r0 = init + reduce(exec, first, last); + EXPECT_EQ(expected, r0, "bad result from reduce(exec, first, last)"); + + Sum r1 = reduce(exec, first, last, init); + EXPECT_EQ(expected, r1, "bad result from reduce(exec, first, last, init)"); + } +}; + +// Test forms of reduce(...) that omit the binary_op or init operands. +void +test_short_forms() +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sum init(42, OddTag()); + Sum expected(init); + Sequence in(n, [n](size_t k) { return Sum((int32_t(k ^ n) % 1000 - 500), OddTag()); }); + for (size_t k = 0; k < n; ++k) + expected = expected + in[k]; + invoke_on_all_policies(test_two_short_forms(), in.begin(), in.end(), init, expected); + invoke_on_all_policies(test_two_short_forms(), in.cbegin(), in.cend(), init, expected); + } +} + +int32_t +main() +{ + // Test for popular types + test_long_form(42, std::plus(), [](int32_t x) { return x; }); + test_long_form(42.0, std::plus(), [](float64_t x) { return x; }); + + // Test for strict types + test_long_form(Number(42, OddTag()), Add(OddTag()), [](int32_t x) { return Number(x, OddTag()); }); + + // Short forms are just facade for long forms, so just test with a single type. + test_short_forms(); + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/scan.cc b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/scan.cc new file mode 100644 index 0000000..28027dd --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/scan.cc @@ -0,0 +1,207 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- scan.pass.cpp -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/numeric" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +// We provide the no execution policy versions of the exclusive_scan and inclusive_scan due checking correctness result of the versions with execution policies. +//TODO: to add a macro for availability of ver implementations +template +OutputIterator +exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, T init) +{ + for (; first != last; ++first, ++result) + { + *result = init; + init = init + *first; + } + return result; +} + +template +OutputIterator +exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, T init, BinaryOperation binary_op) +{ + for (; first != last; ++first, ++result) + { + *result = init; + init = binary_op(init, *first); + } + return result; +} + +// Note: N4582 is missing the ", class T". Issue was reported 2016-Apr-11 to cxxeditor@gmail.com +template +OutputIterator +inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op, T init) +{ + for (; first != last; ++first, ++result) + { + init = binary_op(init, *first); + *result = init; + } + return result; +} + +template +OutputIterator +inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op) +{ + if (first != last) + { + auto tmp = *first; + *result = tmp; + return inclusive_scan_serial(++first, last, ++result, binary_op, tmp); + } + else + { + return result; + } +} + +template +OutputIterator +inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result) +{ + typedef typename std::iterator_traits::value_type input_type; + return inclusive_scan_serial(first, last, result, std::plus()); +} + +// Most of the framework required for testing inclusive and exclusive scan is identical, +// so the tests for both are in this file. Which is being tested is controlled by the global +// flag inclusive, which is set to each alternative by main(). +static bool inclusive; + +template +void +check_and_reset(Iterator expected_first, Iterator out_first, Size n, T trash) +{ + EXPECT_EQ_N(expected_first, out_first, n, + inclusive ? "wrong result from inclusive_scan" : "wrong result from exclusive_scan"); + std::fill_n(out_first, n, trash); +} + +struct test_scan_with_plus +{ + template + void + operator()(Policy&& exec, Iterator1 in_first, Iterator1 in_last, Iterator2 out_first, Iterator2 out_last, + Iterator3 expected_first, Iterator3 expected_last, Size n, T init, T trash) + { + using namespace std; + + auto orr1 = inclusive ? inclusive_scan_serial(in_first, in_last, expected_first) + : exclusive_scan_serial(in_first, in_last, expected_first, init); + auto orr = inclusive ? inclusive_scan(exec, in_first, in_last, out_first) + : exclusive_scan(exec, in_first, in_last, out_first, init); + EXPECT_TRUE(out_last == orr, + inclusive ? "inclusive_scan returned wrong iterator" : "exclusive_scan returned wrong iterator"); + + check_and_reset(expected_first, out_first, n, trash); + fill(out_first, out_last, trash); + } +}; + +template +void +test_with_plus(T init, T trash, Convert convert) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, convert); + Sequence expected(in); + Sequence out(n, [&](int32_t) { return trash; }); + + invoke_on_all_policies(test_scan_with_plus(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), in.size(), init, trash); + invoke_on_all_policies(test_scan_with_plus(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), + expected.end(), in.size(), init, trash); + } +} +struct test_scan_with_binary_op +{ + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator1 in_first, Iterator1 in_last, Iterator2 out_first, Iterator2 out_last, + Iterator3 expected_first, Iterator3 expected_last, Size n, T init, BinaryOp binary_op, T trash) + { + using namespace std; + + auto orr1 = inclusive ? inclusive_scan_serial(in_first, in_last, expected_first, binary_op, init) + : exclusive_scan_serial(in_first, in_last, expected_first, init, binary_op); + auto orr = inclusive ? inclusive_scan(exec, in_first, in_last, out_first, binary_op, init) + : exclusive_scan(exec, in_first, in_last, out_first, init, binary_op); + + EXPECT_TRUE(out_last == orr, "scan returned wrong iterator"); + check_and_reset(expected_first, out_first, n, trash); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator1 in_first, Iterator1 in_last, Iterator2 out_first, Iterator2 out_last, + Iterator3 expected_first, Iterator3 expected_last, Size n, T init, BinaryOp binary_op, T trash) + { + } +}; + +template +void +test_matrix(Out init, BinaryOp binary_op, Out trash) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [](size_t k) { return In(k, k + 1); }); + + Sequence out(n, [&](size_t) { return trash; }); + Sequence expected(n, [&](size_t) { return trash; }); + + invoke_on_all_policies(test_scan_with_binary_op(), in.begin(), in.end(), out.begin(), out.end(), + expected.begin(), expected.end(), in.size(), init, binary_op, trash); + invoke_on_all_policies(test_scan_with_binary_op(), in.cbegin(), in.cend(), out.begin(), out.end(), + expected.begin(), expected.end(), in.size(), init, binary_op, trash); + } +} + +int32_t +main() +{ + for (int32_t mode = 0; mode < 2; ++mode) + { + inclusive = mode != 0; +#if !__PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN + // Test with highly restricted type and associative but not commutative operation + test_matrix, Matrix2x2>(Matrix2x2(), multiply_matrix, + Matrix2x2(-666, 666)); +#endif + + // 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. + test_with_plus(inclusive ? 0.0 : -1.0, -666.0, + [](uint32_t k) { return float64_t((k % 991 + 1) ^ (k % 997 + 2)); }); + } + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/transform_reduce.cc b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/transform_reduce.cc new file mode 100644 index 0000000..41c6457 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/transform_reduce.cc @@ -0,0 +1,144 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- transform_reduce.pass.cpp -----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS + +#include "pstl/execution" +#include "pstl/numeric" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +// Equal for all types +template +static bool +Equal(T x, T y) +{ + return x == y; +} + +// Functor for xor-operation for modeling binary operations in inner_product +class XOR +{ + public: + template + T + operator()(const T& left, const T& right) const + { + return left ^ right; + } +}; + +// Model of User-defined class +class MyClass +{ + public: + int32_t my_field; + MyClass() { my_field = 0; } + MyClass(int32_t in) { my_field = in; } + MyClass(const MyClass& in) { my_field = in.my_field; } + + friend MyClass + operator+(const MyClass& x, const MyClass& y) + { + return MyClass(x.my_field + y.my_field); + } + friend MyClass + operator-(const MyClass& x) + { + return MyClass(-x.my_field); + } + friend MyClass operator*(const MyClass& x, const MyClass& y) { return MyClass(x.my_field * y.my_field); } + bool + operator==(const MyClass& in) + { + return my_field == in.my_field; + } +}; + +template +void +CheckResults(const T& expected, const T& in) +{ + EXPECT_TRUE(Equal(expected, in), "wrong result of transform_reduce"); +} + +// We need to check correctness only for "int" (for example) except cases +// if we have "floating-point type"-specialization +void +CheckResults(const float32_t& expected, const float32_t& in) +{ +} + +// Test for different types and operations with different iterators +struct test_transform_reduce +{ + template + void + operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, + T init, BinaryOperation1 opB1, BinaryOperation2 opB2, UnaryOp opU) + { + + auto expectedB = std::inner_product(first1, last1, first2, init, opB1, opB2); + auto expectedU = transform_reduce_serial(first1, last1, init, opB1, opU); + T resRA = std::transform_reduce(exec, first1, last1, first2, init, opB1, opB2); + CheckResults(expectedB, resRA); + resRA = std::transform_reduce(exec, first1, last1, init, opB1, opU); + CheckResults(expectedU, resRA); + } +}; + +template +void +test_by_type(T init, BinaryOperation1 opB1, BinaryOperation2 opB2, UnaryOp opU, Initializer initObj) +{ + + std::size_t maxSize = 100000; + Sequence in1(maxSize, initObj); + Sequence in2(maxSize, initObj); + + for (std::size_t n = 0; n < maxSize; n = n < 16 ? n + 1 : size_t(3.1415 * n)) + { + invoke_on_all_policies(test_transform_reduce(), in1.begin(), in1.begin() + n, in2.begin(), in2.begin() + n, + init, opB1, opB2, opU); + invoke_on_all_policies(test_transform_reduce(), in1.cbegin(), in1.cbegin() + n, in2.cbegin(), in2.cbegin() + n, + init, opB1, opB2, opU); + } +} + +int32_t +main() +{ + test_by_type(42, std::plus(), std::multiplies(), std::negate(), + [](std::size_t a) -> int32_t { return int32_t(rand() % 1000); }); + test_by_type(0, [](const int64_t& a, const int64_t& b) -> int64_t { return a | b; }, XOR(), + [](const int64_t& x) -> int64_t { return x * 2; }, + [](std::size_t a) -> int64_t { return int64_t(rand() % 1000); }); + test_by_type(1.0f, std::multiplies(), + [](const float32_t& a, const float32_t& b) -> float32_t { return a + b; }, + [](const float32_t& x) -> float32_t { return x + 2; }, + [](std::size_t a) -> float32_t { return rand() % 1000; }); + test_by_type(MyClass(), std::plus(), std::multiplies(), std::negate(), + [](std::size_t a) -> MyClass { return MyClass(rand() % 1000); }); + + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/transform_scan.cc b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/transform_scan.cc new file mode 100644 index 0000000..a3cedff --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/pstl/numeric_ops/transform_scan.cc @@ -0,0 +1,184 @@ +// -*- C++ -*- +// { dg-options "-std=gnu++17 -ltbb" } +// { dg-do run { target c++17 } } +// { dg-require-effective-target tbb-backend } + +//===-- transform_scan.pass.cpp -------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "pstl/pstl_test_config.h" + +#ifdef PSTL_STANDALONE_TESTS +#include "pstl/execution" +#include "pstl/numeric" +#else +#include +#include +#endif // PSTL_STANDALONE_TESTS + +#include "pstl/test_utils.h" + +using namespace TestUtils; + +// Most of the framework required for testing inclusive and exclusive transform-scans is identical, +// so the tests for both are in this file. Which is being tested is controlled by the global +// flag inclusive, which is set to each alternative by main(). +static bool inclusive; + +template +void +check_and_reset(Iterator expected_first, Iterator out_first, Size n, T trash) +{ + EXPECT_EQ_N(expected_first, out_first, n, + inclusive ? "wrong result from transform_inclusive_scan" + : "wrong result from transform_exclusive_scan"); + std::fill_n(out_first, n, trash); +} + +struct test_transform_scan +{ + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, + UnaryOp unary_op, T init, BinaryOp binary_op, T trash) + { + using namespace std; + + auto orr1 = inclusive ? transform_inclusive_scan(__pstl::execution::seq, first, last, expected_first, binary_op, + unary_op, init) + : transform_exclusive_scan(__pstl::execution::seq, first, last, expected_first, init, + binary_op, unary_op); + auto orr2 = inclusive ? transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op, init) + : transform_exclusive_scan(exec, first, last, out_first, init, binary_op, unary_op); + EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator"); + check_and_reset(expected_first, out_first, n, trash); + + // Checks inclusive scan if init is not provided + if (inclusive && n > 0) + { + orr1 = transform_inclusive_scan(__pstl::execution::seq, first, last, expected_first, binary_op, unary_op); + orr2 = transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op); + EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator"); + check_and_reset(expected_first, out_first, n, trash); + } + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, + OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, + UnaryOp unary_op, T init, BinaryOp binary_op, T trash) + { + } +}; + +const uint32_t encryption_mask = 0x314; + +template +std::pair +transform_inclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation unary_op, + T init, BinaryOperation binary_op) noexcept +{ + for (; first != last; ++first, ++result) + { + init = binary_op(init, unary_op(*first)); + *result = init; + } + return std::make_pair(result, init); +} + +template +std::pair +transform_exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation unary_op, + T init, BinaryOperation binary_op) noexcept +{ + for (; first != last; ++first, ++result) + { + *result = init; + init = binary_op(init, unary_op(*first)); + } + return std::make_pair(result, init); +} + +template +void +test(UnaryOp unary_op, Out init, BinaryOp binary_op, Out trash) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [](size_t k) { return In(k ^ encryption_mask); }); + + Out tmp = init; + Sequence expected(n, [&](size_t k) -> Out { + if (inclusive) + { + tmp = binary_op(tmp, unary_op(in[k])); + return tmp; + } + else + { + Out val = tmp; + tmp = binary_op(tmp, unary_op(in[k])); + return val; + } + }); + + Sequence out(n, [&](size_t) { return trash; }); + + auto result = + inclusive + ? transform_inclusive_scan_serial(in.cbegin(), in.cend(), out.fbegin(), unary_op, init, binary_op) + : transform_exclusive_scan_serial(in.cbegin(), in.cend(), out.fbegin(), unary_op, init, binary_op); + check_and_reset(expected.begin(), out.begin(), out.size(), trash); + + invoke_on_all_policies(test_transform_scan(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), in.size(), unary_op, init, binary_op, trash); + invoke_on_all_policies(test_transform_scan(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), + expected.end(), in.size(), unary_op, init, binary_op, trash); + } +} + +template +void +test_matrix(UnaryOp unary_op, Out init, BinaryOp binary_op, Out trash) +{ + for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) + { + Sequence in(n, [](size_t k) { return In(k, k + 1); }); + + Sequence out(n, [&](size_t) { return trash; }); + Sequence expected(n, [&](size_t) { return trash; }); + + invoke_on_all_policies(test_transform_scan(), in.begin(), in.end(), out.begin(), out.end(), expected.begin(), + expected.end(), in.size(), unary_op, init, binary_op, trash); + invoke_on_all_policies(test_transform_scan(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), + expected.end(), in.size(), unary_op, init, binary_op, trash); + } +} + +int32_t +main() +{ + for (int32_t mode = 0; mode < 2; ++mode) + { + inclusive = mode != 0; +#if !__PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN + test_matrix, Matrix2x2>([](const Matrix2x2 x) { return x; }, + Matrix2x2(), multiply_matrix, + Matrix2x2(-666, 666)); +#endif + test([](int32_t x) { return x++; }, -123, [](int32_t x, int32_t y) { return x + y; }, 666); + } + std::cout << done() << std::endl; + return 0; +} diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp index 02952a4..5a12ac0 100644 --- a/libstdc++-v3/testsuite/lib/libstdc++.exp +++ b/libstdc++-v3/testsuite/lib/libstdc++.exp @@ -1605,6 +1605,29 @@ proc check_effective_target_random_device { } { return 0 } +# Return 1 if tbb parallel backend is available +proc check_effective_target_tbb-backend { } { + global cxxflags + + # Set up and preprocess a C++ test program that depends + # on tbb + set src tbb_backend[pid].cc + + set f [open $src "w"] + puts $f "#include " + close $f + set lines [v3_target_compile $src /dev/null preprocess ""] + file delete $src + + if [string match "" $lines] { + # No error message, preprocessing succeeded. + verbose "check_v3_tbb-backend: `1'" 2 + return 1 + } + verbose "check_v3_tbb-backend: `0'" 2 + return 0 +} + set additional_prunes "" if { [info exists env(GCC_RUNTEST_PARALLELIZE_DIR)] \ diff --git a/libstdc++-v3/testsuite/util/pstl/pstl_test_config.h b/libstdc++-v3/testsuite/util/pstl/pstl_test_config.h new file mode 100644 index 0000000..10b8724 --- /dev/null +++ b/libstdc++-v3/testsuite/util/pstl/pstl_test_config.h @@ -0,0 +1,49 @@ +// -*- C++ -*- +//===-- pstl_test_config.h ------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __PSTL_TEST_config_H +#define __PSTL_TEST_config_H + +#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. +#endif + +#define __PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN \ + (__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER <= 1700 && !__APPLE__) +#define __PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN \ + (!_DEBUG && __INTEL_COMPILER && \ + (__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1))) +#define __PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN \ + (__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1) +#define __PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN \ + (__i386__ && !_DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && __APPLE__) +#define __PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN \ + (!_DEBUG && __INTEL_COMPILER >= 1800 && __INTEL_COMPILER < 1900 && _MSC_VER == 1910) +#define __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN \ + (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && _MSC_VER >= 1900) +#define __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN \ + (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1600 && __INTEL_COMPILER < 1700 && _MSC_VER == 1900) +#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) +#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_CLANG_TEST_BIG_OBJ_DEBUG_32_BROKEN \ + (__i386__ && PSTL_USE_DEBUG && __clang__ && __PSTL_CLANG_VERSION <= 90000) +#define __PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN \ + (!_DEBUG && __INTEL_COMPILER && \ + (__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 3))) +#define __PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN \ + (!_DEBUG && __INTEL_COMPILER == 1800 && __AVX__ && !__AVX2__ && !__AVX512__) +#define __PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN \ + (!PSTL_USE_DEBUG && (__linux__ || __APPLE__) && __INTEL_COMPILER == 1900) +#define __PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN \ + (__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) + +#endif /* __PSTL_TEST_config_H */ diff --git a/libstdc++-v3/testsuite/util/pstl/test_utils.h b/libstdc++-v3/testsuite/util/pstl/test_utils.h new file mode 100644 index 0000000..6532928 --- /dev/null +++ b/libstdc++-v3/testsuite/util/pstl/test_utils.h @@ -0,0 +1,1248 @@ +// -*- C++ -*- +//===-- utils.h -----------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// File contains common utilities that tests rely on + +// Do not #include , because if we do we will not detect accidental dependencies. +#include +#include +#include +#include +#include +#include +#include +#include + +#include "pstl_test_config.h" + +namespace TestUtils +{ + +typedef double float64_t; +typedef float float32_t; + +template +constexpr size_t +const_size(const T (&array)[N]) noexcept +{ + return N; +} + +template +class Sequence; + +// Handy macros for error reporting +#define EXPECT_TRUE(condition, message) TestUtils::expect(condition, __FILE__, __LINE__, message) +#define EXPECT_FALSE(condition, message) TestUtils::expect(condition, __FILE__, __LINE__, message) + +// Check that expected and actual are equal and have the same type. +#define EXPECT_EQ(expected, actual, message) TestUtils::expect_equal(expected, actual, __FILE__, __LINE__, message) + +// Check that sequences started with expected and actual and have had size n are equal and have the same type. +#define EXPECT_EQ_N(expected, actual, n, message) \ + TestUtils::expect_equal(expected, actual, n, __FILE__, __LINE__, message) + +// Issue error message from outstr, adding a newline. +// Real purpose of this routine is to have a place to hang a breakpoint. +static void +issue_error_message(std::stringstream& outstr) +{ + outstr << std::endl; + std::cerr << outstr.str(); +} + +template +void +expect(bool condition, const char* file, int32_t line, const char* message) +{ + // Templating this function is somewhat silly, but avoids the need to declare it static + // or have a separate translation unit. + if (condition != B) + { + std::stringstream outstr; + outstr << "error at " << file << ":" << line << " - " << message; + issue_error_message(outstr); + } +} + +// Do not change signature to const T&. +// Function must be able to detect const differences between expected and actual. +template +void +expect_equal(T& expected, T& actual, const char* file, int32_t line, const char* message) +{ + if (!(expected == actual)) + { + std::stringstream outstr; + outstr << "error at " << file << ":" << line << " - " << message << ", expected " << expected << " got " + << actual; + issue_error_message(outstr); + } +} + +template +void +expect_equal(Sequence& expected, Sequence& actual, const char* file, int32_t line, const char* message) +{ + size_t n = expected.size(); + size_t m = actual.size(); + if (n != m) + { + std::stringstream outstr; + outstr << "error at " << file << ":" << line << " - " << message << ", expected sequence of size " << n + << " got sequence of size " << m; + issue_error_message(outstr); + return; + } + size_t error_count = 0; + for (size_t k = 0; k < n && error_count < 10; ++k) + { + if (!(expected[k] == actual[k])) + { + std::stringstream outstr; + outstr << "error at " << file << ":" << line << " - " << message << ", at index " << k << " expected " + << expected[k] << " got " << actual[k]; + issue_error_message(outstr); + ++error_count; + } + } +} + +template +void +expect_equal(Iterator1 expected_first, Iterator2 actual_first, Size n, const char* file, int32_t line, + const char* message) +{ + size_t error_count = 0; + for (size_t k = 0; k < n && error_count < 10; ++k, ++expected_first, ++actual_first) + { + if (!(*expected_first == *actual_first)) + { + std::stringstream outstr; + outstr << "error at " << file << ":" << line << " - " << message << ", at index " << k; + issue_error_message(outstr); + ++error_count; + } + } +} + +// ForwardIterator is like type Iterator, but restricted to be a forward iterator. +// Only the forward iterator signatures that are necessary for tests are present. +// Post-increment in particular is deliberatly omitted since our templates should avoid using it +// because of efficiency considerations. +template +class ForwardIterator +{ + public: + typedef IteratorTag iterator_category; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::difference_type difference_type; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::reference reference; + + protected: + Iterator my_iterator; + typedef value_type element_type; + + public: + ForwardIterator() = default; + explicit ForwardIterator(Iterator i) : my_iterator(i) {} + reference operator*() const { return *my_iterator; } + Iterator operator->() const { return my_iterator; } + ForwardIterator + operator++() + { + ++my_iterator; + return *this; + } + ForwardIterator operator++(int32_t) + { + auto retval = *this; + my_iterator++; + return retval; + } + friend bool + operator==(const ForwardIterator& i, const ForwardIterator& j) + { + return i.my_iterator == j.my_iterator; + } + friend bool + operator!=(const ForwardIterator& i, const ForwardIterator& j) + { + return i.my_iterator != j.my_iterator; + } + + Iterator + iterator() const + { + return my_iterator; + } +}; + +template +class BidirectionalIterator : public ForwardIterator +{ + typedef ForwardIterator base_type; + + public: + BidirectionalIterator() = default; + explicit BidirectionalIterator(Iterator i) : base_type(i) {} + BidirectionalIterator(const base_type& i) : base_type(i.iterator()) {} + + BidirectionalIterator + operator++() + { + ++base_type::my_iterator; + return *this; + } + BidirectionalIterator + operator--() + { + --base_type::my_iterator; + return *this; + } + BidirectionalIterator operator++(int32_t) + { + auto retval = *this; + base_type::my_iterator++; + return retval; + } + BidirectionalIterator operator--(int32_t) + { + auto retval = *this; + base_type::my_iterator--; + return retval; + } +}; + +template +void +fill_data(Iterator first, Iterator last, F f) +{ + typedef typename std::iterator_traits::value_type T; + for (std::size_t i = 0; first != last; ++first, ++i) + { + *first = T(f(i)); + } +} + +// Sequence is a container of a sequence of T with lots of kinds of iterators. +// Prefixes on begin/end mean: +// c = "const" +// f = "forward" +// No prefix indicates non-const random-access iterator. +template +class Sequence +{ + std::vector m_storage; + + public: + typedef typename std::vector::iterator iterator; + typedef typename std::vector::const_iterator const_iterator; + typedef ForwardIterator forward_iterator; + typedef ForwardIterator const_forward_iterator; + + typedef BidirectionalIterator bidirectional_iterator; + typedef BidirectionalIterator const_bidirectional_iterator; + + typedef T value_type; + explicit Sequence(size_t size) : m_storage(size) {} + + // Construct sequence [f(0), f(1), ... f(size-1)] + // f can rely on its invocations being sequential from 0 to size-1. + template + Sequence(size_t size, Func f) + { + m_storage.reserve(size); + // Use push_back because T might not have a default constructor + for (size_t k = 0; k < size; ++k) + m_storage.push_back(T(f(k))); + } + Sequence(const std::initializer_list& data) : m_storage(data) {} + + const_iterator + begin() const + { + return m_storage.begin(); + } + const_iterator + end() const + { + return m_storage.end(); + } + iterator + begin() + { + return m_storage.begin(); + } + iterator + end() + { + return m_storage.end(); + } + const_iterator + cbegin() const + { + return m_storage.cbegin(); + } + const_iterator + cend() const + { + return m_storage.cend(); + } + forward_iterator + fbegin() + { + return forward_iterator(m_storage.begin()); + } + forward_iterator + fend() + { + return forward_iterator(m_storage.end()); + } + const_forward_iterator + cfbegin() const + { + return const_forward_iterator(m_storage.cbegin()); + } + const_forward_iterator + cfend() const + { + return const_forward_iterator(m_storage.cend()); + } + const_forward_iterator + fbegin() const + { + return const_forward_iterator(m_storage.cbegin()); + } + const_forward_iterator + fend() const + { + return const_forward_iterator(m_storage.cend()); + } + + const_bidirectional_iterator + cbibegin() const + { + return const_bidirectional_iterator(m_storage.cbegin()); + } + const_bidirectional_iterator + cbiend() const + { + return const_bidirectional_iterator(m_storage.cend()); + } + + bidirectional_iterator + bibegin() + { + return bidirectional_iterator(m_storage.begin()); + } + bidirectional_iterator + biend() + { + return bidirectional_iterator(m_storage.end()); + } + + std::size_t + size() const + { + return m_storage.size(); + } + const T* + data() const + { + return m_storage.data(); + } + typename std::vector::reference operator[](size_t j) { return m_storage[j]; } + const T& operator[](size_t j) const { return m_storage[j]; } + + // Fill with given value + void + fill(const T& value) + { + for (size_t i = 0; i < m_storage.size(); i++) + m_storage[i] = value; + } + + void + print() const; + + template + void + fill(Func f) + { + fill_data(m_storage.begin(), m_storage.end(), f); + } +}; + +template +void +Sequence::print() const +{ + std::cout << "size = " << size() << ": { "; + std::copy(begin(), end(), std::ostream_iterator(std::cout, " ")); + std::cout << " } " << std::endl; +} + +// Predicates for algorithms +template +struct is_equal_to +{ + is_equal_to(const DataType& expected) : m_expected(expected) {} + bool + operator()(const DataType& actual) const + { + return actual == m_expected; + } + + private: + DataType m_expected; +}; + +// Low-quality hash function, returns value between 0 and (1<= 8 * sizeof(size_t) ? ~size_t(0) : (size_t(1) << bits) - 1; + return (424157 * i ^ 0x24aFa) & mask; +} + +// Stateful unary op +template +class Complement +{ + int32_t val; + + public: + Complement(T v) : val(v) {} + U + operator()(const T& x) const + { + return U(val - x); + } +}; + +// Tag used to prevent accidental use of converting constructor, even if use is explicit. +struct OddTag +{ +}; + +class Sum; + +// Type with limited set of operations. Not default-constructible. +// Only available operator is "==". +// Typically used as value type in tests. +class Number +{ + int32_t value; + friend class Add; + friend class Sum; + friend class IsMultiple; + friend class Congruent; + friend Sum + operator+(const Sum& x, const Sum& y); + + public: + Number(int32_t val, OddTag) : value(val) {} + friend bool + operator==(const Number& x, const Number& y) + { + return x.value == y.value; + } + friend std::ostream& + operator<<(std::ostream& o, const Number& d) + { + return o << d.value; + } +}; + +// Stateful predicate for Number. Not default-constructible. +class IsMultiple +{ + long modulus; + + public: + // True if x is multiple of modulus + bool + operator()(Number x) const + { + return x.value % modulus == 0; + } + IsMultiple(long modulus_, OddTag) : modulus(modulus_) {} +}; + +// Stateful equivalence-class predicate for Number. Not default-constructible. +class Congruent +{ + long modulus; + + public: + // True if x and y have same remainder for the given modulus. + // Note: this is not quite the same as "equivalent modulo modulus" when x and y have different + // sign, but nonetheless AreCongruent is still an equivalence relationship, which is all + // we need for testing. + bool + operator()(Number x, Number y) const + { + return x.value % modulus == y.value % modulus; + } + Congruent(long modulus_, OddTag) : modulus(modulus_) {} +}; + +// Stateful reduction operation for Number +class Add +{ + long bias; + + public: + explicit Add(OddTag) : bias(1) {} + Number + operator()(Number x, const Number& y) + { + return Number(x.value + y.value + (bias - 1), OddTag()); + } +}; + +// Class similar to Number, but has default constructor and +. +class Sum : public Number +{ + public: + Sum() : Number(0, OddTag()) {} + Sum(long x, OddTag) : Number(x, OddTag()) {} + friend Sum + operator+(const Sum& x, const Sum& y) + { + return Sum(x.value + y.value, OddTag()); + } +}; + +// Type with limited set of operations, which includes an associative but not commutative operation. +// Not default-constructible. +// Typically used as value type in tests involving "GENERALIZED_NONCOMMUTATIVE_SUM". +class MonoidElement +{ + size_t a, b; + + public: + MonoidElement(size_t a_, size_t b_, OddTag) : a(a_), b(b_) {} + friend bool + operator==(const MonoidElement& x, const MonoidElement& y) + { + return x.a == y.a && x.b == y.b; + } + friend std::ostream& + operator<<(std::ostream& o, const MonoidElement& x) + { + return o << "[" << x.a << ".." << x.b << ")"; + } + friend class AssocOp; +}; + +// Stateful associative op for MonoidElement +// It's not really a monoid since the operation is not allowed for any two elements. +// But it's good enough for testing. +class AssocOp +{ + unsigned c; + + public: + explicit AssocOp(OddTag) : c(5) {} + MonoidElement + operator()(const MonoidElement& x, const MonoidElement& y) + { + unsigned d = 5; + EXPECT_EQ(d, c, "state lost"); + EXPECT_EQ(x.b, y.a, "commuted?"); + + return MonoidElement(x.a, y.b, OddTag()); + } +}; + +// Multiplication of matrix is an associative but not commutative operation +// Typically used as value type in tests involving "GENERALIZED_NONCOMMUTATIVE_SUM". +template +struct Matrix2x2 +{ + T a[2][2]; + Matrix2x2() : a{{1, 0}, {0, 1}} {} + Matrix2x2(T x, T y) : a{{0, x}, {x, y}} {} +#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& + 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]; + return *this; + } +#endif +}; + +template +bool +operator==(const Matrix2x2& left, const Matrix2x2& right) +{ + return left.a[0][0] == right.a[0][0] && left.a[0][1] == right.a[0][1] && left.a[1][0] == right.a[1][0] && + left.a[1][1] == right.a[1][1]; +} + +template +Matrix2x2 +multiply_matrix(const Matrix2x2& left, const Matrix2x2& right) +{ + Matrix2x2 result; + for (int32_t i = 0; i < 2; ++i) + { + for (int32_t j = 0; j < 2; ++j) + { + result.a[i][j] = left.a[i][0] * right.a[0][j] + left.a[i][1] * right.a[1][j]; + } + } + return result; +} + +// Check that Intel(R) Threading Building Blocks header files are not used when parallel policies are off +#if !__PSTL_USE_PAR_POLICIES +#if defined(TBB_INTERFACE_VERSION) +#error The parallel backend is used while it should not (__PSTL_USE_PAR_POLICIES==0) +#endif +#endif + +//============================================================================ +// Adapters for creating different 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. +// We have adapters for iterators with different tags (forward_iterator_tag, bidirectional_iterator_tag), reverse iterators. +// The input iterator should be const or non-const, non-reverse random access iterator. +// Iterator creates in "MakeIterator": +// firstly, iterator is "packed" by "IteratorTypeAdapter" (creating forward or bidirectional iterator) +// then iterator is "packed" by "ReverseAdapter" (if it's possible) +// So, from input iterator we may create, for example, reverse bidirectional iterator. +// "Main" functor for testing iterators is named "invoke_on_all_iterator_types". + +// Base adapter +template +struct BaseAdapter +{ + typedef Iterator iterator_type; + iterator_type + operator()(Iterator it) + { + return it; + } +}; + +// Check if the iterator is reverse iterator +// Note: it works only for iterators that created by std::reverse_iterator +template +struct isReverse : std::false_type +{ +}; + +template +struct isReverse> : std::true_type +{ +}; + +// Reverse adapter +template +struct ReverseAdapter +{ + typedef std::reverse_iterator iterator_type; + iterator_type + operator()(Iterator it) + { +#if __PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT + return std::make_reverse_iterator(it); +#else + return iterator_type(it); +#endif + } +}; + +// Non-reverse adapter +template +struct ReverseAdapter : BaseAdapter +{ +}; + +// Iterator adapter by type (by default std::random_access_iterator_tag) +template +struct IteratorTypeAdapter : BaseAdapter +{ +}; + +// Iterator adapter for forward iterator +template +struct IteratorTypeAdapter +{ + typedef ForwardIterator iterator_type; + iterator_type + operator()(Iterator it) + { + return iterator_type(it); + } +}; + +// Iterator adapter for bidirectional iterator +template +struct IteratorTypeAdapter +{ + typedef BidirectionalIterator iterator_type; + iterator_type + operator()(Iterator it) + { + return iterator_type(it); + } +}; + +//For creating iterator with new type +template +struct MakeIterator +{ + typedef IteratorTypeAdapter IterByType; + typedef ReverseAdapter ReverseIter; + + typename ReverseIter::iterator_type + operator()(InputIterator it) + { + return ReverseIter()(IterByType()(it)); + } +}; + +// Useful constant variables +constexpr std::size_t GuardSize = 5; +constexpr std::ptrdiff_t sizeLimit = 1000; + +template // local iterator_traits for non-iterators +struct iterator_traits_ +{ +}; + +template // For iterators +struct iterator_traits_::value, void>::type> +{ + typedef typename Iter::iterator_category iterator_category; +}; + +template // For pointers +struct iterator_traits_ +{ + typedef std::random_access_iterator_tag iterator_category; +}; + +// is iterator Iter has tag Tag +template +using is_same_iterator_category = std::is_same::iterator_category, Tag>; + +// if we run with reverse or const iterators we shouldn't test the large range +template +struct invoke_if_ +{ + template + void + operator()(bool is_allow, Op op, Rest&&... rest) + { + if (is_allow) + op(std::forward(rest)...); + } +}; +template <> +struct invoke_if_ +{ + template + void + operator()(bool is_allow, Op op, Rest&&... rest) + { + op(std::forward(rest)...); + } +}; + +// Base non_const_wrapper struct. It is used to distinguish non_const testcases +// from a regular one. For non_const testcases only compilation is checked. +struct non_const_wrapper +{ +}; + +// Generic wrapper to specify iterator type to execute callable Op on. +// The condition can be either positive(Op is executed only with IteratorTag) +// or negative(Op is executed with every type of iterators except IteratorTag) +template +struct non_const_wrapper_tagged : non_const_wrapper +{ + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator iter) + { + Op()(exec, iter); + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, InputIterator input_iter, OutputIterator out_iter) + { + Op()(exec, input_iter, out_iter); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Iterator iter) + { + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, InputIterator input_iter, OutputIterator out_iter) + { + } +}; + +// These run_for_* structures specify with which types of iterators callable object Op +// should be executed. +template +struct run_for_rnd : non_const_wrapper_tagged +{ +}; + +template +struct run_for_rnd_bi : non_const_wrapper_tagged +{ +}; + +template +struct run_for_rnd_fw : non_const_wrapper_tagged +{ +}; + +// Invoker for different types of iterators. +template +struct iterator_invoker +{ + template + using make_iterator = MakeIterator; + template + using IsConst = typename std::is_const< + typename std::remove_pointer::pointer>::type>::type; + template + using invoke_if = invoke_if_>; + + // A single iterator version which is used for non_const testcases + template + typename std::enable_if::value && + std::is_base_of::value, + void>::type + operator()(Policy&& exec, Op op, Iterator iter) + { + op(std::forward(exec), make_iterator()(iter)); + } + + // A version with 2 iterators which is used for non_const testcases + template + typename std::enable_if::value && + std::is_base_of::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator input_iter, OutputIterator out_iter) + { + op(std::forward(exec), make_iterator()(input_iter), + make_iterator()(out_iter)); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Op op, Iterator begin, Size n, Rest&&... rest) + { + invoke_if()(n <= sizeLimit, op, exec, make_iterator()(begin), n, + std::forward(rest)...); + } + + template + typename std::enable_if::value && + !std::is_base_of::value, + void>::type + operator()(Policy&& exec, Op op, Iterator inputBegin, Iterator inputEnd, Rest&&... rest) + { + invoke_if()(std::distance(inputBegin, inputEnd) <= sizeLimit, op, exec, + make_iterator()(inputBegin), make_iterator()(inputEnd), + std::forward(rest)...); + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, + Rest&&... rest) + { + invoke_if()(std::distance(inputBegin, inputEnd) <= sizeLimit, op, exec, + make_iterator()(inputBegin), make_iterator()(inputEnd), + make_iterator()(outputBegin), std::forward(rest)...); + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, + OutputIterator outputEnd, Rest&&... rest) + { + invoke_if()(std::distance(inputBegin, inputEnd) <= sizeLimit, op, exec, + make_iterator()(inputBegin), make_iterator()(inputEnd), + make_iterator()(outputBegin), + make_iterator()(outputEnd), std::forward(rest)...); + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator1 inputBegin1, InputIterator1 inputEnd1, InputIterator2 inputBegin2, + InputIterator2 inputEnd2, OutputIterator outputBegin, OutputIterator outputEnd, Rest&&... rest) + { + invoke_if()( + std::distance(inputBegin1, inputEnd1) <= sizeLimit, op, exec, make_iterator()(inputBegin1), + make_iterator()(inputEnd1), make_iterator()(inputBegin2), + make_iterator()(inputEnd2), make_iterator()(outputBegin), + make_iterator()(outputEnd), std::forward(rest)...); + } +}; + +// Invoker for reverse iterators only +// Note: if we run with reverse iterators we shouldn't test the large range +template +struct iterator_invoker +{ + + template + using make_iterator = MakeIterator; + + // A single iterator version which is used for non_const testcases + template + typename std::enable_if::value && + std::is_base_of::value, + void>::type + operator()(Policy&& exec, Op op, Iterator iter) + { + op(std::forward(exec), make_iterator()(iter)); + } + + // A version with 2 iterators which is used for non_const testcases + template + typename std::enable_if::value && + std::is_base_of::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator input_iter, OutputIterator out_iter) + { + op(std::forward(exec), make_iterator()(input_iter), + make_iterator()(out_iter)); + } + + template + typename std::enable_if::value, void>::type + operator()(Policy&& exec, Op op, Iterator begin, Size n, Rest&&... rest) + { + if (n <= sizeLimit) + op(exec, make_iterator()(begin + n), n, std::forward(rest)...); + } + + template + typename std::enable_if::value && + !std::is_base_of::value, + void>::type + operator()(Policy&& exec, Op op, Iterator inputBegin, Iterator inputEnd, Rest&&... rest) + { + if (std::distance(inputBegin, inputEnd) <= sizeLimit) + op(exec, make_iterator()(inputEnd), make_iterator()(inputBegin), + std::forward(rest)...); + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, + Rest&&... rest) + { + if (std::distance(inputBegin, inputEnd) <= sizeLimit) + op(exec, make_iterator()(inputEnd), make_iterator()(inputBegin), + make_iterator()(outputBegin + (inputEnd - inputBegin)), std::forward(rest)...); + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin, + OutputIterator outputEnd, Rest&&... rest) + { + if (std::distance(inputBegin, inputEnd) <= sizeLimit) + op(exec, make_iterator()(inputEnd), make_iterator()(inputBegin), + make_iterator()(outputEnd), make_iterator()(outputBegin), + std::forward(rest)...); + } + + template + typename std::enable_if::value, + void>::type + operator()(Policy&& exec, Op op, InputIterator1 inputBegin1, InputIterator1 inputEnd1, InputIterator2 inputBegin2, + InputIterator2 inputEnd2, OutputIterator outputBegin, OutputIterator outputEnd, Rest&&... rest) + { + if (std::distance(inputBegin1, inputEnd1) <= sizeLimit) + op(exec, make_iterator()(inputEnd1), make_iterator()(inputBegin1), + make_iterator()(inputEnd2), make_iterator()(inputBegin2), + make_iterator()(outputEnd), make_iterator()(outputBegin), + std::forward(rest)...); + } +}; + +// We can't create reverse iterator from forward iterator +template <> +struct iterator_invoker +{ + template + void + operator()(Rest&&... rest) + { + } +}; + +template +struct reverse_invoker +{ + template + void + operator()(Rest&&... rest) + { + // Random-access iterator + iterator_invoker()(std::forward(rest)...); + + // Forward iterator + iterator_invoker()(std::forward(rest)...); + + // Bidirectional iterator + iterator_invoker()(std::forward(rest)...); + } +}; + +struct invoke_on_all_iterator_types +{ + template + void + operator()(Rest&&... rest) + { + reverse_invoker()(std::forward(rest)...); + reverse_invoker()(std::forward(rest)...); + } +}; +//============================================================================ + +// Invoke op(policy,rest...) for each possible policy. +template +void +invoke_on_all_policies(Op op, T&&... rest) +{ + using namespace __pstl::execution; + + // Try static execution policies + invoke_on_all_iterator_types()(seq, op, std::forward(rest)...); + invoke_on_all_iterator_types()(unseq, op, std::forward(rest)...); +#if __PSTL_USE_PAR_POLICIES + invoke_on_all_iterator_types()(par, op, std::forward(rest)...); + invoke_on_all_iterator_types()(par_unseq, op, std::forward(rest)...); +#endif +} + +template +struct NonConstAdapter +{ + F my_f; + NonConstAdapter(const F& f) : my_f(f) {} + + template + auto + operator()(Types&&... args) -> decltype(std::declval(). + operator()(std::forward(args)...)) + { + return my_f(std::forward(args)...); + } +}; + +template +NonConstAdapter +non_const(const F& f) +{ + return NonConstAdapter(f); +} + +// Wrapper for types. It's need for counting of constructing and destructing objects +template +class Wrapper +{ + public: + Wrapper() + { + my_field = std::shared_ptr(new T()); + ++my_count; + } + Wrapper(const T& input) + { + my_field = std::shared_ptr(new T(input)); + ++my_count; + } + Wrapper(const Wrapper& input) + { + my_field = input.my_field; + ++my_count; + } + Wrapper(Wrapper&& input) + { + my_field = input.my_field; + input.my_field = nullptr; + ++move_count; + } + Wrapper& + operator=(const Wrapper& input) + { + my_field = input.my_field; + return *this; + } + Wrapper& + operator=(Wrapper&& input) + { + my_field = input.my_field; + input.my_field = nullptr; + ++move_count; + return *this; + } + bool + operator==(const Wrapper& input) const + { + return my_field == input.my_field; + } + bool + operator<(const Wrapper& input) const + { + return *my_field < *input.my_field; + } + bool + operator>(const Wrapper& input) const + { + return *my_field > *input.my_field; + } + friend std::ostream& + operator<<(std::ostream& stream, const Wrapper& input) + { + return stream << *(input.my_field); + } + ~Wrapper() + { + --my_count; + if (move_count > 0) + { + --move_count; + } + } + T* + get_my_field() const + { + return my_field.get(); + }; + static size_t + Count() + { + return my_count; + } + static size_t + MoveCount() + { + return move_count; + } + static void + SetCount(const size_t& n) + { + my_count = n; + } + static void + SetMoveCount(const size_t& n) + { + move_count = n; + } + + private: + static std::atomic my_count; + static std::atomic move_count; + std::shared_ptr my_field; +}; + +template +std::atomic Wrapper::my_count = {0}; + +template +std::atomic Wrapper::move_count = {0}; + +template +T +transform_reduce_serial(InputIterator first, InputIterator last, T init, BinaryOperation binary_op, + UnaryOperation unary_op) noexcept +{ + for (; first != last; ++first) + { + init = binary_op(init, unary_op(*first)); + } + return init; +} + +static const char* +done() +{ +#if __PSTL_TEST_SUCCESSFUL_KEYWORD + return "done"; +#else + return "passed"; +#endif +} + +// test_algo_basic_* functions are used to execute +// f on a very basic sequence of elements of type T. + +// Should be used with unary predicate +template +static void +test_algo_basic_single(F&& f) +{ + size_t N = 10; + Sequence in(N, [](size_t v) -> T { return T(v); }); + + invoke_on_all_policies(f, in.begin()); +} + +// Should be used with binary predicate +template +static void +test_algo_basic_double(F&& f) +{ + size_t N = 10; + Sequence in(N, [](size_t v) -> T { return T(v); }); + Sequence out(N, [](size_t v) -> T { return T(v); }); + + invoke_on_all_policies(f, in.begin(), out.begin()); +} + +template +static void +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 + __pstl::__internal::invoke_if_not(__pstl::__internal::allow_unsequenced(), f); +#else + f(); +#endif +} + +} /* namespace TestUtils */