This is an archive of the discontinued LLVM Phabricator instance.

Differential D58852

Changes from integrating PSTL with libstdc++
AbandonedPublic

Authored by rodgert on Mar 1 2019, 4:03 PM.

Details

Reviewers
ldionne
Summary

This is a combination of the following:

  • Remove unused include - pstl_config.h is not required
  • Introduce forward declarations - necessary to break circular includes when introduced to the standard library's, e.g. - <algorithm> <numeric> <memory>
  • Deprecate non-cmake build and test suite Makefile based build is not a LLVM standard Original test suite does not conform to libc++'s standards Scripts for integrating tests into libstdc++ assume libc++'s test layout

Diff Detail

Event Timeline

rodgert created this revision.Mar 1 2019, 4:03 PM
Herald added a reviewer: ldionne. · View Herald TranscriptMar 1 2019, 4:03 PM
Herald added subscribers: libcxx-commits, jdoerfert, mstorsjo and 3 others. · View Herald Transcript
Harbormaster completed remote builds in B28691: Diff 188992.Mar 1 2019, 4:03 PM
ldionne added a comment.Mar 4 2019, 7:33 AM

Do you think you could split this change into smaller changes? Perhaps one that removes the support for the Makefile tests, one that introduces forward declarations, and one that renames the test suite files?

rodgert added a comment.Mar 4 2019, 7:56 AM
In D58852#1416945, @ldionne wrote:

Do you think you could split this change into smaller changes? Perhaps one that removes the support for the Makefile tests, one that introduces forward declarations, and one that renames the test suite files?

I tried to git rebase --interactive my way into something along those lines, but the series of commits which were squashed into this one made the process fairly messy. I can certainly split this one into two changes though, one that introduces the forward declarations (it also removes some unused includes), and one that simultaneously deprecates the support for the Makefile tests and reintroduces them with the new structure. Would that work for you?

ldionne added a comment.Mar 4 2019, 8:09 AM
In D58852#1416971, @rodgert wrote:

I tried to git rebase --interactive my way into something along those lines, but the series of commits which were squashed into this one made the process fairly messy. I can certainly split this one into two changes though, one that introduces the forward declarations (it also removes some unused includes), and one that simultaneously deprecates the support for the Makefile tests and reintroduces them with the new structure. Would that work for you?

Yes.

MikeDvorskiy added a subscriber: MikeDvorskiy.Mar 5 2019, 4:26 AM
MikeDvorskiy added inline comments.
include/pstl/internal/algorithm_fwd.h
2

Thomas, what's a reason to rename the files with forward declarations? (glue_algorithm_defs.h, glue_numeric_defs.h, glue_memory_defs.h to algorithm_fwd.h, numeric_fwd.h, memory_fwd.h)

MikeDvorskiy added a comment.Mar 5 2019, 5:26 AM

pstl_config.h is not required

Thomas, could you please clarify it?

The fact is the file contains significant macros, which are used in simd bricks, and the other useful macros.

rodgert marked an inline comment as done.Mar 5 2019, 6:43 AM
In D58852#1418265, @MikeDvorskiy wrote:

pstl_config.h is not required

Thomas, could you please clarify it?

The fact is the file contains significant macros, which are used in simd bricks, and the other useful macros.

The fact is, it is already included by another file here, so this include is redundant. Removing the include here is the correct thing to do, also because this config file's contents become part of the standard library's configuration when included in libstdc++ (and almost certainly the same with libc++).

include/pstl/internal/algorithm_fwd.h
2

Look carefully at the files, they are *NOT* the same thing.

rodgert abandoned this revision.Mar 5 2019, 1:52 PM

Will resubmit (as discussed) as a couple of smaller patches

Revision Contents

PathSize
5 lines
build/
jni/
include/
pstl/
internal/
1219 lines
4 lines
4 lines
2 lines
131 lines
2 lines
test/
40 lines
std/
3 lines
algorithms/
4 lines
alg.merge/
10 lines
alg.modifying.operations/
26 lines
alg.copy/
7 lines
alg.partitions/
11 lines
alg.reverse/
10 lines
alg.nonmodifying/
22 lines
alg.sorting/
17 lines
alg.heap.operations/
9 lines
alg.lex.comparison/
9 lines
alg.min.max/
9 lines
alg.set.operations/
10 lines
numerics/
1 line
numeric.ops/
13 lines
utilities/
1 line
memory/
1 line
specialized.algorithms/
11 lines
std/
algorithms/
alg.merge/
inplace_merge.pass.cpp
test_inplace_merge.cpp
17 lines
merge.pass.cpp
test_merge.cpp
15 lines
alg.modifying.operations/
alg.copy/
copy_if.pass.cpp
test_copy_if.cpp
19 lines
alg.partitions/
is_partitioned.pass.cpp
test_is_partitioned.cpp
19 lines
partition.pass.cpp
test_partition.cpp
25 lines
partition_copy.pass.cpp
test_partition_copy.cpp
22 lines
alg.reverse/
reverse.pass.cpp
test_reverse.cpp
19 lines
reverse_copy.pass.cpp
test_reverse_copy.cpp
19 lines
copy_move.pass.cpp
test_copy_move.cpp
24 lines
fill.pass.cpp
test_fill.cpp
13 lines
generate.pass.cpp
test_generate.cpp
14 lines
remove.pass.cpp
test_remove.cpp
15 lines
remove_copy.pass.cpp
test_remove_copy.cpp
16 lines
replace.pass.cpp
test_replace.cpp
14 lines
replace_copy.pass.cpp
test_replace_copy.cpp
16 lines
rotate.pass.cpp
test_rotate.cpp
23 lines
rotate_copy.pass.cpp
test_rotate_copy.cpp
19 lines
swap_ranges.pass.cpp
test_swap_ranges.cpp
15 lines
transform_binary.pass.cpp
test_transform_binary.cpp
15 lines
transform_unary.pass.cpp
test_transform_unary.cpp
15 lines
unique.pass.cpp
test_unique.cpp
22 lines
unique_copy_equal.pass.cpp
test_unique_copy_equal.cpp
22 lines
alg.nonmodifying/
adjacent_find.pass.cpp
test_adjacent_find.cpp
14 lines
all_of.pass.cpp
test_all_of.cpp
14 lines
any_of.pass.cpp
test_any_of.cpp
14 lines
count.pass.cpp
test_count.cpp
12 lines
equal.pass.cpp
test_equal.cpp
14 lines
find.pass.cpp
test_find.cpp
23 lines
find_end.pass.cpp
test_find_end.cpp
12 lines
find_first_of.pass.cpp
test_find_first_of.cpp
14 lines
find_if.pass.cpp
test_find_if.cpp
15 lines
for_each.pass.cpp
test_for_each.cpp
22 lines
mismatch.pass.cpp
test_mismatch.cpp
18 lines
none_of.pass.cpp
test_none_of.cpp
14 lines
nth_element.pass.cpp
test_nth_element.cpp
19 lines
search_n.pass.cpp
test_search_n.cpp
15 lines
alg.sorting/
alg.heap.operations/
is_heap.pass.cpp
test_is_heap.cpp
19 lines
alg.lex.comparison/
lexicographical_compare.pass.cpp
test_lexicographical_compare.cpp
17 lines
alg.min.max/
minmax_element.pass.cpp
test_minmax_element.cpp
42 lines
alg.set.operations/
includes.pass.cpp
test_includes.cpp
20 lines
set.pass.cpp
test_set.cpp
18 lines
is_sorted.pass.cpp
test_is_sorted.cpp
12 lines
partial_sort.pass.cpp
test_partial_sort.cpp
17 lines
partial_sort_copy.pass.cpp
test_partial_sort_copy.cpp
24 lines
sort.pass.cpp
test_sort.cpp
13 lines
numerics/
numeric.ops/
adjacent_difference.pass.cpp
test_adjacent_difference.cpp
18 lines
reduce.pass.cpp
test_reduce.cpp
18 lines
scan.pass.cpp
test_scan.cpp
19 lines
transform_reduce.pass.cpp
test_transform_reduce.cpp
14 lines
transform_scan.pass.cpp
test_transform_scan.cpp
25 lines
utilities/
memory/
specialized.algorithms/
uninitialized_construct.pass.cpp
test_uninitialized_construct.cpp
19 lines
uninitialized_copy_move.pass.cpp
test_uninitialized_copy_move.cpp
15 lines
uninitialized_fill_destroy.pass.cpp
test_uninitialized_fill_destroy.cpp
16 lines
support/
20 lines
7 lines

Diff 188992

CMakeLists.txt

Show All 27 Lines if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../${TBB_DIR_NAME}/cmake")
get_filename_component(TBB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${TBB_DIR_NAME}/cmake" ABSOLUTE) get_filename_component(TBB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${TBB_DIR_NAME}/cmake" ABSOLUTE)
endif() endif()
endif() endif()
add_library(ParallelSTL INTERFACE) add_library(ParallelSTL INTERFACE)
add_library(pstl::ParallelSTL ALIAS ParallelSTL) add_library(pstl::ParallelSTL ALIAS ParallelSTL)
if (PARALLELSTL_USE_PARALLEL_POLICIES) if (PARALLELSTL_USE_PARALLEL_POLICIES)
message(STATUS "Using Parallel Policies")
if (PARALLELSTL_BACKEND STREQUAL "tbb") if (PARALLELSTL_BACKEND STREQUAL "tbb")
find_package(TBB 2018 REQUIRED tbb OPTIONAL_COMPONENTS tbbmalloc) find_package(TBB 2018 REQUIRED tbb OPTIONAL_COMPONENTS tbbmalloc)
message(STATUS "Parallel STL uses TBB ${TBB_VERSION} (interface version: ${TBB_INTERFACE_VERSION})") message(STATUS "Parallel STL uses TBB ${TBB_VERSION} (interface version: ${TBB_INTERFACE_VERSION})")
target_link_libraries(ParallelSTL INTERFACE TBB::tbb) target_link_libraries(ParallelSTL INTERFACE TBB::tbb)
else() else()
message(STATUS "Using Parallel Policies, but not tbb")
if (TARGET ${PARALLELSTL_BACKEND}) if (TARGET ${PARALLELSTL_BACKEND})
target_link_libraries(ParallelSTL INTERFACE ${PARALLELSTL_BACKEND}) target_link_libraries(ParallelSTL INTERFACE ${PARALLELSTL_BACKEND})
else() else()
find_package(${PARALLELSTL_BACKEND} REQUIRED) find_package(${PARALLELSTL_BACKEND} REQUIRED)
target_link_libraries(ParallelSTL INTERFACE ${${PARALLELSTL_BACKEND}_IMPORTED_TARGETS}) target_link_libraries(ParallelSTL INTERFACE ${${PARALLELSTL_BACKEND}_IMPORTED_TARGETS})
endif() endif()
endif() endif()
else() else()
Show All 15 Linesconfigure_file(
${CMAKE_CURRENT_BINARY_DIR}/ParallelSTLConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/ParallelSTLConfig.cmake
@ONLY) @ONLY)
export(TARGETS ParallelSTL NAMESPACE pstl:: FILE ParallelSTLTargets.cmake) export(TARGETS ParallelSTL NAMESPACE pstl:: FILE ParallelSTLTargets.cmake)
export(PACKAGE ParallelSTL) export(PACKAGE ParallelSTL)
enable_testing() enable_testing()
add_subdirectory(test) add_subdirectory(test)

build/Makefile

  • This file was deleted.
#===-- Makefile ----------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
#------------------------------------------------------------------------------
# Define rules for making the Parallel STL library.
#------------------------------------------------------------------------------
proj_root ?= $(CURDIR)/..
include $(proj_root)/build/Makefile.common
CPLUS := $(compiler) $(COMPILER_NOLOGO_KEY) $(USE_SHARED_CPPRUNTIME_KEY)
.SECONDARY:
.PHONY: clean clean_all clean_pstl bench
VPATH = $(proj_root)/test
CPLUS_FLAGS += -I$(proj_root)
PSTL_MAKEFILE = $(proj_root)/build/Makefile.pstl
BENCH_MAKEFILE = $(proj_root)/build/Makefile.bench
test_hdr = $(wildcard $(proj_root)/test/*.h)
test_src = $(wildcard $(proj_root)/test/test_*.cpp)
test_bin = $(notdir $(test_src:.cpp=.exe))
all: $(test_bin)
test_%.offload.exe: test_%.offload$(OBJ_SFX) exception_list.offload$(OBJ_SFX)
$(CPLUS) $(CPLUS_FLAGS) $^ $(FKEY)o$@ $(LDFLAGS)
$(PSTL_LIB_NAME):
$(MAKE) -f $(PSTL_MAKEFILE) backend=$(backend) cfg=$(cfg)
test_%.exe: test_%$(OBJ_SFX) $(PSTL_LIB_NAME)
$(LD) $< $(LD_OUT_KEY)$@ $(LDFLAGS) $(DYN_LDFLAGS) $(PSTL_LIB_LINK)
test_%: test_%.exe
$(run_cmd) $(RUN_CMD)test_$*.exe
test_%$(OBJ_SFX): test_%.cpp $(test_hdr) $(proj_root)/build/Makefile
$(CPLUS) $(CPLUS_FLAGS) -c $< $(FKEY)o$@
# This definition intentionally consists of two blank lines
define eol
endef
test: $(test_bin)
$(foreach test, $(test_bin), $(run_cmd) $(RUN_CMD)$(test) $(args) $(eol))
%.s: %.cpp $(proj_root)/build/Makefile
$(CPLUS) $(CPLUS_FLAGS) -S $< $(FKEY)o$@
%.E: %.cpp
$(CPLUS) $(CPLUS_FLAGS) -E $< >$@
TEMPLATE_FILES=$(wildcard $(proj_root)/bench/*.*tmpl)
BENCH_COMMON_FILES=$(wildcard $(proj_root)/bench/*.h) $(wildcard $(proj_root)/bench/*.cpp)
$(BENCH_MAKEFILE): $(proj_root)/bench/algorithm.json $(proj_root)/bench/gen.py $(TEMPLATE_FILES)
$(PYTHON) $(proj_root)/bench/gen.py $(proj_root)/bench/algorithm.json
bench : $(BENCH_MAKEFILE) $(BENCH_COMMON_FILES) $(PSTL_LIB_NAME)
@echo TEMPLATE_FILES=$(TEMPLATE_FILES)
@echo proj_root=$(proj_root)
ls -la $(proj_root)/bench/gen.py
$(MAKE) -f $(BENCH_MAKEFILE)
clean_bench:
$(DEL_CMD) $(BENCH_MAKEFILE)
$(DEL_CMD) batch.py
$(DEL_CMD) $(proj_root)/build/bench/*.*
clean:
$(DEL_CMD) *$(OBJ_SFX) *.exe *.E *.s *.asm *.d *.pdb *.pdb *.suo *.ilk
clean_pstl:
$(MAKE) -f $(PSTL_MAKEFILE) clean
clean_all: clean clean_pstl clean_bench
info:
@echo OS = $(os_name)
@echo proj_root = "$(proj_root)"
@echo $(CURDIR)
@echo VPATH = $(VPATH)
@echo LIBRARY_PATH = $(LIBRARY_PATH)
@echo backend = $(backend)
@echo compiler = $(compiler)
-include *.d

build/Makefile.common

  • This file was deleted.
#===-- Makefile.common ---------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
#------------------------------------------------------------------------------
# Define common parts for Parallel STL
#------------------------------------------------------------------------------
.SUFFIXES:
goals = $(or $(MAKECMDGOALS),all)
ifneq (, $(filter-out clean clean_all,$(goals)))
ifeq (, $(filter $(backend), tbb))
$(info Threading backend was not specified; using TBB)
backend=tbb
endif
endif
ifndef os_name
# Windows sets environment variable OS; for other systems, ask uname
ifeq ($(OS),)
OS:=$(shell uname)
ifeq ($(OS),)
$(error "Cannot detect operating system")
endif
os_name=$(OS)
endif
ifeq ($(OS), Windows_NT)
os_name=windows
endif
ifeq ($(OS), Linux)
os_name=linux
endif
ifeq ($(OS), Darwin)
os_name=macos
endif
endif # !os_name
cfg ?= release
stdver ?= c++11
override INCLUDES += -I$(proj_root)/include -I$(proj_root)/test
TEST_MACRO += -D__PSTL_TEST_SUCCESSFUL_KEYWORD=1
ifeq ($(backend), tbb)
BACKEND_MACRO += -D__PSTL_PAR_BACKEND_TBB
endif
target ?= $(os_name)
#OS specific keys
ifeq ($(target),windows)
ifneq (, $(filter $(compiler), gcc g++))
include $(proj_root)/build/mingw.inc
else
include $(proj_root)/build/windows.inc
endif
else
include $(proj_root)/build/unix.inc
ifneq (,$(wildcard $(proj_root)/build/$(target).inc))
include $(proj_root)/build/$(target).inc
$(info included additional file $(proj_root)/build/$(target).inc)
endif
endif
# compiler specific keys
ifneq (, $(filter $(compiler), gcc g++))
include $(proj_root)/build/gcc.inc
endif
ifneq (, $(filter $(compiler), clang clang++))
include $(proj_root)/build/clang.inc
endif
ifneq (, $(filter $(compiler), icc icpc icx))
include $(proj_root)/build/icc.inc
endif
ifneq (, $(filter $(compiler), icl))
include $(proj_root)/build/icl.inc
endif
OPTIMIZATION_ENABLED_FLAGS += $(XHOST_FLAG)
OPTIMIZATION_DISABLED_FLAGS += $(XHOST_FLAG)
ifeq ($(cfg), debug)
TBB_LIB_NAME = tbb_debug
BACKEND_MACRO += -DTBB_USE_DEBUG=1
DEBUG_MACRO += -DPSTL_USE_DEBUG
OPTIMIZATION_KEYS = $(OPTIMIZATION_DISABLED_FLAGS)
else
OPTIMIZATION_KEYS = $(OPTIMIZATION_ENABLED_FLAGS)
endif
DYN_LDFLAGS += $(PSTL_ARCH)
CPLUS_FLAGS += $(TEST_MACRO)
CPLUS_FLAGS += $(INCLUDES)
CPLUS_FLAGS += $(BACKEND_MACRO)
CPLUS_FLAGS += $(DEBUG_MACRO)
CPLUS_FLAGS += $(CXXFLAGS)
CPLUS_FLAGS += $(OPTIMIZATION_KEYS)
CPLUS_FLAGS += $(DISABLED_WARNINGS)
CPLUS_FLAGS += $(PSTL_ARCH)

build/Makefile.pstl

  • This file was deleted.
#===-- Makefile.pstl -----------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
#------------------------------------------------------------------------------
# Define rules for making the Parallel STL library.
#------------------------------------------------------------------------------
proj_root ?= $(CURDIR)/..
include $(proj_root)/build/Makefile.common
.PHONY: clean
VPATH = $(proj_root)/src
lib_src = $(wildcard $(proj_root)/src/*.cpp)
lib_obj = $(notdir $(lib_src:.cpp=$(OBJ_SFX)))
all: pstl
pstl: $(PSTL_LIB_NAME)
%$(OBJ_SFX): %.cpp $(proj_root)/build/Makefile.pstl
$(CPLUS) $(CPLUS_FLAGS) -c $< $(FKEY)o$@
%.s: %.cpp $(proj_root)/build/Makefile
$(CPLUS) $(CPLUS_FLAGS) -S $< $(FKEY)o$@
%.E: %.cpp
$(CPLUS) $(CPLUS_FLAGS) -E $< >$@
clean:
$(DEL_CMD) *$(OBJ_SFX) *.lib *.dll *.so *.exp *$(PSTL_LIB_NAME)*
info:
@echo OS = $(os_name)
@echo proj_root = "$(proj_root)"
@echo $(CURDIR)
@echo VPATH=$(VPATH)
-include *.d

build/android.inc

  • This file was deleted.
#===-- android.inc -------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
PSTL_ARCH=
PIE_FLAGS = -pie -fPIE -fPIC
SDL_FLAGS = -fstack-protector -Wformat -Wformat-security
CPLUS_FLAGS += $(TARGET_CFLAGS) $(PIE_FLAGS) $(SDL_FLAGS)
# Paths to the NDK prebuilt tools and libraries
ifeq (,$(findstring $(ndk_version), $(foreach v, 7 8 9 10 11 12 13 14 15,r$(v) r$(v)b r$(v)c r$(v)d r$(v)e)))
ifeq (clang,$(compiler))
# Since Android* NDK r16 another sysroot and isystem paths have to be specified
CPLUS_FLAGS += --sysroot=$(NDK_ROOT)/sysroot -isystem $(NDK_ROOT)/sysroot/usr/include/$(TRIPLE)
# Android* version flag required since r16
CPLUS_FLAGS += -D__ANDROID_API__=$(API_LEVEL)
else
CPLUS_FLAGS += --sysroot=$(SYSROOT)
endif
else
CPLUS_FLAGS += --sysroot=$(SYSROOT)
endif
LDFLAGS += --sysroot=$(SYSROOT) $(TARGET_CFLAGS)
PSTL_LIB_LINK += -lc++abi -L$(CPLUS_LIB_PATH) -lc++_shared
ifeq (arm,$(arch))
PSTL_LIB_LINK += -lunwind
endif
# TARGET_CXX cames from NDK
override CPLUS:=$(TARGET_CXX) $(USE_SHARED_CPPRUNTIME_KEY)
LD = $(CPLUS) $(TARGET_CFLAGS) $(PIE_FLAGS) $(SDL_FLAGS)
run_cmd ?= -sh $(proj_root)/build/android.linux.launcher.sh $(largs)
# TBB_LIBRARIES := $(foreach dir,$(LIBRARY_PATH),$(wildcard $(dir)/libtbb*so))
TBB_LIBRARIES := $(foreach dir,$(LIBRARY_PATH),$(wildcard $(dir)/*))
LIB_STL_ANDROID += $(TBB_LIBRARIES)
$(warning LIB_STL_ANDROID=$(LIB_STL_ANDROID))
$(warning TBB_LIBRARIES=$(TBB_LIBRARIES))
$(warning LIBRARY_PATH=$(LIBRARY_PATH))

build/android.linux.launcher.sh

  • This file was deleted.
#!/bin/sh
#===-- android.linux.launcher.sh -----------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
#
#
# Usage:
# android.linux.launcher.sh [-v] [-q] [-s] [-r <repeats>] [-u] [-l <library>] <executable> <arg1> <arg2> <argN>
# where: -v enables verbose output
# where: -q enables quiet mode
# where: -s runs the test in stress mode (until non-zero exit code or ctrl-c pressed)
# where: -r <repeats> specifies number of times to repeat execution
# where: -u is ignored on Android
# where: -l <library> specifies the library name to be assigned to LD_PRELOAD
#
# Libs and executable necessary for testing should be present in the current directory before running.
# ANDROID_SERIAL must be set to the connected Android target device name for file transfer and test runs.
# ANDROID_TEST_DIRECTORY may be set to the directory used for testing on the Android target device; otherwise,
# the default directory used is "/data/local/tmp/$(basename $PWD)".
# Note: Do not remove the redirections to '/dev/null' in the script, otherwise the nightly test system will fail.
do_cleanup() #
{ #
adb pull $targetdir/events.txt events.txt > /dev/null 2>&1 #
# Remove target directory on the device
adb shell "rm -r ${targetdir}; mkdir -p ${targetdir}" > /dev/null 2>&1 #
} #
do_trap_cleanup() #
{ #
do_cleanup #
exit -1 #
} #
while getopts "qvsr:ul:" flag #
do case $flag in #
s ) # Stress testing mode
echo Doing stress testing. Press Ctrl-C to terminate
run_env='stressed() { while $*; do :; done; }; ' #
run_prefix="stressed $run_prefix" ;; #
r ) # Repeats test n times
run_env="repeated() { for i in $(seq -s ' ' 1 $OPTARG) ; do echo \$i of $OPTARG:; \$*; done; }; " #
run_prefix="repeated $run_prefix" ;; #
l ) # Additional library
ldpreload="$OPTARG " ;; #
u ) # Stack limit
;; #
q ) # Quiet mode, removes 'done' but prepends any other output by test name
OUTPUT='2>&1 | sed -e "s/done//;/^[[:space:]]*$/d;s!^!$exename: !"' ;; #
v ) # Verbose mode
SUPPRESS='' #
verbose=1 ;; #
esac done #
shift `expr $OPTIND - 1` #
[ -z "$OUTPUT" ] && OUTPUT='| sed -e "s/\\r$//"' #
[ $verbose ] || SUPPRESS='>/dev/null' #
# Collect the executable name
exename=$(basename $1) #
shift #
# Prepare the target directory on the device
currentdir=$(basename $PWD) #
targetdir=${ANDROID_TEST_DIRECTORY:-/data/local/tmp/$currentdir} #
do_cleanup #
trap do_trap_cleanup INT # if someone hits control-c, cleanup the device
# Collect the list of files to transfer to the target device, starting with executable itself.
fnamelist="$exename" #
# Add the C++ standard library from the NDK, which is required for all tests on Android.
if [ ! -z "${LIB_STL_ANDROID}" ]; then #
fnamelist="$fnamelist ${LIB_STL_ANDROID}" #
else #
fnamelist="$fnamelist libc++_shared.so" #
fi #
# Find the TBB libraries and add them to the list.
OLD_SEP=$IFS
IFS=':'
for dir in $LD_LIBRARY_PATH; do #
found="`ls $dir/lib*.so 2>/dev/null` "||: #
fnamelist+="$fnamelist $found"
done #
IFS=$OLD_SEP
files="$(ls libtbb* 2> /dev/null)" #
[ -z "$files" ] || fnamelist="$fnamelist $files" #
# Add any libraries built for specific tests.
exeroot=${exename%\.*} #
files="$(ls ${exeroot}*.so ${exeroot}*.so.* 2> /dev/null)" #
[ -z "$files" ] || fnamelist="$fnamelist $files" #
# Transfer collected executable and library files to the target device.
transfers_ok=1 #
for fullname in $fnamelist; do { #
if [ -r $fullname ]; then { #
# Transfer the executable and libraries to top-level target directory
if [ "$OS" = 'Windows_NT' ]; then #
fullname=`cygpath -m "$fullname"` #
fi #
[ $verbose ] && echo -n "Pushing $fullname: " #
eval "adb push $fullname ${targetdir}/$(basename $fullname) $SUPPRESS 2>&1" #
}; else { #
echo "Error: required file ${currentdir}/${fullname} for test $exename not available for transfer." #
transfers_ok=0 #
}; fi #
}; done #
if [ "${transfers_ok}" = "0" ]; then { #
do_cleanup #
exit -1 #
}; fi #
# Transfer input files used by example codes by scanning the executable argument list.
for fullname in "$@"; do { #
if [ -r $fullname ]; then { #
directory=$(dirname $fullname) #
filename=$(basename $fullname) #
# strip leading "." from fullname if present
if [ "$directory" = "\." ]; then { #
directory="" #
fullname=$filename #
}; fi #
# Create the target directory to hold input file if necessary
if [ ! -z $directory ]; then { #
eval "adb shell 'mkdir $directory' $SUPPRESS 2>&1" #
}; fi #
# Transfer the input file to corresponding directory on target device
[ $verbose ] && echo -n "Pushing $fullname: " #
eval "adb push $fullname ${targetdir}/$fullname $SUPPRESS 2>&1" #
}; fi #
}; done #
# Set LD_PRELOAD if necessary
[ -z "$ldpreload" ] || run_prefix="LD_PRELOAD='$ldpreload' $run_prefix" #
[ $verbose ] && echo Running $run_prefix ./$exename $* #
run_env="$run_env cd $targetdir; export LD_LIBRARY_PATH=." #
[ -z "$VIRTUAL_MACHINE" ] || run_env="$run_env; export VIRTUAL_MACHINE=$VIRTUAL_MACHINE" #
# The return_code file is the best way found to return the status of the test execution when using adb shell.
eval 'adb shell "$run_env; $run_prefix ./$exename $* || echo -n \$? >error_code"' "${OUTPUT}" #
# Capture the return code string and remove the trailing \r from the return_code file contents
err=`adb shell "cat $targetdir/error_code 2>/dev/null"` #
[ -z $err ] || echo $exename: exited with error $err #
do_cleanup #
# Return the exit code of the test.
exit $err #

build/clang.inc

  • This file was deleted.
#===-- clang.inc ---------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
override compiler:=clang++
ifneq ($(target),android)
PSTL_ARCH += $(KEY)march=native
endif
XHOST_FLAG = -fno-vectorize
CPLUS_FLAGS += $(FQKEY)std=$(stdver)
# XHOST_FLAG = $(KEY)mavx2 -fno-vectorize
# XHOST_FLAG = $(KEY)mavx512f -fno-vectorize
# DYN_LDFLAGS += $(LINK_KEY)c++
# CPLUS_FLAGS += -stdlib=libc++
# CPLUS_FLAGS += -fopenmp-simd //it will be supported in he future version

build/gcc.inc

  • This file was deleted.
#===-- gcc.inc -----------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
override compiler:=g++
XHOST_FLAG = $(KEY)march=native -fno-tree-vectorize
# XHOST_FLAG = $(KEY)mavx2 -fno-tree-vectorize
# XHOST_FLAG = $(KEY)mavx512f -fno-tree-vectorize
DYN_LDFLAGS += $(LINK_KEY)stdc++
# GCC 4.8.5 and early doesn't support -fopenmp-simd; GCC 4.9 supports OpenMP 4.0 for C/C++
ifneq (, $(shell gcc -dumpversion | egrep "^4\.9\.[0-9]"))
CPLUS_FLAGS += -fopenmp-simd
endif
ifneq (, $(shell gcc -dumpversion | egrep "^[5-9]\.[0-9]\.[0-9]"))
CPLUS_FLAGS += -fopenmp-simd
# CPLUS_FLAGS += -fdump-rtl-loop2 #use this option to enable optimization report
endif
CPLUS_FLAGS += $(FQKEY)std=$(stdver)
ifeq ($(os_name),windows)
DISABLED_WARNINGS = $(KEY)Wno-attributes #disable MinGW warnings about extended alignment
endif

build/icc.inc

  • This file was deleted.
#===-- icc.inc -----------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
vecreport ?= 0 #may be set to [0..7], see https://software.intel.com/en-us/node/522949 for details
XHOST_FLAG = $(KEY)xHOST -no-vec
CPLUS_FLAGS += $(QKEY)opt-assume-safe-padding
# XHOST_FLAG = $(KEY)xCORE-AVX2 -no-vec
# XHOST_FLAG = $(KEY)xSSE4.1 -no-vec
# XHOST_FLAG = $(KEY)xMIC-AVX512 -no-vec
CPLUS_FLAGS += $(QKEY)openmp-simd
CPLUS_FLAGS += $(FQKEY)MMD
CPLUS_FLAGS += $(FQKEY)std=$(stdver)
CPLUS_FLAGS += $(QKEY)opt-report=$(vecreport) $(QKEY)opt-report-phase vec
OPTIMIZATION_DISABLED_FLAGS += $(KEY)debug inline-debug-info

build/icl.inc

  • This file was deleted.
#===-- icl.inc -----------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
vecreport ?= 0 #may be set to [0..7], see https://software.intel.com/en-us/node/522949 for details
XHOST_FLAG = $(QKEY)xHOST
XHOST_FLAG = $(QKEY)vec-
# XHOST_FLAG = $(QKEY)xCORE-AVX2
# XHOST_FLAG = $(QKEY)xSSE4.1
# XHOST_FLAG = $(QKEY)xMIC-AVX512
CPLUS_FLAGS += $(QKEY)opt-assume-safe-padding
CPLUS_FLAGS += $(QKEY)openmp-simd
CPLUS_FLAGS += $(FQKEY)MMD
CPLUS_FLAGS += $(FQKEY)std=$(stdver)
CPLUS_FLAGS += $(QKEY)opt-report:$(vecreport) $(QKEY)opt-report-phase:vec $(QKEY)opt-report-phase:loop
DISABLED_WARNINGS = $(QKEY)diag-disable:2586 #use comma-separated values to specify multiple entries

build/jni/Android.mk

  • This file was deleted.
#===-- Android.mk --------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
export proj_root?=$(NDK_PROJECT_PATH)/..
ifeq (armeabi-v7a,$(APP_ABI))
export SYSROOT:=$(NDK_ROOT)/platforms/$(APP_PLATFORM)/arch-arm
else ifeq (arm64-v8a,$(APP_ABI))
export SYSROOT:=$(NDK_ROOT)/platforms/$(APP_PLATFORM)/arch-arm64
else
export SYSROOT:=$(NDK_ROOT)/platforms/$(APP_PLATFORM)/arch-$(APP_ABI)
endif
ifeq (windows,$(os_name))
export CPATH_SEPARATOR :=;
else
export CPATH_SEPARATOR :=:
endif
export ANDROID_NDK_ROOT:=$(NDK_ROOT)
export ndk_version:=$(lastword $(subst -, ,$(ANDROID_NDK_ROOT)))
ndk_version:= $(firstword $(subst /, ,$(ndk_version)))
ndk_version:= $(firstword $(subst \, ,$(ndk_version)))
ifeq (clang,$(compiler))
# "TBB_RTL :=llvm-libc++/libcxx" should be used for ndk_version r13 r13b r14.
TBB_RTL :=llvm-libc++
TBB_RTL_LIB :=llvm-libc++
TBB_RTL_FILE :=libc++_shared.so
else
TBB_RTL :=gnu-libstdc++/$(NDK_TOOLCHAIN_VERSION)
TBB_RTL_LIB :=$(TBB_RTL)
TBB_RTL_FILE :=libgnustl_shared.so
endif
export CPATH := $(INCLUDE)$(CPATH_SEPARATOR)$(SYSROOT)/usr/include$(CPATH_SEPARATOR)$(NDK_ROOT)/sources/cxx-stl/$(TBB_RTL)/include$(CPATH_SEPARATOR)$(NDK_ROOT)/sources/cxx-stl/$(TBB_RTL)/libs/$(APP_ABI)/include$(CPATH_SEPARATOR)$(NDK_ROOT)/sources/android/support/include
LIB_STL_ANDROID_DIR := $(NDK_ROOT)/sources/cxx-stl/$(TBB_RTL_LIB)/libs/$(APP_ABI)
#LIB_STL_ANDROID is required to be set up for copying Android specific library to a device next to test
export LIB_STL_ANDROID := $(LIB_STL_ANDROID_DIR)/$(TBB_RTL_FILE)
export CPLUS_LIB_PATH := $(SYSROOT)/usr/lib -L$(LIB_STL_ANDROID_DIR)
export target_os_version:=$(APP_PLATFORM)
export tbb_tool_prefix:=$(TOOLCHAIN_PREFIX)
export TARGET_CXX
export TARGET_CC
export TARGET_CFLAGS
include $(proj_root)/build/Makefile

build/jni/Application.mk

  • This file was deleted.
#===-- Application.mk ----------------------------------------------------===##
#
# 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 os_name
# Windows sets environment variable OS; for other systems, ask uname
ifeq ($(OS),)
OS:=$(shell uname)
ifeq ($(OS),)
$(error "Cannot detect operating system")
endif
export os_name=$(OS)
endif
ifeq ($(OS), Windows_NT)
export os_name=windows
endif
ifeq ($(OS), Linux)
export os_name=linux
endif
ifeq ($(OS), Darwin)
export os_name=macos
endif
endif
export compiler?=clang
export arch?=ia32
export target?=android
ifeq (ia32,$(arch))
APP_ABI:=x86
export TRIPLE:=i686-linux-android
else ifeq (intel64,$(arch))
APP_ABI:=x86_64
export TRIPLE:=x86_64-linux-android
else ifeq (arm,$(arch))
APP_ABI:=armeabi-v7a
export TRIPLE:=arm-linux-androideabi
else ifeq (arm64,$(arch))
APP_ABI:=arm64-v8a
export TRIPLE:=aarch64-linux-android
else
APP_ABI:=$(arch)
endif
api_version?=21
export API_LEVEL:=$(api_version)
APP_PLATFORM:=android-$(api_version)
ifeq (clang,$(compiler))
NDK_TOOLCHAIN_VERSION:=clang
APP_STL:=c++_shared
else
NDK_TOOLCHAIN_VERSION:=4.9
endif

build/macos.inc

  • This file was deleted.
#===-- macos.inc ---------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
DYN_LDFLAGS += -Wl,-rpath,$(TBBROOT)/lib

build/mingw.inc

  • This file was deleted.
#===-- mingw.inc ---------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
PYTHON = python
KEY = -
QKEY = $(KEY)q
FKEY = $(KEY)
FQKEY = $(KEY)
MACHINE_KEY = $(KEY)m
OBJ_SFX = .o
DEL_CMD = del /F
RUN_CMD =
COMMAND_SEPARATOR = &
compiler ?= gcc
COMPILER_NOLOGO_KEY =
OPTIMIZATION_DISABLED_FLAGS = $(KEY)Og $(KEY)g
OPTIMIZATION_ENABLED_FLAGS += $(KEY)O2
TBB_LIB_NAME = tbb
CPLUS = $(compiler)
LD = $(CPLUS)
USE_SHARED_CPPRUNTIME_KEY =
LINK_KEY = $(KEY)l
LD_OUT_KEY = $(KEY)o
DYN_LDFLAGS += -L. -L$(proj_root)/build
ifneq ($(PSTL_LIB_NAME), )
PSTL_LIB_LINK += $(LINK_KEY)$(PSTL_LIB_NAME)$(PSTL_LIB_EXT)
endif
ifeq ($(backend),tbb)
DYN_LDFLAGS += $(LINK_KEY)$(TBB_LIB_NAME)
endif
ifeq ($(arch),intel64)
PSTL_ARCH = $(MACHINE_KEY)64
else ifeq ($(arch),ia32)
PSTL_ARCH = $(MACHINE_KEY)32
else ifeq ($(arch),)
$(info arch=native by default)
else
PSTL_ARCH = $(MACHINE_KEY)$(arch)
endif

build/unix.inc

  • This file was deleted.
#===-- unix.inc ----------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
PYTHON = python
KEY = -
QKEY = $(KEY)q
FKEY = $(KEY)
FQKEY = $(KEY)
MACHINE_KEY = $(KEY)m
OBJ_SFX = .o
DEL_CMD = rm $(KEY)f
RUN_CMD = ./
COMMAND_SEPARATOR = ;
compiler ?= icc
COMPILER_NOLOGO_KEY =
OPTIMIZATION_DISABLED_FLAGS = $(KEY)O0 $(KEY)g
OPTIMIZATION_ENABLED_FLAGS += $(KEY)O2
TBB_LIB_NAME = tbb
CPLUS = $(compiler)
LD = $(CPLUS)
USE_SHARED_CPPRUNTIME_KEY =
LINK_KEY = $(KEY)l
LD_OUT_KEY = $(KEY)o
DYN_LDFLAGS += -L. -L$(proj_root)/build
ifneq ($(PSTL_LIB_NAME), )
PSTL_LIB_LINK += $(LINK_KEY)$(PSTL_LIB_NAME)$(PSTL_LIB_EXT)
endif
ifeq ($(backend), tbb)
DYN_LDFLAGS += $(LINK_KEY)$(TBB_LIB_NAME)
endif
ifeq ($(arch),intel64)
PSTL_ARCH = $(MACHINE_KEY)64
else ifeq ($(arch),ia32)
PSTL_ARCH = $(MACHINE_KEY)32
else ifeq ($(arch),)
$(info arch=native by default)
else
PSTL_ARCH = $(MACHINE_KEY)$(arch)
endif

build/windows.inc

  • This file was deleted.
#===-- windows.inc -------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
PYTHON = python
compiler ?= icl
LD = LINK
KEY = /
LINK_KEY =
QKEY = $(KEY)Q
FKEY = $(KEY)F
FQKEY = $(QKEY)
MACHINE_KEY = $(QKEY)
OBJ_SFX = .obj
DEL_CMD = del $(KEY)F
RUN_CMD =
COMMAND_SEPARATOR = &
COMPILER_NOLOGO_KEY = $(KEY)nologo
OPTIMIZATION_DISABLED_FLAGS = $(KEY)Od $(KEY)Zi $(KEY)DEBUG $(KEY)Fd"$*.pdb"
OPTIMIZATION_ENABLED_FLAGS = $(KEY)O2 $(KEY)DNDEBUG
LD_OUT_KEY = $(KEY)OUT:
ifneq ($(PSTL_LIB_NAME), )
PSTL_LIB_EXT = .lib
PSTL_LIB_LINK += $(LINK_KEY)$(PSTL_LIB_NAME)$(PSTL_LIB_EXT)
endif
# Do not update LDFLAGS with corresponding TBB_LIB_NAME here, because of
# implicit linkage capability of TBB library
ifeq ($(cfg),debug)
LINK_KEY += $(KEY)debug
USE_SHARED_CPPRUNTIME_KEY += $(KEY)MDd $(KEY)EHsc
BACKEND_MACRO += -DTBB_USE_DEBUG=1
else
USE_SHARED_CPPRUNTIME_KEY += $(KEY)MD $(KEY)EHsc
endif
ifneq (, $(filter $(compiler), cl icl))
CPLUS_FLAGS += $(KEY)bigobj
endif
DYN_LDFLAGS += $(LINK_KEY)
ifneq (,$(filter uwp,$(target_app) $(target_ui)))
CPLUS_FLAGS += /ZW:nostdlib /D "_UNICODE" /D "UNICODE" /D "WINAPI_FAMILY=WINAPI_FAMILY_APP"
_WIN32_WINNT = 0x0A00
DYN_LDFLAGS += /NODEFAULTLIB:"kernel32.lib" OneCore.lib
endif

include/pstl/internal/algorithm_fwd.h

  • This file was added.
// -*- C++ -*-
//===-- algorithm_fwd.h --------------------------------------------------===//
MikeDvorskiyUnsubmitted
Not Done
ReplyInline Actions

Thomas, what's a reason to rename the files with forward declarations? (glue_algorithm_defs.h, glue_numeric_defs.h, glue_memory_defs.h to algorithm_fwd.h, numeric_fwd.h, memory_fwd.h)

MikeDvorskiy: Thomas, what's a reason to rename the files with forward declarations? (glue_algorithm_defs.h…
rodgertAuthorUnsubmitted
Done
ReplyInline Actions

Look carefully at the files, they are *NOT* the same thing.

rodgert: Look carefully at the files, they are *NOT* the same thing.
//
// 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 <type_traits>
#include <utility>
namespace __pstl
{
namespace internal
{
//------------------------------------------------------------------------
// any_of
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Pred>
bool
brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _Pred>
bool
brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
/*parallel=*/std::true_type);
#endif
#if 0
// TODO does this even need forwarding?
template <class _ForwardIterator, class _Size, class _Function>
_ForwardIterator for_each_n_it_serial(_ForwardIterator, _Size, _Function);
#endif
//------------------------------------------------------------------------
// walk1 (pseudo)
//
// walk1 evaluates f(x) for each dereferenced value x drawn from [first,last)
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Function>
void brick_walk1(_ForwardIterator, _ForwardIterator, _Function,
/*vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _Function>
void brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
/*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
void pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
void pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
/*parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
/*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// walk1_n
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _Function>
_ForwardIterator brick_walk1_n(_ForwardIterator, _Size, _Function,
/*_IsVectorTag=*/std::false_type);
template <class _RandomAccessIterator, class _DifferenceType, class _Function>
_RandomAccessIterator brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
/*vectorTag=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
_ForwardIterator pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy,class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
_RandomAccessIterator pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector,
/*is_parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
_ForwardIterator pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
_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 <class _ForwardIterator1, class _ForwardIterator2, class _Function>
_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
/*vector=*/std::true_type) noexcept;
template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
/*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2 pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2 pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
/*parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2 pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function, class _IsVector>
_RandomAccessIterator2 pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector,
/*parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
_ForwardIterator2 pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
_RandomAccessIterator2 pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_Brick,
/*parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
_ForwardIterator2 pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
_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 <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
_ForwardIterator3 brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
/*vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
_RandomAccessIterator3 brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_RandomAccessIterator3, _Function,
/*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function, class _IsVector>
_ForwardIterator3 pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
_IsVector,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function,
class _IsVector>
_RandomAccessIterator3 pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// equal
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
bool brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
/* IsVector = */ std::false_type) noexcept;
template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
bool brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
/* is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
bool pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, _IsVector,
/* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, class _IsVector>
bool pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// find_if
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Predicate>
_ForwardIterator brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
/*is_vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _Predicate>
_RandomAccessIterator brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
_ForwardIterator pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
_ForwardIterator pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// find_end
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
_ForwardIterator1 pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
_ForwardIterator1 pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector,
/*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// find_first_of
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
_ForwardIterator1 pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
_ForwardIterator1 pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// search
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate,
/*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
_ForwardIterator1 pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
_ForwardIterator1 pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_BinaryPredicate, _IsVector,
/*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// search_n
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_ForwardIterator
brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_ForwardIterator
brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
/*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
_ForwardIterator
pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
_RandomAccessIterator
pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
/*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// copy_n
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _OutputIterator>
_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _Size, class _OutputIterator>
_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
/*vector=*/std::true_type) noexcept;
//------------------------------------------------------------------------
// copy
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator,
/*vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _OutputIterator>
_OutputIterator brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
/*vector=*/std::true_type) noexcept;
//------------------------------------------------------------------------
// move
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator,
/*vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _OutputIterator>
_OutputIterator brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
/*vector=*/std::true_type) noexcept;
//------------------------------------------------------------------------
// swap_ranges
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
/*vector=*/std::true_type) noexcept;
//------------------------------------------------------------------------
// copy_if
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
/*vector=*/std::true_type) noexcept;
template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
std::pair<_DifferenceType, _DifferenceType>
brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate,
/*vector=*/std::false_type) noexcept;
template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
std::pair<_DifferenceType, _DifferenceType>
brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate,
/*vector=*/std::true_type) noexcept;
template <class _ForwardIterator, class _OutputIterator>
void
brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*,
/*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator>
void
brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict,
/*vector=*/std::true_type) noexcept;
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
void
brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*,
/*vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
void
brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*,
/*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
_OutputIterator pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector,
/*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
_OutputIterator pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
_IsVector, /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// count
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Predicate>
typename std::iterator_traits<_ForwardIterator>::difference_type
brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
/* is_vector = */ std::true_type) noexcept;
template <class _ForwardIterator, class _Predicate>
typename std::iterator_traits<_ForwardIterator>::difference_type
brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
/* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
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 <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type
pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
/* is_parallel */ std::true_type, _IsVector);
#endif
//------------------------------------------------------------------------
// unique
//------------------------------------------------------------------------
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
/*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
/*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// unique_copy
//------------------------------------------------------------------------
template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
OutputIterator brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate,
/*vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate>
_OutputIterator brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
/*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class OutputIterator, class _BinaryPredicate, class _IsVector>
OutputIterator pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector,
/*parallel=*/std::false_type) noexcept;
template <class _ExecutionPolicy, class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
_DifferenceType
brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
/*vector=*/std::false_type) noexcept;
template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
_DifferenceType
brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
/*vector=*/std::true_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate, class _IsVector>
_OutputIterator pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
_IsVector, /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// reverse
//------------------------------------------------------------------------
template <class _BidirectionalIterator>
void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
/*__is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator>
void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
/*__is_vector=*/std::true_type) noexcept;
template <class _BidirectionalIterator>
void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
/*is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator>
void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
void pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
void pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// reverse_copy
//------------------------------------------------------------------------
template <class _BidirectionalIterator, class _OutputIterator>
_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
/*is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator, class _OutputIterator>
_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// rotate
//------------------------------------------------------------------------
template <class _ForwardIterator>
_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
/*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator>
_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// rotate_copy
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// is_partitioned
//------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate>
bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _UnaryPredicate>
bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// partition
//------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// stable_partition
//------------------------------------------------------------------------
template <class _BidirectionalIterator, class _UnaryPredicate>
_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
/*__is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator, class _UnaryPredicate>
_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
_IsVector,
/*is_parallelization=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
_IsVector,
/*is_parallelization=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// partition_copy
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1,
_OutputIterator2, _UnaryPredicate,
/*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1,
_OutputIterator2, _UnaryPredicate,
/*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
class _IsVector>
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 <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2>
pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
_OutputIterator1, _OutputIterator2,
_UnaryPredicate, _IsVector,
/*is_parallelization=*/std::true_type);
#endif
//------------------------------------------------------------------------
// sort
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector, class _IsMoveConstructible>
void pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
/*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
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 <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// partial_sort
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// partial_sort_copy
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
_RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
_RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// adjacent_find
//------------------------------------------------------------------------
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator
brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
/* IsVector = */ std::true_type, bool) noexcept;
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator
brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
/* IsVector = */ std::false_type, bool) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator
pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate,
/* is_parallel */ std::false_type, _IsVector, bool) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
_RandomAccessIterator
pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
/* is_parallel */ std::true_type, _IsVector, bool);
#endif
//------------------------------------------------------------------------
// nth_element
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// fill, fill_n
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Tp>
void
brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
/* __is_vector = */ std::true_type) noexcept;
template <class _ForwardIterator, class _Tp>
void
brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
/* __is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
void
pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
/*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
_ForwardIterator
pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
/*is_parallel=*/std::true_type, _IsVector);
#endif
template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator
brick_fill_n(_OutputIterator, _Size, const _Tp&,
/* __is_vector = */ std::true_type) noexcept;
template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator
brick_fill_n(_OutputIterator, _Size, const _Tp&,
/* __is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator
pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
/*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator
pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
/*is_parallel=*/std::true_type, _IsVector);
#endif
//------------------------------------------------------------------------
// generate, generate_n
//------------------------------------------------------------------------
template <class _RandomAccessIterator, class _Generator>
void brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator,
/* is_vector = */ std::true_type) noexcept;
template <class _ForwardIterator, class _Generator>
void brick_generate(_ForwardIterator, _ForwardIterator, _Generator,
/* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
void pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
/*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
_ForwardIterator pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
/*is_parallel=*/std::true_type, _IsVector);
#endif
template <class OutputIterator, class Size, class _Generator>
OutputIterator brick_generate_n(OutputIterator, Size, _Generator,
/* is_vector = */ std::true_type) noexcept;
template <class OutputIterator, class Size, class _Generator>
OutputIterator brick_generate_n(OutputIterator, Size, _Generator,
/* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
OutputIterator pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
/*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
OutputIterator pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
/*is_parallel=*/std::true_type, _IsVector);
#endif
//------------------------------------------------------------------------
// remove
//------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
/* __is_vector = */ std::false_type) noexcept;
template <class _RandomAccessIterator, class _UnaryPredicate>
_RandomAccessIterator brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
/* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel*/ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
/*is_parallel*/ std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// merge
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
_Compare,
/* __is_vector = */ std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
_Compare,
/* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare,
class _IsVector>
_OutputIterator pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
_RandomAccessIterator2, _OutputIterator, _Compare, _IsVector,
/* is_parallel = */ std::true_type);
#endif
//------------------------------------------------------------------------
// inplace_merge
//------------------------------------------------------------------------
template <class _BidirectionalIterator, class _Compare>
void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
/* __is_vector = */ std::false_type) noexcept;
template <class _BidirectionalIterator, class _Compare>
void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
/* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// set_union
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// set_intersection
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// set_difference
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// set_symmetric_difference
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _OutputIterator, _Compare,
/*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _OutputIterator, _Compare,
/*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_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 <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
_OutputIterator pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _OutputIterator, _Compare, _IsVector,
/*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// is_heap_until
//------------------------------------------------------------------------
template <class _RandomAccessIterator, class _Compare>
_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
/* __is_vector = */ std::false_type) noexcept;
template <class _RandomAccessIterator, class _Compare>
_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/* is_parallel = */ std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// min_element
//------------------------------------------------------------------------
template <typename _ForwardIterator, typename _Compare>
_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::false_type) noexcept;
template <typename _ForwardIterator, typename _Compare>
_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept;
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
_ForwardIterator pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
/* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector>
_RandomAccessIterator pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
/* is_parallel = */ std::true_type);
#endif
//------------------------------------------------------------------------
// minmax_element
//------------------------------------------------------------------------
template <typename _ForwardIterator, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator>
brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::false_type) noexcept;
template <typename _ForwardIterator, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator>
brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
/* __is_vector = */ std::true_type) noexcept;
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator>
pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare,
_IsVector,
/* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator>
pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare,
_IsVector,
/* is_parallel = */ std::true_type);
#endif
//------------------------------------------------------------------------
// mismatch
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
std::pair<_ForwardIterator1, _ForwardIterator2>
brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _Predicate,
/* __is_vector = */ std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
std::pair<_ForwardIterator1, _ForwardIterator2>
brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
_ForwardIterator2, _Predicate,
/* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
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 <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate, class _IsVector>
std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
_Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
// lexicographical_compare
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
/* __is_vector = */ std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
/* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
_Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
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 */

include/pstl/internal/glue_algorithm_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_algorithm_impl.h ---------------------------------------------===// //===-- glue_algorithm_impl.h ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_algorithm_impl_H #ifndef __PSTL_glue_algorithm_impl_H
#define __PSTL_glue_algorithm_impl_H #define __PSTL_glue_algorithm_impl_H
#include <functional> #include <functional>
#include "execution_defs.h" #include "execution_defs.h"
#include "utils.h" #include "utils.h"
#include "algorithm_impl.h" #include "algorithm_fwd.h"
#include "numeric_impl.h" /* count and count_if use pattern_transform_reduce */ #include "numeric_fwd.h" /* count and count_if use pattern_transform_reduce */
namespace std namespace std
{ {
// [alg.any_of] // [alg.any_of]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate> template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool> __pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
▲ Show 20 Lines • Show All 1,146 Lines • Show Last 20 Lines

include/pstl/internal/glue_execution_defs.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
// Implementation-defined names // Implementation-defined names
// Unsequenced policy is not yet standard, but for consistency // Unsequenced policy is not yet standard, but for consistency
// we include it into namespace std::execution as well // we include it into namespace std::execution as well
using __pstl::execution::unseq; using __pstl::execution::unseq;
using __pstl::execution::unsequenced_policy; using __pstl::execution::unsequenced_policy;
} // namespace execution } // namespace execution
} // namespace std } // namespace std
#include "algorithm_impl.h"
#include "numeric_impl.h"
#include "parallel_backend.h"
#endif /* __PSTL_glue_execution_defs_H */ #endif /* __PSTL_glue_execution_defs_H */

include/pstl/internal/glue_memory_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- glue_memory_impl.h ------------------------------------------------===// //===-- glue_memory_impl.h ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_glue_memory_impl_H #ifndef __PSTL_glue_memory_impl_H
#define __PSTL_glue_memory_impl_H #define __PSTL_glue_memory_impl_H
#include "utils.h" #include "utils.h"
#include "algorithm_impl.h" #include "algorithm_fwd.h"
namespace std namespace std
{ {
// [uninitialized.copy] // [uninitialized.copy]
template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator> template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> __pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
▲ Show 20 Lines • Show All 334 Lines • Show Last 20 Lines

include/pstl/internal/numeric_fwd.h

  • This file was added.
// -*- 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 <type_traits>
#include <utility>
namespace __pstl
{
namespace internal
{
//------------------------------------------------------------------------
// transform_reduce (version with two binary functions, according to draft N4659)
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
_Tp
brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
_BinaryOperation2,
/*__is_vector=*/std::true_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
_Tp
brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
_BinaryOperation2,
/*__is_vector=*/std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2,
class _IsVector>
_Tp
pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
_BinaryOperation2, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp, class _BinaryOperation1,
class _BinaryOperation2, class _IsVector>
_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 <class _ForwardIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
_Tp
brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
/*is_vector=*/std::true_type) noexcept;
template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
_Tp
brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
/*is_vector=*/std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
_Tp
pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector,
/*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
_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 <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
_UnaryOperation, _Tp, _BinaryOperation,
/*Inclusive*/ std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
_UnaryOperation, _Tp, _BinaryOperation,
/*Inclusive*/ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
class _Inclusive, class _IsVector>
_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 <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
class _Inclusive, class _IsVector>
_OutputIterator pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryOperation,
_Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
// adjacent_difference
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
/*is_vector*/ std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
/*is_vector*/ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
_OutputIterator pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
_IsVector, /*is_parallel*/ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
_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 */

include/pstl/internal/numeric_impl.h

// -*- C++ -*- // -*- C++ -*-
//===-- numeric_impl.h ----------------------------------------------------===// //===-- numeric_impl.h ----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_numeric_impl_H #ifndef __PSTL_numeric_impl_H
#define __PSTL_numeric_impl_H #define __PSTL_numeric_impl_H
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <numeric> #include <numeric>
#include "pstl_config.h"
#include "execution_impl.h" #include "execution_impl.h"
#include "unseq_backend_simd.h" #include "unseq_backend_simd.h"
#include "algorithm_fwd.h"
#if __PSTL_USE_PAR_POLICIES #if __PSTL_USE_PAR_POLICIES
#include "parallel_backend.h" #include "parallel_backend.h"
#endif #endif
namespace __pstl namespace __pstl
{ {
namespace internal namespace internal
▲ Show 20 Lines • Show All 341 Lines • Show Last 20 Lines

test/CMakeLists.txt

#===-- CMakeLists.txt ----------------------------------------------------===## # TODO implement me
#
# 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
#
#===----------------------------------------------------------------------===##
# TODO(ldionne): This CMake testing infrastructure should be replaced with a include_directories("${PROJECT_SOURCE_DIR}/include"
# llvm-lit test suite. ${CMAKE_CURRENT_LIST_DIR})
add_custom_target(pstl-build-tests add_definitions(-DPSTL_STANDALONE_TESTS)
COMMENT "Build all the pstl tests.")
add_custom_target(check-pstl macro(add_pass_test test_source)
COMMAND "${CMAKE_CTEST_COMMAND}" --output-on-failure string(REPLACE ".cpp" "" test_name ${test_source})
USES_TERMINAL add_executable(${test_name} ${test_source})
DEPENDS pstl-build-tests target_link_libraries(${test_name} PRIVATE pstl::ParallelSTL)
COMMENT "Build and run all the unit tests.") add_test(NAME ${test_name} COMMAND ${test_name})
endmacro()
file(GLOB_RECURSE UNIT_TESTS "test_*.cpp") add_subdirectory(std)
foreach(_file IN LISTS UNIT_TESTS)
file(RELATIVE_PATH _target "${CMAKE_CURRENT_SOURCE_DIR}" "${_file}")
string(REPLACE ".cpp" "" _target "${_target}")
set(_target "pstl-${_target}")
add_executable(${_target} EXCLUDE_FROM_ALL "${_file}")
target_link_libraries(${_target} PRIVATE pstl::ParallelSTL)
set_target_properties(${_target} PROPERTIES CXX_EXTENSIONS NO
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
add_test(${_target} "${CMAKE_CURRENT_BINARY_DIR}/${_target}")
add_dependencies(pstl-build-tests ${_target})
endforeach()

test/pstl_test_config.h

  • This file was moved to test/support/pstl_test_config.h.

test/std/CMakeLists.txt

  • This file was added.
add_subdirectory(algorithms)
add_subdirectory(utilities)
add_subdirectory(numerics)

test/std/algorithms/CMakeLists.txt

  • This file was added.
add_subdirectory(alg.nonmodifying)
add_subdirectory(alg.modifying.operations)
add_subdirectory(alg.sorting)
add_subdirectory(alg.merge)

test/std/algorithms/alg.merge/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
merge.pass.cpp;
inplace_merge.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_inplace_merge.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_inplace_merge.cpp --------------------------------------------===// //===-- inplace_merge.pass.cpp --------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include <algorithm> #include <algorithm>
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "utils.h" #include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
void void
operator()(pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2, operator()(__pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2,
Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
{ {
} }
template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
void void
operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, operator()(__pstl::execution::parallel_unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2,
BiDirIt1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) BiDirIt1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
{ {
} }
#endif #endif
// inplace_merge works with bidirectional iterators at least // inplace_merge works with bidirectional iterators at least
template <typename Policy, typename BiDirIt1, typename Size, typename Generator1, typename Generator2, template <typename Policy, typename BiDirIt1, typename Size, typename Generator1, typename Generator2,
typename Compare> typename Compare>
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_merge.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_merge.cpp ----------------------------------------------------===// //===-- merge.pass.cpp ----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" // Tests for copy_if and remove_copy_if
#include "support/pstl_test_config.h"
#include <algorithm>
#include <functional> #include <functional>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "utils.h" #include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_merge struct test_merge
{ {
template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator, template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator,
typename Compare> typename Compare>
void void
operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
OutputIterator out_first, OutputIterator out_last, Compare comp) OutputIterator out_first, OutputIterator out_last, Compare comp)
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

test/std/algorithms/alg.modifying.operations/CMakeLists.txt

  • This file was added.
add_subdirectory(alg.copy)
add_subdirectory(alg.partitions)
add_subdirectory(alg.reverse)
set(PASS_SOURCES
copy_move.pass.cpp;
fill.pass.cpp;
generate.pass.cpp;
replace.pass.cpp;
replace_copy.pass.cpp;
remove.pass.cpp;
remove_copy.pass.cpp;
rotate_copy.pass.cpp;
rotate.pass.cpp;
swap_ranges.pass.cpp;
transform_unary.pass.cpp;
transform_binary.pass.cpp
unique_copy_equal.pass.cpp;
unique.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

test/std/algorithms/alg.modifying.operations/alg.copy/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
copy_if.pass.cpp;
)
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_copy_if.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_copy_if.cpp --------------------------------------------------===// //===-- copy_if.pass.cpp --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for copy_if and remove_copy_if // Tests for copy_if and remove_copy_if
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct run_copy_if struct run_copy_if
{ {
#if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration #if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
void void
operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(__pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
Predicate pred, T trash) Predicate pred, T trash)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
void void
operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
OutputIterator2 expected_last, Size n, Predicate pred, T trash) OutputIterator2 expected_last, Size n, Predicate pred, T trash)
{ {
} }
#endif #endif
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

test/std/algorithms/alg.modifying.operations/alg.partitions/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
is_partitioned.pass.cpp;
partition_copy.pass.cpp;
partition.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_is_partitioned.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_is_partitioned.cpp -------------------------------------------===// //===-- is_partitioned.pass.cpp -------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <functional>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_one_policy struct test_one_policy
{ {
//dummy specialization by policy type, in case of broken configuration //dummy specialization by policy type, in case of broken configuration
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
template <typename Iterator1, typename Predicate> template <typename Iterator1, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred) operator()(__pstl::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
{ {
} }
template <typename Iterator1, typename Predicate> template <typename Iterator1, typename Predicate>
void void
operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred) operator()(__pstl::execution::parallel_unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
{ {
} }
#endif #endif
template <typename ExecutionPolicy, typename Iterator1, typename Predicate> template <typename ExecutionPolicy, typename Iterator1, typename Predicate>
void void
operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Predicate pred) operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Predicate pred)
{ {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_partition.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_partition.cpp ------------------------------------------------===// //===-- partition.pass.cpp ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for stable_partition and partition // Tests for stable_partition and partition
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#include <iterator>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include <iterator> #include "support/parallel_utils.h"
#include <type_traits>
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct DataType struct DataType
{ {
explicit DataType(int32_t k) : my_val(k) {} explicit DataType(int32_t k) : my_val(k) {}
DataType(DataType&& input) { my_val = std::move(input.my_val); } DataType(DataType&& input) { my_val = std::move(input.my_val); }
DataType& DataType&
operator=(DataType&& input) operator=(DataType&& input)
Show All 32 Lines
} }
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specializations to skip testing in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specializations to skip testing in case of broken configuration
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
void void
operator()(pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, operator()(__pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
Size n, UnaryOp unary_op, Generator generator) Size n, UnaryOp unary_op, Generator generator)
{ {
} }
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
void void
operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, operator()(__pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator) BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
{ {
} }
#elif __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specializations to skip testing in case of broken configuration #elif __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specializations to skip testing in case of broken configuration
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
void void
operator()(pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, operator()(__pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
Size n, UnaryOp unary_op, Generator generator) Size n, UnaryOp unary_op, Generator generator)
{ {
} }
template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
void void
operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, operator()(__pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator) BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
{ {
} }
#endif #endif
template <typename Policy, typename BiDirIt, typename Size, typename UnaryOp, typename Generator> template <typename Policy, typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
typename std::enable_if<!is_same_iterator_category<BiDirIt, std::forward_iterator_tag>::value, void>::type typename std::enable_if<!is_same_iterator_category<BiDirIt, std::forward_iterator_tag>::value, void>::type
operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size n, operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size n,
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_partition_copy.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_partition_copy.cpp -------------------------------------------===// //===-- partition_copy.pass.cpp -------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for stable_partition and partition_copy // Tests for stable_partition and partition_copy
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#include <cstdlib>
#include <iterator>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include <cstdlib> #include "support/parallel_utils.h"
#include <iterator>
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_partition_copy struct test_partition_copy
{ {
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2,
typename UnaryOp> typename UnaryOp>
void void
operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator true_first, operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator true_first,
OutputIterator true_last, OutputIterator2 false_first, OutputIterator2 false_last, UnaryOp unary_op) 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); 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), EXPECT_TRUE(std::distance(true_first, actual_ret.first) == std::count_if(first, last, unary_op),
"partition_copy has wrong effect from true sequence"); "partition_copy has wrong effect from true sequence");
EXPECT_TRUE(std::distance(false_first, actual_ret.second) == EXPECT_TRUE(std::distance(false_first, actual_ret.second) ==
std::count_if(first, last, __pstl::internal::not_pred<UnaryOp>(unary_op)), std::count_if(first, last, __pstl::internal::not_pred<UnaryOp>(unary_op)),
"partition_copy has wrong effect from false sequence"); "partition_copy has wrong effect from false sequence");
} }
//dummy specialization by iterator type and policy type, in case of broken configuration //dummy specialization by iterator type and policy type, in case of broken configuration
#if __PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN #if __PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp>
void void
operator()(pstl::execution::unsequenced_policy, std::reverse_iterator<InputIterator> first, operator()(__pstl::execution::unsequenced_policy, std::reverse_iterator<InputIterator> first,
std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first, std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first,
std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first, std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first,
OutputIterator2 false_last, UnaryOp unary_op) OutputIterator2 false_last, UnaryOp unary_op)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp>
void void
operator()(pstl::execution::parallel_unsequenced_policy, std::reverse_iterator<InputIterator> first, operator()(__pstl::execution::parallel_unsequenced_policy, std::reverse_iterator<InputIterator> first,
std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first, std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first,
std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first, std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first,
OutputIterator2 false_last, UnaryOp unary_op) OutputIterator2 false_last, UnaryOp unary_op)
{ {
} }
#endif #endif
}; };
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/std/algorithms/alg.modifying.operations/alg.reverse/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
reverse.pass.cpp;
reverse_copy.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_reverse.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_reverse.cpp --------------------------------------------------===// //===-- reverse.pass.cpp --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <iterator> #include <iterator>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN || __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN || __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, operator()(__pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
Iterator2 actual_e) Iterator2 actual_e)
{ {
} }
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, operator()(__pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
Iterator2 actual_e) Iterator2 actual_e)
{ {
} }
#endif #endif
template <typename ExecutionPolicy, typename Iterator1, typename Iterator2> template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
typename std::enable_if<!is_same_iterator_category<Iterator1, std::forward_iterator_tag>::value>::type typename std::enable_if<!is_same_iterator_category<Iterator1, std::forward_iterator_tag>::value>::type
operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e) operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_reverse_copy.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_reverse_copy.cpp ---------------------------------------------===// //===-- reverse_copy.pass.cpp ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <iterator> #include <iterator>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct wrapper struct wrapper
{ {
T t; T t;
wrapper() {} wrapper() {}
explicit wrapper(T t_) : t(t_) {} explicit wrapper(T t_) : t(t_) {}
wrapper& wrapper&
Show All 31 Linesstruct test_one_policy
Iterator data_b; Iterator data_b;
Iterator data_e; Iterator data_e;
test_one_policy(Iterator b, Iterator e) : data_b(b), data_e(e) {} test_one_policy(Iterator b, Iterator e) : data_b(b), data_e(e) {}
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1> template <typename Iterator1>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e) operator()(__pstl::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
{ {
} }
template <typename Iterator1> template <typename Iterator1>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e) operator()(__pstl::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
{ {
} }
#endif #endif
template <typename ExecutionPolicy, typename Iterator1> template <typename ExecutionPolicy, typename Iterator1>
void void
operator()(ExecutionPolicy&& exec, Iterator1 actual_b, Iterator1 actual_e) operator()(ExecutionPolicy&& exec, Iterator1 actual_b, Iterator1 actual_e)
{ {
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_copy_move.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_copy_move.cpp ------------------------------------------------===// //===-- test_copy_move.cpp ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for copy, move and copy_n // Tests for copy, move and copy_n
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct run_copy struct run_copy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(__pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
Size n, T trash) Size n, T trash)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T>
void void
operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
OutputIterator2 expected_last, Size size, Size n, T trash) OutputIterator2 expected_last, Size size, Size n, T trash)
{ {
} }
#endif #endif
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename T> typename T>
Show All 28 Lines
template <typename T> template <typename T>
struct run_move struct run_move
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(__pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
Size n, T trash) Size n, T trash)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
OutputIterator2 expected_last, Size size, Size n, T trash) OutputIterator2 expected_last, Size size, Size n, T trash)
{ {
} }
#endif #endif
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
Show All 18 Lines
template <typename T> template <typename T>
struct run_move<Wrapper<T>> struct run_move<Wrapper<T>>
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(__pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
Size n, Wrapper<T> trash) Size n, Wrapper<T> trash)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
OutputIterator2 expected_last, Size size, Size n, Wrapper<T> trash) OutputIterator2 expected_last, Size size, Size n, Wrapper<T> trash)
{ {
} }
#endif #endif
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size> template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
void void
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_fill.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_fill.cpp -----------------------------------------------------===// //===-- test_fill.cpp -----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for fill/fill_n // Tests for fill/fill_n
// Tests for copy_if and remove_copy_if
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_fill struct test_fill
{ {
template <typename It, typename T> template <typename It, typename T>
bool bool
check(It first, It last, const T& value) check(It first, It last, const T& value)
{ {
for (; first != last; ++first) for (; first != last; ++first)
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_generate.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_generate.cpp -------------------------------------------------===// //===-- test_generate.cpp -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for generate // Tests for generate
#include <atomic> #include "support/pstl_test_config.h"
#include <atomic>
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct Generator_count struct Generator_count
{ {
const T def_val = T(-1); const T def_val = T(-1);
T T
operator()() operator()()
{ {
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_remove.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_remove.cpp ---------------------------------------------------===// //===-- remove.pass.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Test for remove, remove_if // Test for remove, remove_if
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct run_remove struct run_remove
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename Size, typename T> template <typename InputIterator, typename OutputIterator, typename Size, typename T>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_remove_copy.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_remove_copy.cpp ----------------------------------------------===// //===-- remove_copy.pass.cpp ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for remove_copy // Tests for remove_copy
// Tests for copy_if and remove_copy_if
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct run_remove_copy struct run_remove_copy
{ {
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename T> typename T>
void void
operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_replace.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_replace.cpp --------------------------------------------------===// //===-- test_replace.cpp --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" // Tests for copy_if and remove_copy_if
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
// This class is needed to check the self-copying // This class is needed to check the self-copying
struct copy_int struct copy_int
{ {
int32_t value; int32_t value;
int32_t copied_times = 0; int32_t copied_times = 0;
explicit copy_int(int32_t val = 0) { value = val; } explicit copy_int(int32_t val = 0) { value = val; }
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_replace_copy.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_replace_copy.cpp ---------------------------------------------===// //===-- replace_copy.pass.cpp ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for replace_copy and replace_copy_if // Tests for replace_copy and replace_copy_if
#include "pstl_test_config.h" // Tests for copy_if and remove_copy_if
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_replace_copy struct test_replace_copy
{ {
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
void void
operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_rotate.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_rotate.cpp ---------------------------------------------------===// //===-- rotate.pass.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <iterator> #include <iterator>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct wrapper struct wrapper
{ {
T t; T t;
int move_count; int move_count;
explicit wrapper(T t_) : t(t_), move_count(0) {} explicit wrapper(T t_) : t(t_), move_count(0) {}
wrapper& wrapper&
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specializations to skip testing in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specializations to skip testing in case of broken configuration
template <typename Iterator, typename Size> template <typename Iterator, typename Size>
void void
operator()(pstl::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b, operator()(__pstl::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
Iterator actual_e, Size shift) Iterator actual_e, Size shift)
{ {
} }
template <typename Iterator, typename Size> template <typename Iterator, typename Size>
void void
operator()(pstl::execution::parallel_unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b, operator()(__pstl::execution::parallel_unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
Iterator actual_e, Size shift) Iterator actual_e, Size shift)
{ {
} }
#endif #endif
template <typename ExecutionPolicy, typename Iterator, typename Size> template <typename ExecutionPolicy, typename Iterator, typename Size>
void void
operator()(ExecutionPolicy&& exec, Iterator data_b, Iterator data_e, Iterator actual_b, Iterator actual_e, operator()(ExecutionPolicy&& exec, Iterator data_b, Iterator data_e, Iterator actual_b, Iterator actual_e,
Show All 13 Lines operator()(ExecutionPolicy&& exec, Iterator data_b, Iterator data_e, Iterator actual_b, Iterator actual_e,
EXPECT_TRUE(check, "wrong effect of rotate"); EXPECT_TRUE(check, "wrong effect of rotate");
EXPECT_TRUE(check_move(exec, actual_b, actual_e, shift), "wrong move test of rotate"); EXPECT_TRUE(check_move(exec, actual_b, actual_e, shift), "wrong move test of rotate");
} }
template <typename ExecutionPolicy, typename Iterator, typename Size> template <typename ExecutionPolicy, typename Iterator, typename Size>
typename std::enable_if< typename std::enable_if<
is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value && is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
!std::is_same<ExecutionPolicy, pstl::execution::sequenced_policy>::value && !std::is_same<ExecutionPolicy, __pstl::execution::sequenced_policy>::value &&
std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value, std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value,
bool>::type bool>::type
check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift) check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift)
{ {
bool result = all_of(b, e, [](wrapper<float32_t>& a) { bool result = all_of(b, e, [](wrapper<float32_t>& a) {
bool temp = a.move_count > 0; bool temp = a.move_count > 0;
a.move_count = 0; a.move_count = 0;
return temp; return temp;
}); });
return shift == 0 || result; return shift == 0 || result;
} }
template <typename ExecutionPolicy, typename Iterator, typename Size> template <typename ExecutionPolicy, typename Iterator, typename Size>
typename std::enable_if< typename std::enable_if<
!(is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value && !(is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
!std::is_same<ExecutionPolicy, pstl::execution::sequenced_policy>::value && !std::is_same<ExecutionPolicy, __pstl::execution::sequenced_policy>::value &&
std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value), std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value),
bool>::type bool>::type
check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift) check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift)
{ {
return true; return true;
} }
}; };
Show All 32 Lines

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

  • This file was moved from test/test_rotate_copy.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_rotate_copy.cpp ----------------------------------------------===// //===-- rotate_copy.pass.cpp ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <iterator> #include <iterator>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct wrapper; struct wrapper;
template <typename T> template <typename T>
bool bool
compare(const wrapper<T>& a, const wrapper<T>& b) compare(const wrapper<T>& a, const wrapper<T>& b)
{ {
Show All 39 Lines
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, operator()(__pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
Iterator2 actual_e, std::size_t shift) Iterator2 actual_e, std::size_t shift)
{ {
} }
template <typename Iterator1, typename Iterator2> template <typename Iterator1, typename Iterator2>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, operator()(__pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
Iterator2 actual_e, std::size_t shift) Iterator2 actual_e, std::size_t shift)
{ {
} }
#endif #endif
template <typename ExecutionPolicy, typename Iterator1, typename Iterator2> template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
void void
operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e, operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e,
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_swap_ranges.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_swap_ranges.cpp ----------------------------------------------===// //===-- swap_ranges.pass.cpp ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <iterator> #include <iterator>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct wrapper struct wrapper
{ {
T t; T t;
std::size_t number_of_swaps = 0; std::size_t number_of_swaps = 0;
wrapper() {} wrapper() {}
explicit wrapper(T t_) : t(t_) {} explicit wrapper(T t_) : t(t_) {}
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_transform_binary.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_transform_binary.cpp -----------------------------------------===// //===-- transform_binary.pass.cpp -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename In1, typename In2, typename Out> template <typename In1, typename In2, typename Out>
class TheOperation class TheOperation
{ {
Out val; Out val;
public: public:
TheOperation(Out v) : val(v) {} TheOperation(Out v) : val(v) {}
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_transform_unary.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_transform_unary.cpp ------------------------------------------===// //===-- transform_unary.pass.cpp ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
void void
check_and_reset(InputIterator first, InputIterator last, OutputIterator out_first) check_and_reset(InputIterator first, InputIterator last, OutputIterator out_first)
{ {
typedef typename std::iterator_traits<OutputIterator>::value_type Out; typedef typename std::iterator_traits<OutputIterator>::value_type Out;
typename std::iterator_traits<OutputIterator>::difference_type k = 0; typename std::iterator_traits<OutputIterator>::difference_type k = 0;
for (; first != last; ++first, ++out_first, ++k) for (; first != last; ++first, ++out_first, ++k)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_unique.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_unique.cpp ---------------------------------------------------===// //===-- unique.pass.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Test for unique // Test for unique
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct run_unique struct run_unique
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename ForwardIt, typename Generator> template <typename ForwardIt, typename Generator>
void void
operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, operator()(__pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
ForwardIt last2, Generator generator) ForwardIt last2, Generator generator)
{ {
} }
template <typename ForwardIt, typename Generator> template <typename ForwardIt, typename Generator>
void void
operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, operator()(__pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
ForwardIt last2, Generator generator) ForwardIt last2, Generator generator)
{ {
} }
template <typename ForwardIt, typename BinaryPred, typename Generator> template <typename ForwardIt, typename BinaryPred, typename Generator>
void void
operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, operator()(__pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
ForwardIt last2, BinaryPred pred, Generator generator) ForwardIt last2, BinaryPred pred, Generator generator)
{ {
} }
template <typename ForwardIt, typename BinaryPred, typename Generator> template <typename ForwardIt, typename BinaryPred, typename Generator>
void void
operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2, operator()(__pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
ForwardIt last2, BinaryPred pred, Generator generator) ForwardIt last2, BinaryPred pred, Generator generator)
{ {
} }
#endif #endif
template <typename Policy, typename ForwardIt, typename Generator> template <typename Policy, typename ForwardIt, typename Generator>
void void
operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, Generator generator) operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, Generator generator)
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_unique_copy_equal.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_unique_copy_equal.cpp ----------------------------------------===// //===-- unique_copy_equal.pass.cpp ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for unique_copy // Tests for unique_copy that uses == as equivalence relationship
#include "pstl_test_config.h" // Tests for copy_if and remove_copy_if
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct run_unique_copy struct run_unique_copy
{ {
#if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration #if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
void void
operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first, operator()(__pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
Predicate pred, T trash) Predicate pred, T trash)
{ {
} }
template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
void void
operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first, OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
OutputIterator2 expected_last, Size n, Predicate pred, T trash) OutputIterator2 expected_last, Size n, Predicate pred, T trash)
{ {
} }
#endif #endif
template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
typename Predicate, typename T> typename Predicate, typename T>
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/std/algorithms/alg.nonmodifying/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
adjacent_find.pass.cpp
all_of.pass.cpp;
any_of.pass.cpp;
count.pass.cpp;
equal.pass.cpp;
find.pass.cpp;
find_end.pass.cpp;
find_first_of.pass.cpp;
find_if.pass.cpp;
for_each.pass.cpp;
mismatch.pass.cpp;
none_of.pass.cpp;
nth_element.pass.cpp;
search_n.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_adjacent_find.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_adjacent_find.cpp --------------------------------------------===// //===-- adjacent_find.pass.cpp --------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for adjacent_find // Tests for adjacent_find
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_adjacent_find struct test_adjacent_find
{ {
template <typename Policy, typename Iterator, typename Pred> template <typename Policy, typename Iterator, typename Pred>
void void
operator()(Policy&& exec, Iterator first, Iterator last, Pred pred) operator()(Policy&& exec, Iterator first, Iterator last, Pred pred)
{ {
using namespace std; using namespace std;
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_all_of.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_all_of.cpp ---------------------------------------------------===// //===-- test_all_of.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" // UNSUPPORTED: c++98, c++03, c++11, c++14
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
/* /*
TODO: consider implementing the following tests for a better code coverage TODO: consider implementing the following tests for a better code coverage
- correctness - correctness
- bad input argument (if applicable) - bad input argument (if applicable)
- data corruption around/of input and output - data corruption around/of input and output
- correctly work with nested parallelism - correctly work with nested parallelism
- check that algorithm does not require anything more than is described in its requirements section - check that algorithm does not require anything more than is described in its requirements section
*/ */
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_all_of struct test_all_of
{ {
template <typename ExecutionPolicy, typename Iterator, typename Predicate> template <typename ExecutionPolicy, typename Iterator, typename Predicate>
void void
operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected) operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected)
{ {
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_any_of.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_any_of.cpp ---------------------------------------------------===// //===-- any_of.pass.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
/* /*
TODO: consider implementing the following tests for a better code coverage TODO: consider implementing the following tests for a better code coverage
- correctness - correctness
- bad input argument (if applicable) - bad input argument (if applicable)
- data corruption around/of input and output - data corruption around/of input and output
- correctly work with nested parallelism - correctly work with nested parallelism
- check that algorithm does not require anything more than is described in its requirements section - check that algorithm does not require anything more than is described in its requirements section
*/ */
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_any_of struct test_any_of
{ {
template <typename ExecutionPolicy, typename Iterator, typename Predicate> template <typename ExecutionPolicy, typename Iterator, typename Predicate>
void void
operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected) operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected)
{ {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_count.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_count.cpp ----------------------------------------------------===// //===-- test_count.cpp ----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for count and count_if // Tests for count and count_if
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_count struct test_count
{ {
template <typename Policy, typename Iterator, typename T> template <typename Policy, typename Iterator, typename T>
void void
operator()(Policy&& exec, Iterator first, Iterator last, T needle) operator()(Policy&& exec, Iterator first, Iterator last, T needle)
{ {
auto expected = std::count(first, last, needle); auto expected = std::count(first, last, needle);
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_equal.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_equal.cpp ----------------------------------------------------===// //===-- equal.pass.cpp ----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
#define CPP14_ENABLED 0 #define CPP14_ENABLED 0
struct UserType struct UserType
{ {
float32_t f; float32_t f;
float64_t d; float64_t d;
int32_t i; int32_t i;
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_find.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_find.cpp -----------------------------------------------------===// //===-- find.pass.cpp -----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for find // Tests for find
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
struct test_find using namespace Parallel_TestUtils;
{
struct test_find {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Value> template <typename Iterator, typename Value>
void void
operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Value value) operator()(__pstl::execution::unsequenced_policy, Iterator first, Iterator last, Value value)
{ {
} }
template <typename Iterator, typename Value> template <typename Iterator, typename Value>
void void
operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value) operator()(__pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value)
{ {
} }
#endif #endif
template <typename Policy, typename Iterator, typename Value> template <typename Policy, typename Iterator, typename Value>
void void
operator()(Policy&& exec, Iterator first, Iterator last, Value value) operator()(Policy&& exec, Iterator first, Iterator last, Value value)
{ {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_find_end.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_find_end.cpp -------------------------------------------------===// //===-- test_find_end.cpp -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2, typename Predicate> template <typename Iterator1, typename Iterator2, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_find_first_of.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_find_first_of.cpp --------------------------------------------===// //===-- find_first_of.pass.cpp --------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Iterator2, typename Predicate> template <typename Iterator1, typename Iterator2, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_find_if.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_find_if.cpp --------------------------------------------------===// //===-- find_if.pass.cpp --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for find_if and find_if_not // Tests for find_if and find_if_not
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_find_if struct test_find_if
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Predicate, typename NotPredicate> template <typename Iterator, typename Predicate, typename NotPredicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred, operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred,
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_for_each.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_for_each.cpp -------------------------------------------------===// //===-- for_each.pass.cpp -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; #include <iostream>
using namespace Parallel_TestUtils;
template <typename Type> template <typename Type>
struct Gen struct Gen
{ {
Type Type
operator()(std::size_t k) operator()(std::size_t k)
{ {
return Type(k % 5 != 1 ? 3 * k - 7 : 0); return Type(k % 5 != 1 ? 3 * k - 7 : 0);
Show All 16 Lines
{ {
template <typename Policy, typename Iterator, typename Size> template <typename Policy, typename Iterator, typename Size>
void void
operator()(Policy&& exec, Iterator first, Iterator last, Iterator expected_first, Iterator expected_last, Size n) operator()(Policy&& exec, Iterator first, Iterator last, Iterator expected_first, Iterator expected_last, Size n)
{ {
typedef typename std::iterator_traits<Iterator>::value_type T; typedef typename std::iterator_traits<Iterator>::value_type T;
// Try for_each // Try for_each
std::for_each(expected_first, expected_last, Flip<T>(1)); std::for_each(__pstl::execution::seq, expected_first, expected_last, Flip<T>(1));
for_each(exec, first, last, Flip<T>(1)); for_each(exec, first, last, Flip<T>(1));
EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each"); EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each");
// Try for_each_n // Try for_each_n
std::for_each_n(pstl::execution::seq, expected_first, n, Flip<T>(1)); std::for_each_n(__pstl::execution::seq, expected_first, n, Flip<T>(1));
std::for_each_n(__pstl::execution::seq, expected_first, n, Flip<T>(1));
for_each_n(exec, first, n, Flip<T>(1)); for_each_n(exec, first, n, Flip<T>(1));
EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each_n"); EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each_n");
} }
}; };
template <typename T> template <typename T>
void void
test() test()
{ {
for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n)) for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
{ {
Sequence<T> inout(n, Gen<T>()); Sequence<T> inout(n, Gen<T>());
Sequence<T> expected(n, Gen<T>()); Sequence<T> expected(n, Gen<T>());
Show All 32 Lines

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

  • This file was moved from test/test_mismatch.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_mismatch.cpp -------------------------------------------------===// //===-- mismatch.pass.cpp -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for the rest algorithms; temporary approach to check compiling // test mismatch
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "pstl/numeric" #else
#include "pstl/memory" #include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "utils.h" #include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_mismatch struct test_mismatch
{ {
template <typename Policy, typename Iterator1, typename Iterator2> template <typename Policy, typename Iterator1, typename Iterator2>
void void
operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2) operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2)
{ {
using namespace std; using namespace std;
typedef typename iterator_traits<Iterator1>::value_type T; typedef typename iterator_traits<Iterator1>::value_type T;
{ {
const auto expected = std::mismatch(first1, last1, first2, std::equal_to<T>()); const auto expected = std::mismatch(first1, last1, first2, std::equal_to<T>());
const auto res3 = mismatch(exec, first1, last1, first2, std::equal_to<T>()); const auto res3 = mismatch(exec, first1, last1, first2, std::equal_to<T>());
EXPECT_TRUE(expected == res3, "wrong return result from mismatch"); EXPECT_TRUE(expected == res3, "wrong return result from mismatch");
const auto res4 = mismatch(exec, first1, last1, first2); const auto res4 = mismatch(exec, first1, last1, first2);
EXPECT_TRUE(expected == res4, "wrong return result from mismatch"); EXPECT_TRUE(expected == res4, "wrong return result from mismatch");
} }
} }
template <typename Policy, typename Iterator1, typename Iterator2> template <typename Policy, typename Iterator1, typename Iterator2>
void void
operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2) operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
{ {
using namespace std; using namespace std;
typedef typename iterator_traits<Iterator1>::value_type T; typedef typename iterator_traits<Iterator1>::value_type T;
{ {
const auto expected = mismatch(pstl::execution::seq, first1, last1, first2, last2, std::equal_to<T>()); const auto expected = mismatch(__pstl::execution::seq, first1, last1, first2, last2, std::equal_to<T>());
const auto res1 = mismatch(exec, first1, last1, first2, last2, std::equal_to<T>()); const auto res1 = mismatch(exec, first1, last1, first2, last2, std::equal_to<T>());
EXPECT_TRUE(expected == res1, "wrong return result from mismatch"); EXPECT_TRUE(expected == res1, "wrong return result from mismatch");
const auto res2 = mismatch(exec, first1, last1, first2, last2); const auto res2 = mismatch(exec, first1, last1, first2, last2);
EXPECT_TRUE(expected == res2, "wrong return result from mismatch"); EXPECT_TRUE(expected == res2, "wrong return result from mismatch");
} }
} }
}; };
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_none_of.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_none_of.cpp --------------------------------------------------===// //===-- none_of.pass.cpp --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
/* /*
TODO: consider implementing the following tests for a better code coverage TODO: consider implementing the following tests for a better code coverage
- correctness - correctness
- bad input argument (if applicable) - bad input argument (if applicable)
- data corruption around/of input and output - data corruption around/of input and output
- correctly work with nested parallelism - correctly work with nested parallelism
- check that algorithm does not require anything more than is described in its requirements section - check that algorithm does not require anything more than is described in its requirements section
*/ */
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_none_of struct test_none_of
{ {
template <typename ExecutionPolicy, typename Iterator, typename Predicate> template <typename ExecutionPolicy, typename Iterator, typename Predicate>
void void
operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected) operator()(ExecutionPolicy&& exec, Iterator begin, Iterator end, Predicate pred, bool expected)
{ {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_nth_element.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_nth_element.cpp ----------------------------------------------===// //===-- nth_element.pass.cpp ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <algorithm> #ifdef PSTL_STANDALONE_TESTS
#include <iostream>
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "utils.h" #include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
// User defined type with minimal requirements // User defined type with minimal requirements
template <typename T> template <typename T>
struct DataType struct DataType
{ {
explicit DataType(int32_t k) : my_val(k) {} explicit DataType(int32_t k) : my_val(k) {}
DataType(DataType&& input) DataType(DataType&& input)
{ {
Show All 38 Lines
} }
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2, operator()(__pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
{ {
} }
template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare> template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2, operator()(__pstl::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp) Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
{ {
} }
#endif #endif
// nth_element works only with random access iterators // nth_element works only with random access iterators
template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2, template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
typename Compare> typename Compare>
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_search_n.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_search_n.cpp -------------------------------------------------===// //===-- search.pass.cpp -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_one_policy struct test_one_policy
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Size, typename T, typename Predicate> template <typename Iterator, typename Size, typename T, typename Predicate>
void void
operator()(pstl::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred) operator()(pstl::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred)
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/std/algorithms/alg.sorting/CMakeLists.txt

  • This file was added.
add_subdirectory(alg.heap.operations)
add_subdirectory(alg.lex.comparison)
add_subdirectory(alg.min.max)
add_subdirectory(alg.set.operations)
set(PASS_SOURCES
is_sorted.pass.cpp;
partial_sort.pass.cpp;
partial_sort_copy.pass.cpp;
sort.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

test/std/algorithms/alg.sorting/alg.heap.operations/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
is_heap.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_is_heap.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_is_heap.cpp --------------------------------------------------===// //===-- test_is_heap.cpp --------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for is_heap, is_heap_until // Tests for is_heap, is_heap_until
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <functional>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <iostream> #include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct WithCmpOp struct WithCmpOp
{ {
int32_t _first; int32_t _first;
int32_t _second; int32_t _second;
WithCmpOp() : _first(0), _second(0){}; WithCmpOp() : _first(0), _second(0){};
explicit WithCmpOp(int32_t x) : _first(x), _second(x){}; explicit WithCmpOp(int32_t x) : _first(x), _second(x){};
bool bool
operator<(const WithCmpOp& rhs) const operator<(const WithCmpOp& rhs) const
{ {
return this->_first < rhs._first; return this->_first < rhs._first;
} }
}; };
struct test_is_heap struct test_is_heap
{ {
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator, typename Predicate> template <typename Iterator, typename Predicate>
typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred) operator()(__pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred)
{ {
} }
template <typename Iterator, typename Predicate> template <typename Iterator, typename Predicate>
typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred) operator()(__pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred)
{ {
} }
#endif #endif
template <typename Policy, typename Iterator, typename Predicate> template <typename Policy, typename Iterator, typename Predicate>
typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred) operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred)
{ {
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/std/algorithms/alg.sorting/alg.lex.comparison/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
lexicographical_compare.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_lexicographical_compare.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_lexicographical_compare.cpp ----------------------------------===// //===-- lexicographical_compare.pass.cpp ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <string>
#include <iostream>
#include <string>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_one_policy struct test_one_policy
{ {
template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate> template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate>
void void
operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Iterator2 begin2, Iterator2 end2, operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Iterator2 begin2, Iterator2 end2,
Predicate pred) Predicate pred)
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

test/std/algorithms/alg.sorting/alg.min.max/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
minmax_element.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp

  • This file was moved from test/test_minmax_element.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_minmax_element.cpp -------------------------------------------===// //===-- minmax_element.pass.cpp -------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for min_element, max_element, minmax_element // Tests for min_element, max_element, minmax_element
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
#include <set> #include <set>
#include <cassert> #include <cassert>
#include <cmath> #include <cmath>
using namespace TestUtils; using namespace Parallel_TestUtils;
struct check_minelement struct check_minelement
{ {
template <typename Policy, typename Iterator> template <typename Policy, typename Iterator>
void void
operator()(Policy&& exec, Iterator begin, Iterator end) operator()(Policy&& exec, Iterator begin, Iterator end)
{ {
typedef typename std::iterator_traits<Iterator>::value_type T; typedef typename std::iterator_traits<Iterator>::value_type T;
Show All 34 Lines operator()(Policy&& exec, Iterator begin, Iterator end)
EXPECT_TRUE(expect.second == got.second, "wrong return result from minmax_element (max 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"); EXPECT_TRUE(expect == got_pred, "wrong return result from minmax_element");
} }
}; };
template <typename T> template <typename T>
struct sequence_wrapper struct sequence_wrapper
{ {
TestUtils::Sequence<T> seq; Parallel_TestUtils::Sequence<T> seq;
const T min_value; const T min_value;
const T max_value; const T max_value;
static const std::size_t bits = 30; // We assume that T can handle signed 2^bits+1 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<<bits)-1, // Parallel_TestUtils::HashBits returns value between 0 and (1<<bits)-1,
// therefore we could threat 1<<bits as maximum and -(1<<bits) as a minimum // therefore we could threat 1<<bits as maximum and -(1<<bits) as a minimum
sequence_wrapper(std::size_t n) : seq(n), min_value(-(1 << bits)), max_value(1 << bits) {} sequence_wrapper(std::size_t n) : seq(n), min_value(-(1 << bits)), max_value(1 << bits) {}
void void
pattern_fill() pattern_fill()
{ {
seq.fill([](std::size_t i) -> T { return T(TestUtils::HashBits(i, bits)); }); seq.fill([](std::size_t i) -> T { return T(Parallel_TestUtils::HashBits(i, bits)); });
} }
// sets first one at position `at` and bunch of them farther // sets first one at position `at` and bunch of them farther
void void
set_desired_value(std::size_t at, T value) set_desired_value(std::size_t at, T value)
{ {
if (seq.size() == 0) if (seq.size() == 0)
return; return;
seq[at] = value; seq[at] = value;
//Producing serveral red herrings //Producing serveral red herrings
for (std::size_t i = at + 1; i < seq.size(); i += 1 + TestUtils::HashBits(i, 5)) for (std::size_t i = at + 1; i < seq.size(); i += 1 + Parallel_TestUtils::HashBits(i, 5))
seq[i] = value; seq[i] = value;
} }
}; };
template <typename T> template <typename T>
void void
test_by_type(std::size_t n) test_by_type(std::size_t n)
{ {
Show All 9 Lines if (n > 1)
targets.insert(n / 7.389056); targets.insert(n / 7.389056);
targets.insert(n - 1); // last targets.insert(n - 1); // last
} }
for (std::set<std::size_t>::iterator it = targets.begin(); it != targets.end(); ++it) for (std::set<std::size_t>::iterator it = targets.begin(); it != targets.end(); ++it)
{ {
wseq.pattern_fill(); wseq.pattern_fill();
wseq.set_desired_value(*it, wseq.min_value); wseq.set_desired_value(*it, wseq.min_value);
TestUtils::invoke_on_all_policies(check_minelement(), wseq.seq.cbegin(), wseq.seq.cend()); Parallel_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()); Parallel_TestUtils::invoke_on_all_policies(check_minelement(), wseq.seq.begin(), wseq.seq.end());
wseq.set_desired_value(*it, wseq.max_value); wseq.set_desired_value(*it, wseq.max_value);
TestUtils::invoke_on_all_policies(check_maxelement(), wseq.seq.cbegin(), wseq.seq.cend()); Parallel_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()); Parallel_TestUtils::invoke_on_all_policies(check_maxelement(), wseq.seq.begin(), wseq.seq.end());
if (targets.size() > 1) if (targets.size() > 1)
{ {
for (std::set<std::size_t>::reverse_iterator rit = targets.rbegin(); rit != targets.rend(); ++rit) for (std::set<std::size_t>::reverse_iterator rit = targets.rbegin(); rit != targets.rend(); ++rit)
{ {
if (*rit == *it) // we requires at least 2 unique indexes in targets if (*rit == *it) // we requires at least 2 unique indexes in targets
break; break;
wseq.pattern_fill(); wseq.pattern_fill();
wseq.set_desired_value(*it, wseq.min_value); // setting minimum element wseq.set_desired_value(*it, wseq.min_value); // setting minimum element
wseq.set_desired_value(*rit, wseq.max_value); // setting maximum 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()); Parallel_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()); Parallel_TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.begin(), wseq.seq.end());
} }
} }
else else
{ // we must check this corner case; it can not be tested in loop above { // 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()); Parallel_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()); Parallel_TestUtils::invoke_on_all_policies(check_minmaxelement(), wseq.seq.begin(), wseq.seq.end());
} }
} }
} }
// should provide minimal requirements only // should provide minimal requirements only
struct OnlyLessCompare struct OnlyLessCompare
{ {
int32_t val; int32_t val;
Show All 17 Lines operator()(Policy&& exec, Iterator iter)
min_element(exec, iter, iter, non_const(std::less<T>())); min_element(exec, iter, iter, non_const(std::less<T>()));
minmax_element(exec, iter, iter, non_const(std::less<T>())); minmax_element(exec, iter, iter, non_const(std::less<T>()));
} }
}; };
int32_t int32_t
main() main()
{ {
using TestUtils::float64_t; using Parallel_TestUtils::float64_t;
const std::size_t N = 100000; const std::size_t N = 100000;
for (std::size_t n = 0; n < N; n = n < 16 ? n + 1 : size_t(3.14159 * n)) for (std::size_t n = 0; n < N; n = n < 16 ? n + 1 : size_t(3.14159 * n))
{ {
test_by_type<float64_t>(n); test_by_type<float64_t>(n);
test_by_type<OnlyLessCompare>(n); test_by_type<OnlyLessCompare>(n);
} }
test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>()); test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
std::cout << TestUtils::done() << std::endl; std::cout << Parallel_TestUtils::done() << std::endl;
return 0; return 0;
} }

test/std/algorithms/alg.sorting/alg.set.operations/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
includes.pass.cpp;
set.pass.cpp;
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

test/std/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp

  • This file was moved from test/test_includes.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_includes.cpp -------------------------------------------------===// //===-- includes.pass.cpp -------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for partial_sort // Tests for partial_sort
#include <cmath>
#include "support/pstl_test_config.h"
#include <cmath>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct Num struct Num
{ {
T val; T val;
explicit Num(const T& v) : val(v) {} explicit Num(const T& v) : val(v) {}
//for "includes" checks //for "includes" checks
Show All 10 Linesstruct Num
{ {
return Num<T1>((T1)val); return Num<T1>((T1)val);
} }
}; };
struct test_one_policy struct test_one_policy
{ {
template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare> template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
typename std::enable_if<!TestUtils::isReverse<InputIterator1>::value, void>::type typename std::enable_if<!Parallel_TestUtils::isReverse<InputIterator1>::value, void>::type
operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
Compare comp) Compare comp)
{ {
auto expect_res = std::includes(first1, last1, first2, last2, comp); auto expect_res = std::includes(first1, last1, first2, last2, comp);
auto res = std::includes(exec, first1, last1, first2, last2, comp); auto res = std::includes(exec, first1, last1, first2, last2, comp);
EXPECT_TRUE(expect_res == res, "wrong result for includes"); EXPECT_TRUE(expect_res == res, "wrong result for includes");
} }
template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare> template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
typename std::enable_if<TestUtils::isReverse<InputIterator1>::value, void>::type typename std::enable_if<Parallel_TestUtils::isReverse<InputIterator1>::value, void>::type
operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
Compare comp) Compare comp)
{ {
} }
}; };
template <typename T1, typename T2, typename Compare> template <typename T1, typename T2, typename Compare>
void void
Show All 39 Lines

test/std/algorithms/alg.sorting/alg.set.operations/set.pass.cpp

  • This file was moved from test/test_set.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_set.cpp ------------------------------------------------------===// //===-- set.pass.cpp ------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for partial_sort // Tests for partial_sort
#include "support/pstl_test_config.h"
#include <cmath> #include <cmath>
#include <chrono> #include <chrono>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct Num struct Num
{ {
T val; T val;
Num() : val{} {} Num() : val{} {}
Num(const T& v) : val(v) {} Num(const T& v) : val(v) {}
Show All 18 Linesstruct Num
{ {
return v1.val == v2.val; return v1.val == v2.val;
} }
}; };
struct test_one_policy struct test_one_policy
{ {
template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare> template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
typename std::enable_if<!TestUtils::isReverse<InputIterator1>::value, void>::type typename std::enable_if<!Parallel_TestUtils::isReverse<InputIterator1>::value, void>::type
operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
Compare comp) Compare comp)
{ {
using T1 = typename std::iterator_traits<InputIterator1>::value_type; using T1 = typename std::iterator_traits<InputIterator1>::value_type;
auto n1 = std::distance(first1, last1); auto n1 = std::distance(first1, last1);
auto n2 = std::distance(first2, last2); auto n2 = std::distance(first2, last2);
auto n = n1 + n2; auto n = n1 + n2;
Show All 26 Lines operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
res = std::set_symmetric_difference(exec, first1, last1, first2, last2, out.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_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), EXPECT_EQ_N(expect.begin(), out.begin(), std::distance(out.begin(), res),
"wrong set_symmetric_difference effect"); "wrong set_symmetric_difference effect");
} }
template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare> template <typename Policy, typename InputIterator1, typename InputIterator2, typename Compare>
typename std::enable_if<TestUtils::isReverse<InputIterator1>::value, void>::type typename std::enable_if<Parallel_TestUtils::isReverse<InputIterator1>::value, void>::type
operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
Compare comp) Compare comp)
{ {
} }
}; };
template <typename T1, typename T2, typename Compare> template <typename T1, typename T2, typename Compare>
void void
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_is_sorted.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_is_sorted.cpp ------------------------------------------------===// //===-- test_is_sorted.cpp ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for is_sorted, is_sorted_until // Tests for is_sorted, is_sorted_until
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_is_sorted struct test_is_sorted
{ {
template <typename Policy, typename Iterator> template <typename Policy, typename Iterator>
void void
operator()(Policy&& exec, Iterator first, Iterator last, bool exam) operator()(Policy&& exec, Iterator first, Iterator last, bool exam)
{ {
using namespace std; using namespace std;
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_partial_sort.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_partial_sort.cpp ---------------------------------------------===// //===-- partial_sort.pass.cpp ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for partial_sort // Tests for partial_sort
#include <cmath> // Tests for copy_if and remove_copy_if
#include "support/pstl_test_config.h"
#include <cmath>
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
static std::atomic<int32_t> count_val; static std::atomic<int32_t> count_val;
static std::atomic<int32_t> count_comp; static std::atomic<int32_t> count_comp;
template <typename T> template <typename T>
struct Num struct Num
{ {
T val; T val;
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_partial_sort_copy.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_partial_sort_copy.cpp ----------------------------------------===// //===-- partial_sort_copy.pass.cpp ----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for partial_sort_copy // Tests for partial_sort_copy
#include <cmath> #include "support/pstl_test_config.h"
#include "pstl_test_config.h"
#include <cmath>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct Num struct Num
{ {
T val; T val;
Num() : val(0) {} Num() : val(0) {}
Num(T v) : val(v) {} Num(T v) : val(v) {}
Show All 24 Linesstruct test_one_policy
test_one_policy(RandomAccessIterator b1, RandomAccessIterator e1, RandomAccessIterator b2, RandomAccessIterator e2) test_one_policy(RandomAccessIterator b1, RandomAccessIterator e1, RandomAccessIterator b2, RandomAccessIterator e2)
: d_first(b1), d_last(e1), exp_first(b2), exp_last(e2) : d_first(b1), d_last(e1), exp_first(b2), exp_last(e2)
{ {
} }
#if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \ #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
__PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
template <typename InputIterator, typename Size, typename T, typename Compare> template <typename InputIterator, typename Size, typename T, typename Compare>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, operator()(__pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
const T& trash, Compare compare) const T& trash, Compare compare)
{ {
} }
template <typename InputIterator, typename Size, typename T, typename Compare> template <typename InputIterator, typename Size, typename T, typename Compare>
void void
operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
const T& trash, Compare compare) const T& trash, Compare compare)
{ {
} }
template <typename InputIterator, typename Size, typename T> template <typename InputIterator, typename Size, typename T>
void void
operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, operator()(__pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
const T& trash) const T& trash)
{ {
} }
template <typename InputIterator, typename Size, typename T> template <typename InputIterator, typename Size, typename T>
void void
operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2, operator()(__pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
const T& trash) const T& trash)
{ {
} }
#endif #endif
template <typename Policy, typename InputIterator, typename Size, typename T, typename Compare> template <typename Policy, typename InputIterator, typename Size, typename T, typename Compare>
void void
operator()(Policy&& exec, InputIterator first, InputIterator last, Size n1, Size n2, const T& trash, operator()(Policy&& exec, InputIterator first, InputIterator last, Size n1, Size n2, const T& trash,
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_sort.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_sort.cpp -----------------------------------------------------===// //===-- test_sort.cpp -----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for sort and stable_sort // Tests for sort and stable_sort
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm" #include "pstl/algorithm"
#include "utils.h" #else
#include <execution>
#include <algorithm>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
#define _CRT_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS
#include <atomic> #include <atomic>
static bool Stable; static bool Stable;
//! Number of extant keys //! Number of extant keys
static std::atomic<int32_t> KeyCount; static std::atomic<int32_t> KeyCount;
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

test/std/numerics/CMakeLists.txt

  • This file was added.
add_subdirectory(numeric.ops)

test/std/numerics/numeric.ops/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
adjacent_difference.pass.cpp
reduce.pass.cpp
scan.pass.cpp
transform_reduce.pass.cpp
transform_scan.pass.cpp
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_adjacent_difference.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_adjacent_difference.cpp --------------------------------------===// //===-- adjacent_difference.pass.cpp --------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <iterator>
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/algorithm"
#include "pstl/numeric" #include "pstl/numeric"
#include "utils.h" #else
#include <execution>
#include <numeric>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
template <typename T> template <typename T>
struct wrapper struct wrapper
{ {
T t; T t;
explicit wrapper(T t_) : t(t_) {} explicit wrapper(T t_) : t(t_) {}
template <typename T2> template <typename T2>
wrapper(const wrapper<T2>& a) wrapper(const wrapper<T2>& a)
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_reduce.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_reduce.cpp ---------------------------------------------------===// //===-- reduce.pass.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/numeric" #include "pstl/numeric"
#include "utils.h" #else
#include <execution>
#include <numeric>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
struct test_long_forms_for_one_policy struct test_long_forms_for_one_policy
{ {
template <typename Policy, typename Iterator, typename T, typename BinaryOp> template <typename Policy, typename Iterator, typename T, typename BinaryOp>
void void
operator()(Policy&& exec, Iterator first, Iterator last, T init, BinaryOp binary, T expected) operator()(Policy&& exec, Iterator first, Iterator last, T init, BinaryOp binary, T expected)
{ {
T result_r = std::reduce(exec, first, last, init, binary); T result_r = std::reduce(exec, first, last, init, binary);
Show All 24 Lines
} }
struct test_two_short_forms struct test_two_short_forms
{ {
#if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specialization by policy type, in case of broken configuration #if __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specialization by policy type, in case of broken configuration
template <typename Iterator> template <typename Iterator>
void void
operator()(pstl::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected) operator()(__pstl::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected)
{ {
} }
template <typename Iterator> template <typename Iterator>
void void
operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected) operator()(__pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected)
{ {
} }
#endif #endif
template <typename Policy, typename Iterator> template <typename Policy, typename Iterator>
void void
operator()(Policy&& exec, Iterator first, Iterator last, Sum init, Sum expected) operator()(Policy&& exec, Iterator first, Iterator last, Sum init, Sum expected)
{ {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_scan.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_scan.cpp -----------------------------------------------------===// //===-- scan.pass.cpp -----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/numeric" #include "pstl/numeric"
#include "utils.h" #else
#include "pstl_test_config.h" #include <execution>
#include <numeric>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_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. // 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 //TODO: to add a macro for availability of ver implementations
template <class InputIterator, class OutputIterator, class T> template <class InputIterator, class OutputIterator, class T>
OutputIterator OutputIterator
exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, T init) exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, T init)
{ {
for (; first != last; ++first, ++result) for (; first != last; ++first, ++result)
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
invoke_on_all_policies(test_scan_with_plus(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(), invoke_on_all_policies(test_scan_with_plus(), in.cbegin(), in.cend(), out.begin(), out.end(), expected.begin(),
expected.end(), in.size(), init, trash); expected.end(), in.size(), init, trash);
} }
} }
struct test_scan_with_binary_op struct test_scan_with_binary_op
{ {
template <typename Policy, typename Iterator1, typename Iterator2, typename Iterator3, typename Size, typename T, template <typename Policy, typename Iterator1, typename Iterator2, typename Iterator3, typename Size, typename T,
typename BinaryOp> typename BinaryOp>
typename std::enable_if<!TestUtils::isReverse<Iterator1>::value, void>::type typename std::enable_if<!Parallel_TestUtils::isReverse<Iterator1>::value, void>::type
operator()(Policy&& exec, Iterator1 in_first, Iterator1 in_last, Iterator2 out_first, Iterator2 out_last, 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) Iterator3 expected_first, Iterator3 expected_last, Size n, T init, BinaryOp binary_op, T trash)
{ {
using namespace std; using namespace std;
auto orr1 = inclusive ? inclusive_scan_serial(in_first, in_last, expected_first, binary_op, init) 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); : 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) 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); : exclusive_scan(exec, in_first, in_last, out_first, init, binary_op);
EXPECT_TRUE(out_last == orr, "scan returned wrong iterator"); EXPECT_TRUE(out_last == orr, "scan returned wrong iterator");
check_and_reset(expected_first, out_first, n, trash); check_and_reset(expected_first, out_first, n, trash);
} }
template <typename Policy, typename Iterator1, typename Iterator2, typename Iterator3, typename Size, typename T, template <typename Policy, typename Iterator1, typename Iterator2, typename Iterator3, typename Size, typename T,
typename BinaryOp> typename BinaryOp>
typename std::enable_if<TestUtils::isReverse<Iterator1>::value, void>::type typename std::enable_if<Parallel_TestUtils::isReverse<Iterator1>::value, void>::type
operator()(Policy&& exec, Iterator1 in_first, Iterator1 in_last, Iterator2 out_first, Iterator2 out_last, 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) Iterator3 expected_first, Iterator3 expected_last, Size n, T init, BinaryOp binary_op, T trash)
{ {
} }
}; };
template <typename In, typename Out, typename BinaryOp> template <typename In, typename Out, typename BinaryOp>
void void
Show All 36 Lines

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

  • This file was moved from test/test_transform_reduce.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_transform_reduce.cpp -----------------------------------------===// //===-- test_transform_reduce.cpp -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for inner_product // Tests for inner_product
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/numeric" #include "pstl/numeric"
#include "utils.h" // TODO break this dependency
#include "pstl/internal/numeric_impl.h" //for usage a serial algo version
#else
#include <execution>
#include <numeric>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
// Equal for all types // Equal for all types
template <typename T> template <typename T>
static bool static bool
Equal(T x, T y) Equal(T x, T y)
{ {
return x == y; return x == y;
} }
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_transform_scan.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_transform_scan.cpp -------------------------------------------===// //===-- transform_scan.pass.cpp -------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "support/pstl_test_config.h"
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/numeric" #include "pstl/numeric"
#include "utils.h" #else
#include "pstl_test_config.h" #include <execution>
#include <numeric>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
// Most of the framework required for testing inclusive and exclusive transform-scans is identical, // 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 // 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(). // flag inclusive, which is set to each alternative by main().
static bool inclusive; static bool inclusive;
template <typename Iterator, typename Size, typename T> template <typename Iterator, typename Size, typename T>
void void
check_and_reset(Iterator expected_first, Iterator out_first, Size n, T trash) check_and_reset(Iterator expected_first, Iterator out_first, Size n, T trash)
{ {
EXPECT_EQ_N(expected_first, out_first, n, EXPECT_EQ_N(expected_first, out_first, n,
inclusive ? "wrong result from transform_inclusive_scan" inclusive ? "wrong result from transform_inclusive_scan"
: "wrong result from transform_exclusive_scan"); : "wrong result from transform_exclusive_scan");
std::fill_n(out_first, n, trash); std::fill_n(out_first, n, trash);
} }
struct test_transform_scan struct test_transform_scan
{ {
template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp, template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp,
typename T, typename BinaryOp> typename T, typename BinaryOp>
typename std::enable_if<!TestUtils::isReverse<InputIterator>::value, void>::type typename std::enable_if<!Parallel_TestUtils::isReverse<InputIterator>::value, void>::type
operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
UnaryOp unary_op, T init, BinaryOp binary_op, T trash) UnaryOp unary_op, T init, BinaryOp binary_op, T trash)
{ {
using namespace std; using namespace std;
auto orr1 = inclusive ? transform_inclusive_scan(pstl::execution::seq, first, last, expected_first, binary_op, auto orr1 = inclusive ? transform_inclusive_scan(__pstl::execution::seq, first, last, expected_first, binary_op,
unary_op, init) unary_op, init)
: transform_exclusive_scan(pstl::execution::seq, first, last, expected_first, init, : transform_exclusive_scan(__pstl::execution::seq, first, last, expected_first, init,
binary_op, unary_op); binary_op, unary_op);
auto orr2 = inclusive ? transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op, init) 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); : transform_exclusive_scan(exec, first, last, out_first, init, binary_op, unary_op);
EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator"); EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator");
check_and_reset(expected_first, out_first, n, trash); check_and_reset(expected_first, out_first, n, trash);
// Checks inclusive scan if init is not provided // Checks inclusive scan if init is not provided
if (inclusive && n > 0) if (inclusive && n > 0)
{ {
orr1 = transform_inclusive_scan(pstl::execution::seq, first, last, expected_first, binary_op, unary_op); 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); orr2 = transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op);
EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator"); EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator");
check_and_reset(expected_first, out_first, n, trash); check_and_reset(expected_first, out_first, n, trash);
} }
} }
template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp, template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp,
typename T, typename BinaryOp> typename T, typename BinaryOp>
typename std::enable_if<TestUtils::isReverse<InputIterator>::value, void>::type typename std::enable_if<Parallel_TestUtils::isReverse<InputIterator>::value, void>::type
operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n, OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
UnaryOp unary_op, T init, BinaryOp binary_op, T trash) UnaryOp unary_op, T init, BinaryOp binary_op, T trash)
{ {
} }
}; };
const uint32_t encryption_mask = 0x314; const uint32_t encryption_mask = 0x314;
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

test/std/utilities/CMakeLists.txt

  • This file was added.
add_subdirectory(memory)

test/std/utilities/memory/CMakeLists.txt

  • This file was added.
add_subdirectory(specialized.algorithms)

test/std/utilities/memory/specialized.algorithms/CMakeLists.txt

  • This file was added.
set(PASS_SOURCES
uninitialized_copy_move.pass.cpp
uninitialized_fill_destroy.pass.cpp
uninitialized_construct.pass.cpp
)
# TODO add more tests
foreach(test_source ${PASS_SOURCES})
add_pass_test(${test_source})
endforeach(test_source ${PASS_SOURCES})

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

  • This file was moved from test/test_uninitialized_construct.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_uninitialized_construct.cpp ----------------------------------===// //===-- uninitialized_construct.pass.cpp ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for uninitialized_default_construct, uninitialized_default_construct_n, // Tests for uninitialized_default_consruct, uninitialized_default_consruct_n,
// uninitialized_value_construct, uninitialized_value_construct_n // uninitialized_value_consruct, uninitialized_value_consruct_n
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/memory" #include "pstl/memory"
#include "utils.h" #else
#include <execution>
#include <memory>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
// function of checking correctness for uninitialized.construct.value // function of checking correctness for uninitialized.construct.value
template <typename T, typename Iterator> template <typename T, typename Iterator>
bool bool
IsCheckValueCorrectness(Iterator begin, Iterator end) IsCheckValueCorrectness(Iterator begin, Iterator end)
{ {
for (; begin != end; ++begin) for (; begin != end; ++begin)
{ {
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_uninitialized_copy_move.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_uninitialized_copy_move.cpp ----------------------------------===// //===-- uninitialized_copy_move.pass.cpp ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for uninitialized_copy, uninitialized_copy_n, uninitialized_move, uninitialized_move_n // Tests for uninitialized_copy, uninitialized_copy_n, uninitialized_move, uninitialized_move_n
#include "pstl_test_config.h" #include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/memory" #include "pstl/memory"
#include "utils.h" #else
#include <execution>
#include <memory>
#endif // PSTL_STANDALONE_TESTS
using namespace TestUtils; #include "support/parallel_utils.h"
using namespace Parallel_TestUtils;
// function of checking correctness for uninitialized.construct.value // function of checking correctness for uninitialized.construct.value
template <typename InputIterator, typename OutputIterator, typename Size> template <typename InputIterator, typename OutputIterator, typename Size>
bool bool
IsCheckValueCorrectness(InputIterator first1, OutputIterator first2, Size n) IsCheckValueCorrectness(InputIterator first1, OutputIterator first2, Size n)
{ {
for (Size i = 0; i < n; ++i, ++first1, ++first2) for (Size i = 0; i < n; ++i, ++first1, ++first2)
{ {
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

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

  • This file was moved from test/test_uninitialized_fill_destroy.cpp.
// -*- C++ -*- // -*- C++ -*-
//===-- test_uninitialized_fill_destroy.cpp -------------------------------===// //===-- uninitialized_fill_destroy.pass.cpp -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Tests for the destroy, destroy_n, uninitialized_fill, uninitialized_fill_n algorithms // Tests for the destroy, destroy_n, uninitialized_fill, uninitialized_fill_n algorithms
#include "support/pstl_test_config.h"
#include <type_traits>
#ifdef PSTL_STANDALONE_TESTS
#include "pstl/execution" #include "pstl/execution"
#include "pstl/memory" #include "pstl/memory"
#include "pstl/algorithm" #else
#include "utils.h" #include <execution>
#include <memory>
#endif // PSTL_STANDALONE_TESTS
#include "support/parallel_utils.h"
using namespace TestUtils; using namespace Parallel_TestUtils;
struct test_uninitialized_fill_destroy struct test_uninitialized_fill_destroy
{ {
template <typename Policy, typename Iterator, typename T> template <typename Policy, typename Iterator, typename T>
void void
operator()(Policy&& exec, Iterator first, Iterator last, const T& in, std::size_t n, std::false_type) operator()(Policy&& exec, Iterator first, Iterator last, const T& in, std::size_t n, std::false_type)
{ {
using namespace std; using namespace std;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/support/parallel_utils.h

  • This file was moved from test/utils.h.
// -*- C++ -*- // -*- C++ -*-
//===-- utils.h -----------------------------------------------------------===// //===-- parallel_utils.h -----------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // The LLVM Compiler Infrastructure
// See https://llvm.org/LICENSE.txt for license information. //
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// File contains common utilities that tests rely on // File contains common utilities that tests rely on
// Do not #include <algorithm>, because if we do we will not detect accidental dependencies. // Do not #include <algorithm>, because if we do we will not detect accidental dependencies.
#include <sstream> #include <sstream>
#include <iostream> #include <iostream>
#include <cstring> #include <cstring>
#include <iterator> #include <iterator>
#include <vector> #include <vector>
#include <atomic> #include <atomic>
#include <memory> #include <memory>
#include <cstdint> #include <cstdint>
#include "pstl_test_config.h" #include "pstl_test_config.h"
namespace TestUtils namespace Parallel_TestUtils
{ {
typedef double float64_t; typedef double float64_t;
typedef float float32_t; typedef float float32_t;
template <class T, std::size_t N> template <class T, std::size_t N>
constexpr size_t constexpr size_t
const_size(const T (&array)[N]) noexcept const_size(const T (&array)[N]) noexcept
{ {
return N; return N;
} }
template <typename T> template <typename T>
class Sequence; class Sequence;
// Handy macros for error reporting // Handy macros for error reporting
#define EXPECT_TRUE(condition, message) TestUtils::expect<true>(condition, __FILE__, __LINE__, message) #define EXPECT_TRUE(condition, message) Parallel_TestUtils::expect<true>(condition, __FILE__, __LINE__, message)
#define EXPECT_FALSE(condition, message) TestUtils::expect<false>(condition, __FILE__, __LINE__, message) #define EXPECT_FALSE(condition, message) Parallel_TestUtils::expect<false>(condition, __FILE__, __LINE__, message)
// Check that expected and actual are equal and have the same type. // 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) #define EXPECT_EQ(expected, actual, message) \
Parallel_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. // 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) \ #define EXPECT_EQ_N(expected, actual, n, message) \
TestUtils::expect_equal(expected, actual, n, __FILE__, __LINE__, message) Parallel_TestUtils::expect_equal(expected, actual, n, __FILE__, __LINE__, message)
// Issue error message from outstr, adding a newline. // Issue error message from outstr, adding a newline.
// Real purpose of this routine is to have a place to hang a breakpoint. // Real purpose of this routine is to have a place to hang a breakpoint.
static void static void
issue_error_message(std::stringstream& outstr) issue_error_message(std::stringstream& outstr)
{ {
outstr << std::endl; outstr << std::endl;
std::cerr << outstr.str(); std::cerr << outstr.str();
▲ Show 20 Lines • Show All 1,191 Lines • Show Last 20 Lines

test/support/pstl_test_config.h

  • This file was moved from test/pstl_test_config.h.
// -*- C++ -*- // -*- C++ -*-
//===-- pstl_test_config.h ------------------------------------------------===// //===-- pstl_test_config.h ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // The LLVM Compiler Infrastructure
// See https://llvm.org/LICENSE.txt for license information. //
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef __PSTL_TEST_config_H #ifndef __PSTL_TEST_config_H
#define __PSTL_TEST_config_H #define __PSTL_TEST_config_H
#if defined(_MSC_VER) && defined(_DEBUG) #if defined(_MSC_VER) && defined(_DEBUG)
#define _SCL_SECURE_NO_WARNINGS //to prevent the compilation warning. Microsoft STL implementation has specific checking of an iterator range in DEBUG mode for the containers from the standard library. #define _SCL_SECURE_NO_WARNINGS //to prevent the compilation warning. Microsoft STL implementation has specific checking of an iterator range in DEBUG mode for the containers from the standard library.
Show All 35 Lines

test/test_adjacent_difference.cpp

  • This file was moved to test/std/numerics/numeric.ops/adjacent_difference.pass.cpp.

test/test_adjacent_find.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/adjacent_find.pass.cpp.

test/test_all_of.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/all_of.pass.cpp.

test/test_any_of.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/any_of.pass.cpp.

test/test_copy_if.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp.

test/test_copy_move.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/copy_move.pass.cpp.

test/test_count.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/count.pass.cpp.

test/test_equal.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/equal.pass.cpp.

test/test_fill.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/fill.pass.cpp.

test/test_find.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/find.pass.cpp.

test/test_find_end.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/find_end.pass.cpp.

test/test_find_first_of.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/find_first_of.pass.cpp.

test/test_find_if.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/find_if.pass.cpp.

test/test_for_each.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/for_each.pass.cpp.

test/test_generate.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/generate.pass.cpp.

test/test_includes.cpp

  • This file was moved to test/std/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp.

test/test_inplace_merge.cpp

  • This file was moved to test/std/algorithms/alg.merge/inplace_merge.pass.cpp.

test/test_is_heap.cpp

  • This file was moved to test/std/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp.

test/test_is_partitioned.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp.

test/test_is_sorted.cpp

  • This file was moved to test/std/algorithms/alg.sorting/is_sorted.pass.cpp.

test/test_lexicographical_compare.cpp

  • This file was moved to test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp.

test/test_merge.cpp

  • This file was moved to test/std/algorithms/alg.merge/merge.pass.cpp.

test/test_minmax_element.cpp

  • This file was moved to test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp.

test/test_mismatch.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/mismatch.pass.cpp.

test/test_none_of.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/none_of.pass.cpp.

test/test_nth_element.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/nth_element.pass.cpp.

test/test_partial_sort.cpp

  • This file was moved to test/std/algorithms/alg.sorting/partial_sort.pass.cpp.

test/test_partial_sort_copy.cpp

  • This file was moved to test/std/algorithms/alg.sorting/partial_sort_copy.pass.cpp.

test/test_partition.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp.

test/test_partition_copy.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp.

test/test_reduce.cpp

  • This file was moved to test/std/numerics/numeric.ops/reduce.pass.cpp.

test/test_remove.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/remove.pass.cpp.

test/test_remove_copy.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/remove_copy.pass.cpp.

test/test_replace.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/replace.pass.cpp.

test/test_replace_copy.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/replace_copy.pass.cpp.

test/test_reverse.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp.

test/test_reverse_copy.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp.

test/test_rotate.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/rotate.pass.cpp.

test/test_rotate_copy.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/rotate_copy.pass.cpp.

test/test_scan.cpp

  • This file was moved to test/std/numerics/numeric.ops/scan.pass.cpp.

test/test_search_n.cpp

  • This file was moved to test/std/algorithms/alg.nonmodifying/search_n.pass.cpp.

test/test_set.cpp

  • This file was moved to test/std/algorithms/alg.sorting/alg.set.operations/set.pass.cpp.

test/test_sort.cpp

  • This file was moved to test/std/algorithms/alg.sorting/sort.pass.cpp.

test/test_swap_ranges.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/swap_ranges.pass.cpp.

test/test_transform_binary.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/transform_binary.pass.cpp.

test/test_transform_reduce.cpp

  • This file was moved to test/std/numerics/numeric.ops/transform_reduce.pass.cpp.

test/test_transform_scan.cpp

  • This file was moved to test/std/numerics/numeric.ops/transform_scan.pass.cpp.

test/test_transform_unary.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/transform_unary.pass.cpp.

test/test_uninitialized_construct.cpp

  • This file was moved to test/std/utilities/memory/specialized.algorithms/uninitialized_construct.pass.cpp.

test/test_uninitialized_copy_move.cpp

  • This file was moved to test/std/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp.

test/test_uninitialized_fill_destroy.cpp

  • This file was moved to test/std/utilities/memory/specialized.algorithms/uninitialized_fill_destroy.pass.cpp.

test/test_unique.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/unique.pass.cpp.

test/test_unique_copy_equal.cpp

  • This file was moved to test/std/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp.

test/utils.h

  • This file was moved to test/support/parallel_utils.h.
build/mingw.inc