From bf2279fa70b18757ddb918e1d3ee5f73cc3b912f Mon Sep 17 00:00:00 2001 From: Andres Arpi Date: Tue, 25 Feb 2020 22:51:17 +0100 Subject: [PATCH 1/2] Add settable seed --- test/CMakeLists.txt | 1 + test/test_adjacent_difference.cpp | 182 ++- test/test_binary_search.cpp | 95 +- test/test_binary_search_vector.cpp | 402 ++--- test/test_binary_search_vector_descending.cpp | 188 ++- test/test_complex.cpp | 340 +++-- test/test_complex_transform.cpp | 258 ++-- test/test_copy.cpp | 386 +++-- test/test_count.cpp | 42 +- test/test_counting_iterator.cpp | 38 +- test/test_dereference.cpp | 67 +- test/test_device_delete.cpp | 3 +- test/test_equal.cpp | 98 +- test/test_fill.cpp | 132 +- test/test_find.cpp | 107 +- test/test_for_each.cpp | 88 +- test/test_gather.cpp | 284 ++-- test/test_generate.cpp | 2 +- test/test_inner_product.cpp | 36 +- test/test_is_partitioned.cpp | 22 +- test/test_is_sorted.cpp | 20 +- test/test_is_sorted_until.cpp | 20 +- test/test_max_element.cpp | 43 +- test/test_memory.cpp | 2 +- test/test_merge.cpp | 182 ++- test/test_merge_by_key.cpp | 405 ++--- test/test_min_element.cpp | 43 +- test/test_minmax_element.cpp | 65 +- test/test_mismatch.cpp | 4 +- test/test_pair.cpp | 19 +- test/test_pair_reduce.cpp | 49 +- test/test_pair_scan.cpp | 121 +- test/test_pair_sort.cpp | 52 +- test/test_pair_transform.cpp | 58 +- test/test_partition.cpp | 1354 +++++++++-------- test/test_partition_point.cpp | 18 +- test/test_reduce.cpp | 46 +- test/test_reduce_by_key.cpp | 198 ++- test/test_remove.cpp | 484 +++--- test/test_replace.cpp | 361 +++-- test/test_reverse_iterator.cpp | 36 +- test/test_scan.cpp | 360 +++-- test/test_scan_by_key.cpp | 320 ++-- test/test_scatter.cpp | 190 ++- test/test_seed.hpp | 27 + test/test_set_difference.cpp | 182 ++- test/test_set_difference_by_key.cpp | 417 ++--- .../test_set_difference_by_key_descending.cpp | 130 +- test/test_set_difference_descending.cpp | 73 +- test/test_set_intersection.cpp | 233 +-- test/test_set_intersection_by_key.cpp | 399 ++--- ...est_set_intersection_by_key_descending.cpp | 118 +- test/test_set_intersection_descending.cpp | 72 +- test/test_set_intersection_key_value.cpp | 100 +- test/test_set_symmetric_difference.cpp | 371 +++-- test/test_set_symmetric_difference_by_key.cpp | 398 ++--- ...symmetric_difference_by_key_descending.cpp | 132 +- ...st_set_symmetric_difference_descending.cpp | 72 +- test/test_set_union.cpp | 129 +- test/test_set_union_by_key.cpp | 403 ++--- test/test_set_union_by_key_descending.cpp | 185 ++- test/test_set_union_descending.cpp | 72 +- test/test_set_union_key_value.cpp | 379 +++-- test/test_sort.cpp | 191 ++- test/test_sort_by_key.cpp | 176 ++- test/test_sort_by_key_variable_bits.cpp | 41 +- test/test_sort_variables.cpp | 32 +- test/test_stable_sort.cpp | 24 +- test/test_stable_sort_by_key.cpp | 40 +- test/test_swap_ranges.cpp | 60 +- test/test_tabulate.cpp | 4 +- test/test_transform.cpp | 646 +++++--- test/test_transform_iterator.cpp | 38 +- test/test_transform_reduce.cpp | 52 +- test/test_transform_scan.cpp | 218 +-- test/test_tuple.cpp | 458 +++--- test/test_tuple_reduce.cpp | 48 +- test/test_tuple_sort.cpp | 63 +- test/test_tuple_transform.cpp | 48 +- test/test_uninitialized_copy.cpp | 5 +- test/test_unique.cpp | 94 +- test/test_unique_by_key.cpp | 388 ++--- test/test_utils.hpp | 10 +- test/test_vector_insert.cpp | 95 +- test/test_vector_manipulation.cpp | 144 +- test/test_zip_iterator.cpp | 89 +- test/test_zip_iterator_reduce.cpp | 49 +- test/test_zip_iterator_reduce_by_key.cpp | 185 +-- test/test_zip_iterator_scan.cpp | 129 +- test/test_zip_iterator_sort.cpp | 40 +- test/test_zip_iterator_sort_by_key.cpp | 97 +- 91 files changed, 8461 insertions(+), 6116 deletions(-) create mode 100644 test/test_seed.hpp diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 86d46d71f..bc0bb1e1a 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -33,6 +33,7 @@ endfunction() # Tests # **************************************************************************** + add_rocthrust_test("thrust.hip.adjacent_difference" test_adjacent_difference.cpp) add_rocthrust_test("thrust.hip.advance" test_advance.cpp) add_rocthrust_test("thrust.hip.allocator" test_allocator.cpp) diff --git a/test/test_adjacent_difference.cpp b/test/test_adjacent_difference.cpp index 2ae811aa8..77260f3f7 100644 --- a/test/test_adjacent_difference.cpp +++ b/test/test_adjacent_difference.cpp @@ -70,42 +70,52 @@ TYPED_TEST(AdjacentDifferenceVariableTests, TestAdjacentDifference) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - typename thrust::host_vector::iterator h_result; - typename thrust::device_vector::iterator d_result; - - h_result = thrust::adjacent_difference(h_input.begin(), h_input.end(), h_output.begin()); - d_result = thrust::adjacent_difference(d_input.begin(), d_input.end(), d_output.begin()); - - ASSERT_EQ(h_result - h_output.begin(), size); - ASSERT_EQ(d_result - d_output.begin(), size); - ASSERT_EQ_QUIET(h_output, d_output); - - h_result = thrust::adjacent_difference( - h_input.begin(), h_input.end(), h_output.begin(), thrust::plus()); - d_result = thrust::adjacent_difference( - d_input.begin(), d_input.end(), d_output.begin(), thrust::plus()); - - ASSERT_EQ(h_result - h_output.begin(), size); - ASSERT_EQ(d_result - d_output.begin(), size); - ASSERT_EQ_QUIET(h_output, d_output); - - // in-place operation - h_result = thrust::adjacent_difference( - h_input.begin(), h_input.end(), h_input.begin(), thrust::plus()); - d_result = thrust::adjacent_difference( - d_input.begin(), d_input.end(), d_input.begin(), thrust::plus()); - - ASSERT_EQ(h_result - h_input.begin(), size); - ASSERT_EQ(d_result - d_input.begin(), size); - ASSERT_EQ_QUIET(h_input, h_output); //computed previously - ASSERT_EQ_QUIET(d_input, d_output); //computed previously + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + typename thrust::host_vector::iterator h_result; + typename thrust::device_vector::iterator d_result; + + h_result + = thrust::adjacent_difference(h_input.begin(), h_input.end(), h_output.begin()); + d_result + = thrust::adjacent_difference(d_input.begin(), d_input.end(), d_output.begin()); + + ASSERT_EQ(h_result - h_output.begin(), size); + ASSERT_EQ(d_result - d_output.begin(), size); + ASSERT_EQ_QUIET(h_output, d_output); + + h_result = thrust::adjacent_difference( + h_input.begin(), h_input.end(), h_output.begin(), thrust::plus()); + d_result = thrust::adjacent_difference( + d_input.begin(), d_input.end(), d_output.begin(), thrust::plus()); + + ASSERT_EQ(h_result - h_output.begin(), size); + ASSERT_EQ(d_result - d_output.begin(), size); + ASSERT_EQ_QUIET(h_output, d_output); + + // in-place operation + h_result = thrust::adjacent_difference( + h_input.begin(), h_input.end(), h_input.begin(), thrust::plus()); + d_result = thrust::adjacent_difference( + d_input.begin(), d_input.end(), d_input.begin(), thrust::plus()); + + ASSERT_EQ(h_result - h_input.begin(), size); + ASSERT_EQ(d_result - d_input.begin(), size); + ASSERT_EQ_QUIET(h_input, h_output); //computed previously + ASSERT_EQ_QUIET(d_input, d_output); //computed previously + } } } @@ -116,31 +126,39 @@ TYPED_TEST(AdjacentDifferenceVariableTests, TestAdjacentDifferenceInPlaceWithRel const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - typename thrust::host_vector::iterator h_result; - typename thrust::device_vector::iterator d_result; - - h_result = thrust::adjacent_difference( - h_input.begin(), h_input.end(), h_output.begin(), thrust::plus()); - d_result = thrust::adjacent_difference( - d_input.begin(), d_input.end(), d_output.begin(), thrust::plus()); - - // in-place operation with different iterator types - h_result = thrust::adjacent_difference( - h_input.cbegin(), h_input.cend(), h_input.begin(), thrust::plus()); - d_result = thrust::adjacent_difference( - d_input.cbegin(), d_input.cend(), d_input.begin(), thrust::plus()); - - ASSERT_EQ(h_result - h_input.begin(), size); - ASSERT_EQ(d_result - d_input.begin(), size); - ASSERT_EQ_QUIET(h_output, h_input); // reference computed previously - ASSERT_EQ_QUIET(d_output, d_input); // reference computed previously + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + typename thrust::host_vector::iterator h_result; + typename thrust::device_vector::iterator d_result; + + h_result = thrust::adjacent_difference( + h_input.begin(), h_input.end(), h_output.begin(), thrust::plus()); + d_result = thrust::adjacent_difference( + d_input.begin(), d_input.end(), d_output.begin(), thrust::plus()); + + // in-place operation with different iterator types + h_result = thrust::adjacent_difference( + h_input.cbegin(), h_input.cend(), h_input.begin(), thrust::plus()); + d_result = thrust::adjacent_difference( + d_input.cbegin(), d_input.cend(), d_input.begin(), thrust::plus()); + + ASSERT_EQ(h_result - h_input.begin(), size); + ASSERT_EQ(d_result - d_input.begin(), size); + ASSERT_EQ_QUIET(h_output, h_input); // reference computed previously + ASSERT_EQ_QUIET(d_output, d_input); // reference computed previously + } } } @@ -151,28 +169,36 @@ TYPED_TEST(AdjacentDifferenceVariableTests, TestAdjacentDifferenceDiscardIterato const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::discard_iterator<> h_result; - thrust::discard_iterator<> d_result; - - h_result = thrust::adjacent_difference( - h_input.begin(), h_input.end(), thrust::make_discard_iterator()); - d_result = thrust::adjacent_difference( - d_input.begin(), d_input.end(), thrust::make_discard_iterator()); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::discard_iterator<> h_result; + thrust::discard_iterator<> d_result; + + h_result = thrust::adjacent_difference( + h_input.begin(), h_input.end(), thrust::make_discard_iterator()); + d_result = thrust::adjacent_difference( + d_input.begin(), d_input.end(), thrust::make_discard_iterator()); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } template OutputIterator - adjacent_difference(my_system& system, InputIterator, InputIterator, OutputIterator result) +adjacent_difference(my_system& system, InputIterator, InputIterator, OutputIterator result) { system.validate_dispatch(); return result; diff --git a/test/test_binary_search.cpp b/test/test_binary_search.cpp index b1186d42b..9dba1f165 100644 --- a/test/test_binary_search.cpp +++ b/test/test_binary_search.cpp @@ -27,19 +27,15 @@ TESTS_DEFINE(BinarySearchTestsInKernel, NumericalTestsParams); struct custom_less { - template - __device__ inline - bool operator()(T a, T b) + template + __device__ inline bool operator()(T a, T b) { return a < b; } }; -template -__global__ -void lower_bound_kernel(size_t n, - T* input, - ptrdiff_t* output) +template +__global__ void lower_bound_kernel(size_t n, T* input, ptrdiff_t* output) { output[0] = thrust::lower_bound(thrust::device, input, input + n, T(0), custom_less()) - input; output[1] = thrust::lower_bound(thrust::device, input, input + n, T(1)) - input; @@ -66,13 +62,14 @@ TYPED_TEST(BinarySearchTestsInKernel, TestLowerBound) thrust::device_vector d_output(10); - hipLaunchKernelGGL( - HIP_KERNEL_NAME(lower_bound_kernel), - dim3(1), dim3(1), 0, 0, - size_t(d_input.size()), - thrust::raw_pointer_cast(d_input.data()), - thrust::raw_pointer_cast(d_output.data()) - ); + hipLaunchKernelGGL(HIP_KERNEL_NAME(lower_bound_kernel), + dim3(1), + dim3(1), + 0, + 0, + size_t(d_input.size()), + thrust::raw_pointer_cast(d_input.data()), + thrust::raw_pointer_cast(d_output.data())); thrust::host_vector output = d_output; ASSERT_EQ(output[0], 0); @@ -87,11 +84,8 @@ TYPED_TEST(BinarySearchTestsInKernel, TestLowerBound) ASSERT_EQ(output[9], 5); } -template -__global__ -void upper_bound_kernel(size_t n, - T* input, - ptrdiff_t* output) +template +__global__ void upper_bound_kernel(size_t n, T* input, ptrdiff_t* output) { output[0] = thrust::upper_bound(thrust::device, input, input + n, T(0)) - input; output[1] = thrust::upper_bound(thrust::device, input, input + n, T(1)) - input; @@ -118,13 +112,14 @@ TYPED_TEST(BinarySearchTestsInKernel, TestUpperBound) thrust::device_vector d_output(10); - hipLaunchKernelGGL( - HIP_KERNEL_NAME(upper_bound_kernel), - dim3(1), dim3(1), 0, 0, - size_t(d_input.size()), - thrust::raw_pointer_cast(d_input.data()), - thrust::raw_pointer_cast(d_output.data()) - ); + hipLaunchKernelGGL(HIP_KERNEL_NAME(upper_bound_kernel), + dim3(1), + dim3(1), + 0, + 0, + size_t(d_input.size()), + thrust::raw_pointer_cast(d_input.data()), + thrust::raw_pointer_cast(d_output.data())); thrust::host_vector output = d_output; ASSERT_EQ(output[0], 1); @@ -139,11 +134,8 @@ TYPED_TEST(BinarySearchTestsInKernel, TestUpperBound) ASSERT_EQ(output[9], 5); } -template -__global__ -void binary_search_kernel(size_t n, - T* input, - bool* output) +template +__global__ void binary_search_kernel(size_t n, T* input, bool* output) { output[0] = thrust::binary_search(thrust::device, input, input + n, T(0)); output[1] = thrust::binary_search(thrust::device, input, input + n, T(1)); @@ -170,13 +162,14 @@ TYPED_TEST(BinarySearchTestsInKernel, TestBinarySearch) thrust::device_vector d_output(10); - hipLaunchKernelGGL( - HIP_KERNEL_NAME(binary_search_kernel), - dim3(1), dim3(1), 0, 0, - size_t(d_input.size()), - thrust::raw_pointer_cast(d_input.data()), - thrust::raw_pointer_cast(d_output.data()) - ); + hipLaunchKernelGGL(HIP_KERNEL_NAME(binary_search_kernel), + dim3(1), + dim3(1), + 0, + 0, + size_t(d_input.size()), + thrust::raw_pointer_cast(d_input.data()), + thrust::raw_pointer_cast(d_output.data())); thrust::host_vector output = d_output; ASSERT_EQ(output[0], true); @@ -220,10 +213,8 @@ TYPED_TEST(BinarySearchTests, TestScalarLowerBoundSimple) } template -ForwardIterator lower_bound(my_system& system, - ForwardIterator first, - ForwardIterator, - const LessThanComparable&) +ForwardIterator +lower_bound(my_system& system, ForwardIterator first, ForwardIterator, const LessThanComparable&) { system.validate_dispatch(); return first; @@ -241,7 +232,7 @@ TEST(BinarySearchTests, TestScalarLowerBoundDispatchExplicit) template ForwardIterator - lower_bound(my_tag, ForwardIterator first, ForwardIterator, const LessThanComparable&) +lower_bound(my_tag, ForwardIterator first, ForwardIterator, const LessThanComparable&) { *first = 13; return first; @@ -281,10 +272,8 @@ TYPED_TEST(BinarySearchTests, TestScalarUpperBoundSimple) } template -ForwardIterator upper_bound(my_system& system, - ForwardIterator first, - ForwardIterator, - const LessThanComparable&) +ForwardIterator +upper_bound(my_system& system, ForwardIterator first, ForwardIterator, const LessThanComparable&) { system.validate_dispatch(); return first; @@ -302,7 +291,7 @@ TEST(BinarySearchTests, TestScalarUpperBoundDispatchExplicit) template ForwardIterator - upper_bound(my_tag, ForwardIterator first, ForwardIterator, const LessThanComparable&) +upper_bound(my_tag, ForwardIterator first, ForwardIterator, const LessThanComparable&) { *first = 13; return first; @@ -410,10 +399,8 @@ TYPED_TEST(BinarySearchTests, TestScalarEqualRangeSimple) } template -thrust::pair equal_range(my_system& system, - ForwardIterator first, - ForwardIterator, - const LessThanComparable&) +thrust::pair +equal_range(my_system& system, ForwardIterator first, ForwardIterator, const LessThanComparable&) { system.validate_dispatch(); return thrust::make_pair(first, first); @@ -431,7 +418,7 @@ TEST(BinarySearchTests, TestScalarEqualRangeDispatchExplicit) template thrust::pair - equal_range(my_tag, ForwardIterator first, ForwardIterator, const LessThanComparable&) +equal_range(my_tag, ForwardIterator first, ForwardIterator, const LessThanComparable&) { *first = 13; return thrust::make_pair(first, first); diff --git a/test/test_binary_search_vector.cpp b/test/test_binary_search_vector.cpp index 4597e2060..ca255a31d 100644 --- a/test/test_binary_search_vector.cpp +++ b/test/test_binary_search_vector.cpp @@ -16,8 +16,8 @@ */ #include -#include #include +#include #include #include #include @@ -28,24 +28,19 @@ TESTS_DEFINE(BinarySearchVectorTestsInKernel, NumericalTestsParams); struct custom_less { - template - __device__ inline - bool operator()(T a, T b) + template + __device__ inline bool operator()(T a, T b) { return a < b; } }; -template -__global__ -void lower_bound_kernel(size_t n, - T* input, - ptrdiff_t* output) +template +__global__ void lower_bound_kernel(size_t n, T* input, ptrdiff_t* output) { thrust::counting_iterator values(0); thrust::lower_bound( - thrust::device, input, input + n, values, values + 10, output, custom_less() - ); + thrust::device, input, input + n, values, values + 10, output, custom_less()); } TYPED_TEST(BinarySearchVectorTestsInKernel, TestLowerBound) @@ -61,13 +56,14 @@ TYPED_TEST(BinarySearchVectorTestsInKernel, TestLowerBound) thrust::device_vector d_output(10); - hipLaunchKernelGGL( - HIP_KERNEL_NAME(lower_bound_kernel), - dim3(1), dim3(1), 0, 0, - size_t(d_input.size()), - thrust::raw_pointer_cast(d_input.data()), - thrust::raw_pointer_cast(d_output.data()) - ); + hipLaunchKernelGGL(HIP_KERNEL_NAME(lower_bound_kernel), + dim3(1), + dim3(1), + 0, + 0, + size_t(d_input.size()), + thrust::raw_pointer_cast(d_input.data()), + thrust::raw_pointer_cast(d_output.data())); thrust::host_vector output = d_output; ASSERT_EQ(output[0], 0); @@ -82,11 +78,8 @@ TYPED_TEST(BinarySearchVectorTestsInKernel, TestLowerBound) ASSERT_EQ(output[9], 5); } -template -__global__ -void upper_bound_kernel(size_t n, - T* input, - ptrdiff_t* output) +template +__global__ void upper_bound_kernel(size_t n, T* input, ptrdiff_t* output) { thrust::counting_iterator values(0); thrust::upper_bound(thrust::device, input, input + n, values, values + 10, output); @@ -105,13 +98,14 @@ TYPED_TEST(BinarySearchVectorTestsInKernel, TestUpperBound) thrust::device_vector d_output(10); - hipLaunchKernelGGL( - HIP_KERNEL_NAME(upper_bound_kernel), - dim3(1), dim3(1), 0, 0, - size_t(d_input.size()), - thrust::raw_pointer_cast(d_input.data()), - thrust::raw_pointer_cast(d_output.data()) - ); + hipLaunchKernelGGL(HIP_KERNEL_NAME(upper_bound_kernel), + dim3(1), + dim3(1), + 0, + 0, + size_t(d_input.size()), + thrust::raw_pointer_cast(d_input.data()), + thrust::raw_pointer_cast(d_output.data())); thrust::host_vector output = d_output; ASSERT_EQ(output[0], 1); @@ -126,11 +120,8 @@ TYPED_TEST(BinarySearchVectorTestsInKernel, TestUpperBound) ASSERT_EQ(output[9], 5); } -template -__global__ -void binary_search_kernel(size_t n, - T* input, - bool* output) +template +__global__ void binary_search_kernel(size_t n, T* input, bool* output) { thrust::counting_iterator values(0); thrust::binary_search(thrust::device, input, input + n, values, values + 10, output); @@ -149,13 +140,14 @@ TYPED_TEST(BinarySearchVectorTestsInKernel, TestBinarySearch) thrust::device_vector d_output(10); - hipLaunchKernelGGL( - HIP_KERNEL_NAME(binary_search_kernel), - dim3(1), dim3(1), 0, 0, - size_t(d_input.size()), - thrust::raw_pointer_cast(d_input.data()), - thrust::raw_pointer_cast(d_output.data()) - ); + hipLaunchKernelGGL(HIP_KERNEL_NAME(binary_search_kernel), + dim3(1), + dim3(1), + 0, + 0, + size_t(d_input.size()), + thrust::raw_pointer_cast(d_input.data()), + thrust::raw_pointer_cast(d_output.data())); thrust::host_vector output = d_output; ASSERT_EQ(output[0], true); @@ -476,25 +468,34 @@ TYPED_TEST(BinarySearchVectorIntegerTests, TestVectorLowerBound) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(2 * size); - thrust::device_vector d_output(2 * size); - - thrust::lower_bound( - h_vec.begin(), h_vec.end(), h_input.begin(), h_input.end(), h_output.begin()); - thrust::lower_bound( - d_vec.begin(), d_vec.end(), d_input.begin(), d_input.end(), d_output.begin()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(2 * size); + thrust::device_vector d_output(2 * size); + + thrust::lower_bound( + h_vec.begin(), h_vec.end(), h_input.begin(), h_input.end(), h_output.begin()); + thrust::lower_bound( + d_vec.begin(), d_vec.end(), d_input.begin(), d_input.end(), d_output.begin()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -504,25 +505,34 @@ TYPED_TEST(BinarySearchVectorIntegerTests, TestVectorUpperBound) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(2 * size); - thrust::device_vector d_output(2 * size); - - thrust::upper_bound( - h_vec.begin(), h_vec.end(), h_input.begin(), h_input.end(), h_output.begin()); - thrust::upper_bound( - d_vec.begin(), d_vec.end(), d_input.begin(), d_input.end(), d_output.begin()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(2 * size); + thrust::device_vector d_output(2 * size); + + thrust::upper_bound( + h_vec.begin(), h_vec.end(), h_input.begin(), h_input.end(), h_output.begin()); + thrust::upper_bound( + d_vec.begin(), d_vec.end(), d_input.begin(), d_input.end(), d_output.begin()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -532,25 +542,34 @@ TYPED_TEST(BinarySearchVectorIntegerTests, TestVectorBinarySearch) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(2 * size); - thrust::device_vector d_output(2 * size); - - thrust::binary_search( - h_vec.begin(), h_vec.end(), h_input.begin(), h_input.end(), h_output.begin()); - thrust::binary_search( - d_vec.begin(), d_vec.end(), d_input.begin(), d_input.end(), d_output.begin()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(2 * size); + thrust::device_vector d_output(2 * size); + + thrust::binary_search( + h_vec.begin(), h_vec.end(), h_input.begin(), h_input.end(), h_output.begin()); + thrust::binary_search( + d_vec.begin(), d_vec.end(), d_input.begin(), d_input.end(), d_output.begin()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -560,31 +579,42 @@ TYPED_TEST(BinarySearchVectorIntegerTests, TestVectorLowerBoundDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::discard_iterator<> h_result = thrust::lower_bound(h_vec.begin(), - h_vec.end(), - h_input.begin(), - h_input.end(), - thrust::make_discard_iterator()); - thrust::discard_iterator<> d_result = thrust::lower_bound(d_vec.begin(), - d_vec.end(), - d_input.begin(), - d_input.end(), - thrust::make_discard_iterator()); - - thrust::discard_iterator<> reference(2 * size); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::discard_iterator<> h_result + = thrust::lower_bound(h_vec.begin(), + h_vec.end(), + h_input.begin(), + h_input.end(), + thrust::make_discard_iterator()); + thrust::discard_iterator<> d_result + = thrust::lower_bound(d_vec.begin(), + d_vec.end(), + d_input.begin(), + d_input.end(), + thrust::make_discard_iterator()); + + thrust::discard_iterator<> reference(2 * size); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } @@ -594,31 +624,42 @@ TYPED_TEST(BinarySearchVectorIntegerTests, TestVectorUpperBoundDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::discard_iterator<> h_result = thrust::upper_bound(h_vec.begin(), - h_vec.end(), - h_input.begin(), - h_input.end(), - thrust::make_discard_iterator()); - thrust::discard_iterator<> d_result = thrust::upper_bound(d_vec.begin(), - d_vec.end(), - d_input.begin(), - d_input.end(), - thrust::make_discard_iterator()); - - thrust::discard_iterator<> reference(2 * size); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::discard_iterator<> h_result + = thrust::upper_bound(h_vec.begin(), + h_vec.end(), + h_input.begin(), + h_input.end(), + thrust::make_discard_iterator()); + thrust::discard_iterator<> d_result + = thrust::upper_bound(d_vec.begin(), + d_vec.end(), + d_input.begin(), + d_input.end(), + thrust::make_discard_iterator()); + + thrust::discard_iterator<> reference(2 * size); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } @@ -628,32 +669,41 @@ TYPED_TEST(BinarySearchVectorIntegerTests, TestVectorBinarySearchDiscardIterator for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::discard_iterator<> h_result - = thrust::binary_search(h_vec.begin(), - h_vec.end(), - h_input.begin(), - h_input.end(), - thrust::make_discard_iterator()); - thrust::discard_iterator<> d_result - = thrust::binary_search(d_vec.begin(), - d_vec.end(), - d_input.begin(), - d_input.end(), - thrust::make_discard_iterator()); - - thrust::discard_iterator<> reference(2 * size); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::discard_iterator<> h_result + = thrust::binary_search(h_vec.begin(), + h_vec.end(), + h_input.begin(), + h_input.end(), + thrust::make_discard_iterator()); + thrust::discard_iterator<> d_result + = thrust::binary_search(d_vec.begin(), + d_vec.end(), + d_input.begin(), + d_input.end(), + thrust::make_discard_iterator()); + + thrust::discard_iterator<> reference(2 * size); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } diff --git a/test/test_binary_search_vector_descending.cpp b/test/test_binary_search_vector_descending.cpp index 0cb569ffc..78b209f69 100644 --- a/test/test_binary_search_vector_descending.cpp +++ b/test/test_binary_search_vector_descending.cpp @@ -181,33 +181,42 @@ TYPED_TEST(BinarySearchVectorDescendingIntegerTests, TestVectorLowerBoundDescend for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end(), thrust::greater()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(2 * size); - thrust::device_vector d_output(2 * size); - - thrust::lower_bound(h_vec.begin(), - h_vec.end(), - h_input.begin(), - h_input.end(), - h_output.begin(), - thrust::greater()); - thrust::lower_bound(d_vec.begin(), - d_vec.end(), - d_input.begin(), - d_input.end(), - d_output.begin(), - thrust::greater()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end(), thrust::greater()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(2 * size); + thrust::device_vector d_output(2 * size); + + thrust::lower_bound(h_vec.begin(), + h_vec.end(), + h_input.begin(), + h_input.end(), + h_output.begin(), + thrust::greater()); + thrust::lower_bound(d_vec.begin(), + d_vec.end(), + d_input.begin(), + d_input.end(), + d_output.begin(), + thrust::greater()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -218,32 +227,42 @@ TYPED_TEST(BinarySearchVectorDescendingIntegerTests, TestVectorUpperBoundDescend { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end(), thrust::greater()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(2 * size); - thrust::device_vector d_output(2 * size); - - thrust::upper_bound(h_vec.begin(), - h_vec.end(), - h_input.begin(), - h_input.end(), - h_output.begin(), - thrust::greater()); - thrust::upper_bound(d_vec.begin(), - d_vec.end(), - d_input.begin(), - d_input.end(), - d_output.begin(), - thrust::greater()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end(), thrust::greater()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(2 * size); + thrust::device_vector d_output(2 * size); + + thrust::upper_bound(h_vec.begin(), + h_vec.end(), + h_input.begin(), + h_input.end(), + h_output.begin(), + thrust::greater()); + thrust::upper_bound(d_vec.begin(), + d_vec.end(), + d_input.begin(), + d_input.end(), + d_output.begin(), + thrust::greater()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -253,32 +272,41 @@ TYPED_TEST(BinarySearchVectorDescendingIntegerTests, TestVectorBinarySearchDesce for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_vec = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::sort(h_vec.begin(), h_vec.end(), thrust::greater()); - thrust::device_vector d_vec = h_vec; - - thrust::host_vector h_input = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(2 * size); - thrust::device_vector d_output(2 * size); - - thrust::binary_search(h_vec.begin(), - h_vec.end(), - h_input.begin(), - h_input.end(), - h_output.begin(), - thrust::greater()); - thrust::binary_search(d_vec.begin(), - d_vec.end(), - d_input.begin(), - d_input.end(), - d_output.begin(), - thrust::greater()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vec = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::sort(h_vec.begin(), h_vec.end(), thrust::greater()); + thrust::device_vector d_vec = h_vec; + + thrust::host_vector h_input = get_random_data( + 2 * size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(2 * size); + thrust::device_vector d_output(2 * size); + + thrust::binary_search(h_vec.begin(), + h_vec.end(), + h_input.begin(), + h_input.end(), + h_output.begin(), + thrust::greater()); + thrust::binary_search(d_vec.begin(), + d_vec.end(), + d_input.begin(), + d_input.end(), + d_output.begin(), + thrust::greater()); + + ASSERT_EQ(h_output, d_output); + } } } diff --git a/test/test_complex.cpp b/test/test_complex.cpp index 244761738..beaf31e54 100644 --- a/test/test_complex.cpp +++ b/test/test_complex.cpp @@ -24,235 +24,305 @@ TESTS_DEFINE(ComplexTests, FloatTestsParams); TYPED_TEST(ComplexTests, TestComplexConstructors) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector data = get_random_data(2, T(-1000), T(1000)); - thrust::complex a(data[0], data[1]); - thrust::complex b(a); - thrust::complex float_b(a); - a = thrust::complex(data[0], data[1]); - ASSERT_NEAR_COMPLEX(a, b); + thrust::host_vector data = get_random_data(2, T(-1000), T(1000), seed_value); - a = thrust::complex(data[0]); - ASSERT_EQ(data[0], a.real()); - ASSERT_EQ(T(0), a.imag()); + thrust::complex a(data[0], data[1]); + thrust::complex b(a); + thrust::complex float_b(a); + a = thrust::complex(data[0], data[1]); + ASSERT_NEAR_COMPLEX(a, b); - a = thrust::complex(); - ASSERT_NEAR_COMPLEX(a, std::complex(0)); + a = thrust::complex(data[0]); + ASSERT_EQ(data[0], a.real()); + ASSERT_EQ(T(0), a.imag()); - a = thrust::complex( - thrust::complex(static_cast(data[0]), static_cast(data[1]))); - ASSERT_NEAR_COMPLEX(a, float_b); + a = thrust::complex(); + ASSERT_NEAR_COMPLEX(a, std::complex(0)); - a = thrust::complex( - thrust::complex(static_cast(data[0]), static_cast(data[1]))); - ASSERT_NEAR_COMPLEX(a, b); + a = thrust::complex( + thrust::complex(static_cast(data[0]), static_cast(data[1]))); + ASSERT_NEAR_COMPLEX(a, float_b); - a = thrust::complex( - std::complex(static_cast(data[0]), static_cast(data[1]))); - ASSERT_NEAR_COMPLEX(a, float_b); + a = thrust::complex( + thrust::complex(static_cast(data[0]), static_cast(data[1]))); + ASSERT_NEAR_COMPLEX(a, b); - a = thrust::complex( - std::complex(static_cast(data[0]), static_cast(data[1]))); - ASSERT_NEAR_COMPLEX(a, b); + a = thrust::complex( + std::complex(static_cast(data[0]), static_cast(data[1]))); + ASSERT_NEAR_COMPLEX(a, float_b); + + a = thrust::complex( + std::complex(static_cast(data[0]), static_cast(data[1]))); + ASSERT_NEAR_COMPLEX(a, b); + } } TYPED_TEST(ComplexTests, TestComplexGetters) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + - thrust::host_vector data - = get_random_data(2, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector data = get_random_data( + 2, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::complex z(data[0], data[1]); + thrust::complex z(data[0], data[1]); - ASSERT_EQ(data[0], z.real()); - ASSERT_EQ(data[1], z.imag()); + ASSERT_EQ(data[0], z.real()); + ASSERT_EQ(data[1], z.imag()); - z.real(data[1]); - z.imag(data[0]); - ASSERT_EQ(data[1], z.real()); - ASSERT_EQ(data[0], z.imag()); + z.real(data[1]); + z.imag(data[0]); + ASSERT_EQ(data[1], z.real()); + ASSERT_EQ(data[0], z.imag()); - volatile thrust::complex v(data[0], data[1]); + volatile thrust::complex v(data[0], data[1]); - ASSERT_EQ(data[0], v.real()); - ASSERT_EQ(data[1], v.imag()); + ASSERT_EQ(data[0], v.real()); + ASSERT_EQ(data[1], v.imag()); - v.real(data[1]); - v.imag(data[0]); - ASSERT_EQ(data[1], v.real()); - ASSERT_EQ(data[0], v.imag()); + v.real(data[1]); + v.imag(data[0]); + ASSERT_EQ(data[1], v.real()); + ASSERT_EQ(data[0], v.imag()); + } } TYPED_TEST(ComplexTests, TestComplexMemberOperators) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector data_a = get_random_data(2, 10000, 10000); - thrust::host_vector data_b = get_random_data(2, 10000, 10000); + thrust::host_vector data_a = get_random_data(2, 10000, 10000, seed_value); - thrust::complex a(data_a[0], data_a[1]); - thrust::complex b(data_b[0], data_b[1]); + thrust::host_vector data_b = get_random_data(2, 10000, 10000, seed_value + seed_value_addition); - std::complex c(a); - std::complex d(b); + thrust::complex a(data_a[0], data_a[1]); + thrust::complex b(data_b[0], data_b[1]); - a += b; - c += d; - ASSERT_NEAR_COMPLEX(a, c); + std::complex c(a); + std::complex d(b); - a -= b; - c -= d; - ASSERT_NEAR_COMPLEX(a, c); + a += b; + c += d; + ASSERT_NEAR_COMPLEX(a, c); - a *= b; - c *= d; - ASSERT_NEAR_COMPLEX(a, c); + a -= b; + c -= d; + ASSERT_NEAR_COMPLEX(a, c); - a /= b; - c /= d; - ASSERT_NEAR_COMPLEX(a, c); + a *= b; + c *= d; + ASSERT_NEAR_COMPLEX(a, c); - // casting operator - c = (std::complex)a; + a /= b; + c /= d; + ASSERT_NEAR_COMPLEX(a, c); + + // casting operator + c = (std::complex)a; + } } TYPED_TEST(ComplexTests, TestComplexBasicArithmetic) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + - thrust::host_vector data = get_random_data(2, T(-100), T(100)); + thrust::host_vector data = get_random_data(2, T(-100), T(100), seed_value); - thrust::complex a(data[0], data[1]); - std::complex b(a); + thrust::complex a(data[0], data[1]); + std::complex b(a); - // Test the basic arithmetic functions against std + // Test the basic arithmetic functions against std - ASSERT_NEAR(abs(a), abs(b), T(0.01)); + ASSERT_NEAR(abs(a), abs(b), T(0.01)); - ASSERT_NEAR(arg(a), arg(b), T(0.01)); + ASSERT_NEAR(arg(a), arg(b), T(0.01)); - ASSERT_NEAR(norm(a), norm(b), T(0.01)); + ASSERT_NEAR(norm(a), norm(b), T(0.01)); - ASSERT_EQ(conj(a), conj(b)); + ASSERT_EQ(conj(a), conj(b)); - ASSERT_NEAR_COMPLEX(thrust::polar(data[0], data[1]), std::polar(data[0], data[1])); + ASSERT_NEAR_COMPLEX(thrust::polar(data[0], data[1]), std::polar(data[0], data[1])); - // random_samples does not seem to produce infinities so proj(z) == z - ASSERT_EQ(proj(a), a); + // random_samples does not seem to produce infinities so proj(z) == z + ASSERT_EQ(proj(a), a); + } } TYPED_TEST(ComplexTests, TestComplexBinaryArithmetic) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector data_a = get_random_data(2, -10000, 10000); - thrust::host_vector data_b = get_random_data(2, -10000, 10000); + thrust::host_vector data_a = get_random_data(2, -10000, 10000, seed_value); - thrust::complex a(data_a[0], data_a[1]); - thrust::complex b(data_b[0], data_b[1]); + thrust::host_vector data_b = get_random_data(2, -10000, 10000, seed_value + seed_value_addition); - ASSERT_NEAR_COMPLEX(a * b, std::complex(a) * std::complex(b)); - ASSERT_NEAR_COMPLEX(a * data_b[0], std::complex(a) * data_b[0]); - ASSERT_NEAR_COMPLEX(data_a[0] * b, data_a[0] * std::complex(b)); + thrust::complex a(data_a[0], data_a[1]); + thrust::complex b(data_b[0], data_b[1]); - ASSERT_NEAR_COMPLEX(a / b, std::complex(a) / std::complex(b)); - ASSERT_NEAR_COMPLEX(a / data_b[0], std::complex(a) / data_b[0]); - ASSERT_NEAR_COMPLEX(data_a[0] / b, data_a[0] / std::complex(b)); + ASSERT_NEAR_COMPLEX(a * b, std::complex(a) * std::complex(b)); + ASSERT_NEAR_COMPLEX(a * data_b[0], std::complex(a) * data_b[0]); + ASSERT_NEAR_COMPLEX(data_a[0] * b, data_a[0] * std::complex(b)); - ASSERT_EQ(a + b, std::complex(a) + std::complex(b)); - ASSERT_EQ(a + data_b[0], std::complex(a) + data_b[0]); - ASSERT_EQ(data_a[0] + b, data_a[0] + std::complex(b)); + ASSERT_NEAR_COMPLEX(a / b, std::complex(a) / std::complex(b)); + ASSERT_NEAR_COMPLEX(a / data_b[0], std::complex(a) / data_b[0]); + ASSERT_NEAR_COMPLEX(data_a[0] / b, data_a[0] / std::complex(b)); - ASSERT_EQ(a - b, std::complex(a) - std::complex(b)); - ASSERT_EQ(a - data_b[0], std::complex(a) - data_b[0]); - ASSERT_EQ(data_a[0] - b, data_a[0] - std::complex(b)); + ASSERT_EQ(a + b, std::complex(a) + std::complex(b)); + ASSERT_EQ(a + data_b[0], std::complex(a) + data_b[0]); + ASSERT_EQ(data_a[0] + b, data_a[0] + std::complex(b)); + + ASSERT_EQ(a - b, std::complex(a) - std::complex(b)); + ASSERT_EQ(a - data_b[0], std::complex(a) - data_b[0]); + ASSERT_EQ(data_a[0] - b, data_a[0] - std::complex(b)); + } } TYPED_TEST(ComplexTests, TestComplexUnaryArithmetic) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + - thrust::host_vector data_a - = get_random_data(2, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector data_a = get_random_data( + 2, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::complex a(data_a[0], data_a[1]); + thrust::complex a(data_a[0], data_a[1]); - ASSERT_EQ(+a, +std::complex(a)); - ASSERT_EQ(-a, -std::complex(a)); + ASSERT_EQ(+a, +std::complex(a)); + ASSERT_EQ(-a, -std::complex(a)); + } } TYPED_TEST(ComplexTests, TestComplexExponentialFunctions) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + - thrust::host_vector data_a = get_random_data(2, -100, 100); + thrust::host_vector data_a = get_random_data(2, -100, 100, seed_value); - thrust::complex a(data_a[0], data_a[1]); - std::complex b(a); + thrust::complex a(data_a[0], data_a[1]); + std::complex b(a); - ASSERT_NEAR_COMPLEX(exp(a), exp(b)); - ASSERT_NEAR_COMPLEX(log(a), log(b)); - ASSERT_NEAR_COMPLEX(log10(a), log10(b)); + ASSERT_NEAR_COMPLEX(exp(a), exp(b)); + ASSERT_NEAR_COMPLEX(log(a), log(b)); + ASSERT_NEAR_COMPLEX(log10(a), log10(b)); + } } TYPED_TEST(ComplexTests, TestComplexPowerFunctions) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector data_a = get_random_data(2, -100, 100); - thrust::host_vector data_b = get_random_data(2, -100, 100); + thrust::host_vector data_a = get_random_data(2, -100, 100, seed_value); - thrust::complex a(data_a[0], data_a[1]); - thrust::complex b(data_b[0], data_b[1]); - std::complex c(a); - std::complex d(b); + thrust::host_vector data_b = get_random_data(2, -100, 100, seed_value + seed_value_addition); - ASSERT_NEAR_COMPLEX(pow(a, b), pow(c, d)); - ASSERT_NEAR_COMPLEX(pow(a, b.real()), pow(c, d.real())); - ASSERT_NEAR_COMPLEX(pow(a.real(), b), pow(c.real(), d)); + thrust::complex a(data_a[0], data_a[1]); + thrust::complex b(data_b[0], data_b[1]); + std::complex c(a); + std::complex d(b); - ASSERT_NEAR_COMPLEX(sqrt(a), sqrt(c)); + ASSERT_NEAR_COMPLEX(pow(a, b), pow(c, d)); + ASSERT_NEAR_COMPLEX(pow(a, b.real()), pow(c, d.real())); + ASSERT_NEAR_COMPLEX(pow(a.real(), b), pow(c.real(), d)); + + ASSERT_NEAR_COMPLEX(sqrt(a), sqrt(c)); + } } TYPED_TEST(ComplexTests, TestComplexTrigonometricFunctions) { using T = typename TestFixture::input_type; - - thrust::host_vector data_a = get_random_data(2, T(-1), T(1)); - - thrust::complex a(data_a[0], data_a[1]); - std::complex c(a); - - ASSERT_NEAR_COMPLEX(cos(a), cos(c)); - ASSERT_NEAR_COMPLEX(sin(a), sin(c)); - ASSERT_NEAR_COMPLEX(tan(a), tan(c)); - ASSERT_NEAR_COMPLEX(cosh(a), cosh(c)); - ASSERT_NEAR_COMPLEX(sinh(a), sinh(c)); - ASSERT_NEAR_COMPLEX(tanh(a), tanh(c)); - - ASSERT_NEAR_COMPLEX(acos(a), acos(c)); - ASSERT_NEAR_COMPLEX(asin(a), asin(c)); - ASSERT_NEAR_COMPLEX(atan(a), atan(c)); - ASSERT_NEAR_COMPLEX(acosh(a), acosh(c)); - ASSERT_NEAR_COMPLEX(asinh(a), asinh(c)); - ASSERT_NEAR_COMPLEX(atanh(a), atanh(c)); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + + thrust::host_vector data_a = get_random_data(2, T(-1), T(1), seed_value); + + thrust::complex a(data_a[0], data_a[1]); + std::complex c(a); + + ASSERT_NEAR_COMPLEX(cos(a), cos(c)); + ASSERT_NEAR_COMPLEX(sin(a), sin(c)); + ASSERT_NEAR_COMPLEX(tan(a), tan(c)); + ASSERT_NEAR_COMPLEX(cosh(a), cosh(c)); + ASSERT_NEAR_COMPLEX(sinh(a), sinh(c)); + ASSERT_NEAR_COMPLEX(tanh(a), tanh(c)); + + ASSERT_NEAR_COMPLEX(acos(a), acos(c)); + ASSERT_NEAR_COMPLEX(asin(a), asin(c)); + ASSERT_NEAR_COMPLEX(atan(a), atan(c)); + ASSERT_NEAR_COMPLEX(acosh(a), acosh(c)); + ASSERT_NEAR_COMPLEX(asinh(a), asinh(c)); + ASSERT_NEAR_COMPLEX(atanh(a), atanh(c)); + } } TYPED_TEST(ComplexTests, TestComplexStreamOperators) { using T = typename TestFixture::input_type; - - thrust::host_vector data_a = get_random_data(2, T(-1000), T(1000)); - - thrust::complex a(data_a[0], data_a[1]); - std::stringstream out; - out << a; - thrust::complex b; - out >> b; - ASSERT_NEAR_COMPLEX(a, b); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + + thrust::host_vector data_a = get_random_data(2, T(-1000), T(1000), seed_value); + + thrust::complex a(data_a[0], data_a[1]); + std::stringstream out; + out << a; + thrust::complex b; + out >> b; + ASSERT_NEAR_COMPLEX(a, b); + } } diff --git a/test/test_complex_transform.cpp b/test/test_complex_transform.cpp index 227cf0b37..e94e5ec5a 100644 --- a/test/test_complex_transform.cpp +++ b/test/test_complex_transform.cpp @@ -208,10 +208,10 @@ thrust::complex epsilonComplex() }; template -thrust::host_vector> random_complex_samples(size_t size) +thrust::host_vector> random_complex_samples(size_t size, unsigned int seed_value) { thrust::host_vector real = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); thrust::host_vector> h_p1(size); for(size_t i = 0; i < size; i++) { @@ -229,19 +229,27 @@ TYPED_TEST(ComplexTransformTests, TestComplexArithmeticTransform) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = random_complex_samples(size); - thrust::host_vector h_p2 = random_complex_samples(size); - thrust::host_vector h_result(size); - - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_p2 = h_p2; - thrust::device_vector d_result(size); - - thrust::transform( - h_p1.begin(), h_p1.end(), h_p2.begin(), h_result.begin(), basic_arithmetic_functor()); - thrust::transform( - d_p1.begin(), d_p1.end(), d_p2.begin(), d_result.begin(), basic_arithmetic_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_p1 = random_complex_samples(size, seed_value); + thrust::host_vector h_p2 = random_complex_samples(size, seed_value + seed_value_addition); + thrust::host_vector h_result(size); + + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_p2 = h_p2; + thrust::device_vector d_result(size); + + thrust::transform( + h_p1.begin(), h_p1.end(), h_p2.begin(), h_result.begin(), basic_arithmetic_functor()); + thrust::transform( + d_p1.begin(), d_p1.end(), d_p2.begin(), d_result.begin(), basic_arithmetic_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + } } } @@ -253,15 +261,23 @@ TYPED_TEST(ComplexTransformTests, TestComplexPlaneTransform) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = random_complex_samples(size); - thrust::host_vector h_result(size); - - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_result(size); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), complex_plane_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), complex_plane_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_p1 = random_complex_samples(size, seed_value); + thrust::host_vector h_result(size); + + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_result(size); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), complex_plane_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), complex_plane_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + } } } @@ -273,21 +289,29 @@ TYPED_TEST(ComplexTransformTests, TestComplexPowerTransform) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = random_complex_samples(size); - thrust::host_vector h_p2 = random_complex_samples(size); - thrust::host_vector h_result(size); - - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_p2 = h_p2; - thrust::device_vector d_result(size); - - thrust::transform(h_p1.begin(), h_p1.end(), h_p2.begin(), h_result.begin(), pow_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_p2.begin(), d_result.begin(), pow_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), sqrt_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), sqrt_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_p1 = random_complex_samples(size, seed_value); + thrust::host_vector h_p2 = random_complex_samples(size, seed_value + seed_value_addition); + thrust::host_vector h_result(size); + + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_p2 = h_p2; + thrust::device_vector d_result(size); + + thrust::transform(h_p1.begin(), h_p1.end(), h_p2.begin(), h_result.begin(), pow_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_p2.begin(), d_result.begin(), pow_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), sqrt_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), sqrt_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + } } } @@ -299,23 +323,31 @@ TYPED_TEST(ComplexTransformTests, TestComplexExponentialTransform) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = random_complex_samples(size); - thrust::host_vector h_result(size); - - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_result(size); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), exp_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), exp_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), log_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), log_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), log10_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), log10_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_p1 = random_complex_samples(size, seed_value); + thrust::host_vector h_result(size); + + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_result(size); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), exp_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), exp_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), log_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), log_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), log10_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), log10_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + } } } @@ -327,58 +359,66 @@ TYPED_TEST(ComplexTransformTests, TestComplexTrigonometricTransform) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = random_complex_samples(size); - thrust::host_vector h_result(size); - - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_result(size); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), sin_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), sin_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), cos_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), cos_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), tan_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), tan_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), sinh_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), sinh_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), cosh_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), cosh_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), tanh_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), tanh_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), asin_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), asin_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), acos_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), acos_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), atan_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), atan_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), asinh_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), asinh_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), acosh_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), acosh_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); - - thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), atanh_functor()); - thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), atanh_functor()); - ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_p1 = random_complex_samples(size, seed_value); + thrust::host_vector h_result(size); + + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_result(size); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), sin_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), sin_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), cos_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), cos_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), tan_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), tan_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), sinh_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), sinh_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), cosh_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), cosh_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), tanh_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), tanh_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), asin_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), asin_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), acos_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), acos_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), atan_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), atan_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), asinh_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), asinh_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), acosh_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), acosh_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + + thrust::transform(h_p1.begin(), h_p1.end(), h_result.begin(), atanh_functor()); + thrust::transform(d_p1.begin(), d_p1.end(), d_result.begin(), atanh_functor()); + ASSERT_NEAR_COMPLEX_VECTOR(h_result, d_result); + } } } diff --git a/test/test_copy.cpp b/test/test_copy.cpp index cc6a825aa..bd29e878a 100644 --- a/test/test_copy.cpp +++ b/test/test_copy.cpp @@ -15,8 +15,8 @@ * limitations under the License. */ -#include #include +#include #include #include #include @@ -25,17 +25,17 @@ #include "test_header.hpp" -#include #include +#include TESTS_DEFINE(CopyTests, FullTestsParams) TESTS_DEFINE(CopyIntegerTests, IntegerTestsParams) TEST(HipThrustCopy, HostToDevice) { - const size_t size = 256; + const size_t size = 256; thrust::device_system_tag dev_tag; - thrust::host_system_tag host_tag; + thrust::host_system_tag host_tag; // Malloc on host auto h_ptr = thrust::malloc(host_tag, sizeof(int) * size); @@ -58,7 +58,7 @@ TEST(HipThrustCopy, HostToDevice) TEST(HipThrustCopy, DeviceToDevice) { - const size_t size = 256; + const size_t size = 256; thrust::device_system_tag dev_tag; // Malloc on device @@ -73,13 +73,10 @@ TEST(HipThrustCopy, DeviceToDevice) thrust::copy(d_ptr1, d_ptr1 + 256, d_ptr2); std::vector output(size); - HIP_CHECK( - hipMemcpy( - output.data(), thrust::raw_pointer_cast(d_ptr2), - size * sizeof(int), - hipMemcpyDeviceToHost - ) - ); + HIP_CHECK(hipMemcpy(output.data(), + thrust::raw_pointer_cast(d_ptr2), + size * sizeof(int), + hipMemcpyDeviceToHost)); for(size_t i = 0; i < size; i++) { @@ -96,13 +93,17 @@ TEST(CopyTests, TestCopyFromConstIterator) using T = int; std::vector v(5); - v[0] = T(0); v[1] = T(1); v[2] = T(2); v[3] = T(3); v[4] = T(4); + v[0] = T(0); + v[1] = T(1); + v[2] = T(2); + v[3] = T(3); + v[4] = T(4); std::vector::const_iterator begin = v.begin(); - std::vector::const_iterator end = v.end(); + std::vector::const_iterator end = v.end(); // copy to host_vector - thrust::host_vector h(5, (T) 10); + thrust::host_vector h(5, (T)10); thrust::host_vector::iterator h_result = thrust::copy(begin, end, h.begin()); ASSERT_EQ(h[0], T(0)); ASSERT_EQ(h[1], T(1)); @@ -112,7 +113,7 @@ TEST(CopyTests, TestCopyFromConstIterator) ASSERT_EQ_QUIET(h_result, h.end()); // copy to device_vector - thrust::device_vector d(5, (T) 10); + thrust::device_vector d(5, (T)10); thrust::device_vector::iterator d_result = thrust::copy(begin, end, d.begin()); ASSERT_EQ(d[0], T(0)); ASSERT_EQ(d[1], T(1)); @@ -126,18 +127,18 @@ TEST(CopyTests, TestCopyToDiscardIterator) { using T = int; - thrust::host_vector h_input(5,1); + thrust::host_vector h_input(5, 1); thrust::device_vector d_input = h_input; thrust::discard_iterator<> reference(5); // copy from host_vector - thrust::discard_iterator<> h_result = - thrust::copy(h_input.begin(), h_input.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> h_result + = thrust::copy(h_input.begin(), h_input.end(), thrust::make_discard_iterator()); // copy from device_vector - thrust::discard_iterator<> d_result = - thrust::copy(d_input.begin(), d_input.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> d_result + = thrust::copy(d_input.begin(), d_input.end(), thrust::make_discard_iterator()); ASSERT_EQ_QUIET(reference, h_result); ASSERT_EQ_QUIET(reference, d_result); @@ -147,30 +148,32 @@ TEST(CopyTests, TestCopyToDiscardIteratorZipped) { using T = int; - thrust::host_vector h_input(5,1); + thrust::host_vector h_input(5, 1); thrust::device_vector d_input = h_input; thrust::host_vector h_output(5); thrust::device_vector d_output(5); thrust::discard_iterator<> reference(5); - using Tuple1 = thrust::tuple,thrust::host_vector::iterator>; - using Tuple2 = thrust::tuple,thrust::device_vector::iterator>; + using Tuple1 = thrust::tuple, thrust::host_vector::iterator>; + using Tuple2 = thrust::tuple, thrust::device_vector::iterator>; using ZipIterator1 = thrust::zip_iterator; using ZipIterator2 = thrust::zip_iterator; // copy from host_vector - ZipIterator1 h_result = - thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(h_input.begin(), h_input.begin())), - thrust::make_zip_iterator(thrust::make_tuple(h_input.end(), h_input.end())), - thrust::make_zip_iterator(thrust::make_tuple(thrust::make_discard_iterator(), h_output.begin()))); + ZipIterator1 h_result = thrust::copy( + thrust::make_zip_iterator(thrust::make_tuple(h_input.begin(), h_input.begin())), + thrust::make_zip_iterator(thrust::make_tuple(h_input.end(), h_input.end())), + thrust::make_zip_iterator( + thrust::make_tuple(thrust::make_discard_iterator(), h_output.begin()))); // copy from device_vector - ZipIterator2 d_result = - thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(d_input.begin(), d_input.begin())), - thrust::make_zip_iterator(thrust::make_tuple(d_input.end(), d_input.end())), - thrust::make_zip_iterator(thrust::make_tuple(thrust::make_discard_iterator(), d_output.begin()))); + ZipIterator2 d_result = thrust::copy( + thrust::make_zip_iterator(thrust::make_tuple(d_input.begin(), d_input.begin())), + thrust::make_zip_iterator(thrust::make_tuple(d_input.end(), d_input.end())), + thrust::make_zip_iterator( + thrust::make_tuple(thrust::make_discard_iterator(), d_output.begin()))); ASSERT_EQ(h_output, h_input); ASSERT_EQ(d_output, d_input); @@ -181,14 +184,19 @@ TEST(CopyTests, TestCopyToDiscardIteratorZipped) TYPED_TEST(CopyTests, TestCopyMatchingTypes) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; + using T = typename Vector::value_type; Vector v(5); - v[0] = T(0); v[1] = T(1); v[2] = T(2); v[3] = T(3); v[4] = T(4); + v[0] = T(0); + v[1] = T(1); + v[2] = T(2); + v[3] = T(3); + v[4] = T(4); // copy to host_vector - thrust::host_vector h(5, (T) 10); - typename thrust::host_vector::iterator h_result = thrust::copy(v.begin(), v.end(), h.begin()); + thrust::host_vector h(5, (T)10); + typename thrust::host_vector::iterator h_result + = thrust::copy(v.begin(), v.end(), h.begin()); ASSERT_EQ(h[0], T(0)); ASSERT_EQ(h[1], T(1)); ASSERT_EQ(h[2], T(2)); @@ -197,8 +205,9 @@ TYPED_TEST(CopyTests, TestCopyMatchingTypes) ASSERT_EQ_QUIET(h_result, h.end()); // copy to device_vector - thrust::device_vector d(5, (T) 10); - typename thrust::device_vector::iterator d_result = thrust::copy(v.begin(), v.end(), d.begin()); + thrust::device_vector d(5, (T)10); + typename thrust::device_vector::iterator d_result + = thrust::copy(v.begin(), v.end(), d.begin()); ASSERT_EQ(d[0], T(0)); ASSERT_EQ(d[1], T(1)); ASSERT_EQ(d[2], T(2)); @@ -210,14 +219,19 @@ TYPED_TEST(CopyTests, TestCopyMatchingTypes) TYPED_TEST(CopyTests, TestCopyMixedTypes) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; + using T = typename Vector::value_type; Vector v(5); - v[0] = T(0); v[1] = T(1); v[2] = T(2); v[3] = T(3); v[4] = T(4); + v[0] = T(0); + v[1] = T(1); + v[2] = T(2); + v[3] = T(3); + v[4] = T(4); // copy to host_vector with different type - thrust::host_vector h(5, (float) 10); - typename thrust::host_vector::iterator h_result = thrust::copy(v.begin(), v.end(), h.begin()); + thrust::host_vector h(5, (float)10); + typename thrust::host_vector::iterator h_result + = thrust::copy(v.begin(), v.end(), h.begin()); ASSERT_EQ(h[0], T(0)); ASSERT_EQ(h[1], T(1)); @@ -227,8 +241,9 @@ TYPED_TEST(CopyTests, TestCopyMixedTypes) ASSERT_EQ_QUIET(h_result, h.end()); // copy to device_vector with different type - thrust::device_vector d(5, (float) 10); - typename thrust::device_vector::iterator d_result = thrust::copy(v.begin(), v.end(), d.begin()); + thrust::device_vector d(5, (float)10); + typename thrust::device_vector::iterator d_result + = thrust::copy(v.begin(), v.end(), d.begin()); ASSERT_EQ(d[0], T(0)); ASSERT_EQ(d[1], T(1)); ASSERT_EQ(d[2], T(2)); @@ -240,9 +255,11 @@ TYPED_TEST(CopyTests, TestCopyMixedTypes) TEST(CopyTests, TestCopyVectorBool) { std::vector v(3); - v[0] = true; v[1] = false; v[2] = true; + v[0] = true; + v[1] = false; + v[2] = true; - thrust::host_vector h(3); + thrust::host_vector h(3); thrust::device_vector d(3); thrust::copy(v.begin(), v.end(), h.begin()); @@ -260,7 +277,7 @@ TEST(CopyTests, TestCopyVectorBool) TYPED_TEST(CopyTests, TestCopyListTo) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; + using T = typename Vector::value_type; // copy from list to Vector std::list l; @@ -283,43 +300,45 @@ TYPED_TEST(CopyTests, TestCopyListTo) l.clear(); - thrust::copy(v.begin(), v.end(), std::back_insert_iterator< std::list >(l)); + thrust::copy(v.begin(), v.end(), std::back_insert_iterator>(l)); ASSERT_EQ(l.size(), 5); typename std::list::const_iterator iter = l.begin(); - ASSERT_EQ(*iter, 0); iter++; - ASSERT_EQ(*iter, 1); iter++; - ASSERT_EQ(*iter, 2); iter++; - ASSERT_EQ(*iter, 3); iter++; - ASSERT_EQ(*iter, 4); iter++; + ASSERT_EQ(*iter, 0); + iter++; + ASSERT_EQ(*iter, 1); + iter++; + ASSERT_EQ(*iter, 2); + iter++; + ASSERT_EQ(*iter, 3); + iter++; + ASSERT_EQ(*iter, 4); + iter++; } -template +template struct is_even { - __host__ __device__ - bool operator()(T x) + __host__ __device__ bool operator()(T x) { return (static_cast(x) & 1) == 0; } }; -template +template struct is_true { - __host__ __device__ - bool operator()(T x) + __host__ __device__ bool operator()(T x) { return x ? true : false; } }; -template +template struct mod_3 { - __host__ __device__ - unsigned int operator()(T x) + __host__ __device__ unsigned int operator()(T x) { return static_cast(x) % 3; } @@ -328,14 +347,19 @@ struct mod_3 TYPED_TEST(CopyTests, TestCopyIfSimple) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; + using T = typename Vector::value_type; Vector v(5); - v[0] = T(0); v[1] = T(1); v[2] = T(2); v[3] = T(3); v[4] = T(4); + v[0] = T(0); + v[1] = T(1); + v[2] = T(2); + v[3] = T(3); + v[4] = T(4); Vector dest(3); - typename Vector::iterator dest_end = thrust::copy_if(v.begin(), v.end(), dest.begin(), is_even()); + typename Vector::iterator dest_end + = thrust::copy_if(v.begin(), v.end(), dest.begin(), is_even()); ASSERT_EQ(T(0), dest[0]); ASSERT_EQ(T(2), dest[1]); @@ -347,44 +371,54 @@ TYPED_TEST(CopyIntegerTests, TestCopyIf) { using T = typename TestFixture::input_type; - for (auto size : get_sizes()) + for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_data = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - typename thrust::host_vector::iterator h_new_end; - typename thrust::device_vector::iterator d_new_end; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - // test with Predicate that returns a bool - { - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + typename thrust::host_vector::iterator h_new_end; + typename thrust::device_vector::iterator d_new_end; - h_new_end = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), is_even()); - d_new_end = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), is_even()); + // test with Predicate that returns a bool + { + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - h_result.resize(h_new_end - h_result.begin()); - d_result.resize(d_new_end - d_result.begin()); + h_new_end + = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), is_even()); + d_new_end + = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), is_even()); - ASSERT_EQ(h_result, d_result); - } + h_result.resize(h_new_end - h_result.begin()); + d_result.resize(d_new_end - d_result.begin()); - // test with Predicate that returns a non-bool - { - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + ASSERT_EQ(h_result, d_result); + } + + // test with Predicate that returns a non-bool + { + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - h_new_end = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), mod_3()); - d_new_end = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), mod_3()); + h_new_end + = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), mod_3()); + d_new_end + = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), mod_3()); - h_result.resize(h_new_end - h_result.begin()); - d_result.resize(d_new_end - d_result.begin()); + h_result.resize(h_new_end - h_result.begin()); + d_result.resize(d_new_end - d_result.begin()); - ASSERT_EQ(h_result, d_result); + ASSERT_EQ(h_result, d_result); + } } } } @@ -393,50 +427,66 @@ TYPED_TEST(CopyIntegerTests, TestCopyIfStencil) { using T = typename TestFixture::input_type; - for (auto size : get_sizes()) + for(auto size : get_sizes()) { - thrust::host_vector h_data(size); thrust::sequence(h_data.begin(), h_data.end()); - thrust::device_vector d_data(size); thrust::sequence(d_data.begin(), d_data.end()); + SCOPED_TRACE(testing::Message() << "with size= " << size); - thrust::host_vector h_stencil = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); - thrust::device_vector d_stencil = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); + thrust::host_vector h_data(size); + thrust::sequence(h_data.begin(), h_data.end()); + thrust::device_vector d_data(size); + thrust::sequence(d_data.begin(), d_data.end()); - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); - - typename thrust::host_vector::iterator h_new_end; - typename thrust::device_vector::iterator d_new_end; - - // test with Predicate that returns a bool + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_stencil = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_stencil = get_random_data( + size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_result(size); thrust::device_vector d_result(size); - h_new_end = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), is_even()); - d_new_end = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), is_even()); + typename thrust::host_vector::iterator h_new_end; + typename thrust::device_vector::iterator d_new_end; - h_result.resize(h_new_end - h_result.begin()); - d_result.resize(d_new_end - d_result.begin()); + // test with Predicate that returns a bool + { + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - ASSERT_EQ(h_result, d_result); - } + h_new_end + = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), is_even()); + d_new_end + = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), is_even()); - // test with Predicate that returns a non-bool - { - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + h_result.resize(h_new_end - h_result.begin()); + d_result.resize(d_new_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } + + // test with Predicate that returns a non-bool + { + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - h_new_end = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), mod_3()); - d_new_end = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), mod_3()); + h_new_end + = thrust::copy_if(h_data.begin(), h_data.end(), h_result.begin(), mod_3()); + d_new_end + = thrust::copy_if(d_data.begin(), d_data.end(), d_result.begin(), mod_3()); - h_result.resize(h_new_end - h_result.begin()); - d_result.resize(d_new_end - d_result.begin()); + h_result.resize(h_new_end - h_result.begin()); + d_result.resize(d_new_end - d_result.begin()); - ASSERT_EQ(h_result, d_result); + ASSERT_EQ(h_result, d_result); + } } } } @@ -444,7 +494,7 @@ TYPED_TEST(CopyIntegerTests, TestCopyIfStencil) TYPED_TEST(CopyTests, TestCopyCountingIterator) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; + using T = typename Vector::value_type; thrust::counting_iterator iter(1); @@ -461,16 +511,22 @@ TYPED_TEST(CopyTests, TestCopyCountingIterator) TYPED_TEST(CopyTests, TestCopyZipIterator) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; - - Vector v1(3); v1[0] = T(1); v1[1] = T(2); v1[2] = T(3); - Vector v2(3); v2[0] = T(4); v2[1] = T(5); v2[2] = T(6); + using T = typename Vector::value_type; + + Vector v1(3); + v1[0] = T(1); + v1[1] = T(2); + v1[2] = T(3); + Vector v2(3); + v2[0] = T(4); + v2[1] = T(5); + v2[2] = T(6); Vector v3(3, T(0)); Vector v4(3, T(0)); - thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(v1.begin(),v2.begin())), - thrust::make_zip_iterator(thrust::make_tuple(v1.end(),v2.end())), - thrust::make_zip_iterator(thrust::make_tuple(v3.begin(),v4.begin()))); + thrust::copy(thrust::make_zip_iterator(thrust::make_tuple(v1.begin(), v2.begin())), + thrust::make_zip_iterator(thrust::make_tuple(v1.end(), v2.end())), + thrust::make_zip_iterator(thrust::make_tuple(v3.begin(), v4.begin()))); ASSERT_EQ(v1, v3); ASSERT_EQ(v2, v4); @@ -479,14 +535,14 @@ TYPED_TEST(CopyTests, TestCopyZipIterator) TYPED_TEST(CopyTests, TestCopyConstantIteratorToZipIterator) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; + using T = typename Vector::value_type; - Vector v1(3,T(0)); - Vector v2(3,T(0)); + Vector v1(3, T(0)); + Vector v2(3, T(0)); - thrust::copy(thrust::make_constant_iterator(thrust::tuple(4,7)), - thrust::make_constant_iterator(thrust::tuple(4,7)) + v1.size(), - thrust::make_zip_iterator(thrust::make_tuple(v1.begin(),v2.begin()))); + thrust::copy(thrust::make_constant_iterator(thrust::tuple(4, 7)), + thrust::make_constant_iterator(thrust::tuple(4, 7)) + v1.size(), + thrust::make_zip_iterator(thrust::make_tuple(v1.begin(), v2.begin()))); ASSERT_EQ(v1[0], T(4)); ASSERT_EQ(v1[1], T(4)); @@ -496,8 +552,8 @@ TYPED_TEST(CopyTests, TestCopyConstantIteratorToZipIterator) ASSERT_EQ(v2[2], T(7)); } -template -OutputIterator copy(my_system &system, InputIterator, InputIterator, OutputIterator result) +template +OutputIterator copy(my_system& system, InputIterator, InputIterator, OutputIterator result) { system.validate_dispatch(); return result; @@ -508,15 +564,12 @@ TEST(CopyTests, TestCopyDispatchExplicit) thrust::device_vector vec(1); my_system sys(0); - thrust::copy(sys, - vec.begin(), - vec.end(), - vec.begin()); + thrust::copy(sys, vec.begin(), vec.end(), vec.begin()); ASSERT_EQ(true, sys.is_valid()); } -template +template OutputIterator copy(my_tag, InputIterator, InputIterator, OutputIterator result) { *result = 13; @@ -534,9 +587,9 @@ TEST(CopyTests, TestCopyDispatchImplicit) ASSERT_EQ(13, vec.front()); } -template -__host__ __device__ -OutputIterator copy_if(my_system &system, InputIterator, InputIterator, OutputIterator result, Predicate) +template +__host__ __device__ OutputIterator + copy_if(my_system& system, InputIterator, InputIterator, OutputIterator result, Predicate) { system.validate_dispatch(); return result; @@ -547,18 +600,14 @@ TEST(CopyTests, TestCopyIfDispatchExplicit) thrust::device_vector vec(1); my_system sys(0); - thrust::copy_if(sys, - vec.begin(), - vec.end(), - vec.begin(), - 0); + thrust::copy_if(sys, vec.begin(), vec.end(), vec.begin(), 0); ASSERT_EQ(true, sys.is_valid()); } -template -__host__ __device__ -OutputIterator copy_if(my_tag, InputIterator, InputIterator, OutputIterator result, Predicate) +template +__host__ __device__ OutputIterator + copy_if(my_tag, InputIterator, InputIterator, OutputIterator result, Predicate) { *result = 13; return result; @@ -576,9 +625,16 @@ TEST(CopyTests, TestCopyIfDispatchImplicit) ASSERT_EQ(13, vec.front()); } -template -__host__ __device__ -OutputIterator copy_if(my_system &system, InputIterator1, InputIterator1, InputIterator2, OutputIterator result, Predicate) +template +__host__ __device__ OutputIterator copy_if(my_system& system, + InputIterator1, + InputIterator1, + InputIterator2, + OutputIterator result, + Predicate) { system.validate_dispatch(); return result; @@ -589,19 +645,17 @@ TEST(CopyTests, TestCopyIfStencilDispatchExplicit) thrust::device_vector vec(1); my_system sys(0); - thrust::copy_if(sys, - vec.begin(), - vec.end(), - vec.begin(), - vec.begin(), - 0); + thrust::copy_if(sys, vec.begin(), vec.end(), vec.begin(), vec.begin(), 0); ASSERT_EQ(true, sys.is_valid()); } -template -__host__ __device__ -OutputIterator copy_if(my_tag, InputIterator1, InputIterator1, InputIterator2, OutputIterator result, Predicate) +template +__host__ __device__ OutputIterator + copy_if(my_tag, InputIterator1, InputIterator1, InputIterator2, OutputIterator result, Predicate) { *result = 13; return result; diff --git a/test/test_count.cpp b/test/test_count.cpp index c87faf56c..2952d4c48 100644 --- a/test/test_count.cpp +++ b/test/test_count.cpp @@ -51,14 +51,21 @@ TYPED_TEST(CountPrimitiveTests, TestCount) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - size_t cpu_result = thrust::count(h_data.begin(), h_data.end(), T(5)); - size_t gpu_result = thrust::count(d_data.begin(), d_data.end(), T(5)); + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - ASSERT_EQ(cpu_result, gpu_result); + size_t cpu_result = thrust::count(h_data.begin(), h_data.end(), T(5)); + size_t gpu_result = thrust::count(d_data.begin(), d_data.end(), T(5)); + + ASSERT_EQ(cpu_result, gpu_result); + } } } @@ -94,13 +101,22 @@ TYPED_TEST(CountTests, TestCountIf) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - size_t cpu_result = thrust::count_if(h_data.begin(), h_data.end(), greater_than_five()); - size_t gpu_result = thrust::count_if(d_data.begin(), d_data.end(), greater_than_five()); - - ASSERT_EQ(cpu_result, gpu_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + size_t cpu_result + = thrust::count_if(h_data.begin(), h_data.end(), greater_than_five()); + size_t gpu_result + = thrust::count_if(d_data.begin(), d_data.end(), greater_than_five()); + + ASSERT_EQ(cpu_result, gpu_result); + } } } diff --git a/test/test_counting_iterator.cpp b/test/test_counting_iterator.cpp index 041b52e82..062eeabe5 100644 --- a/test/test_counting_iterator.cpp +++ b/test/test_counting_iterator.cpp @@ -189,26 +189,38 @@ TEST(CountingIteratorTests, TestCountingIteratorLowerBound) size_t n = 10000; const size_t M = 100; - thrust::host_vector h_data = get_random_data( - n, std::numeric_limits::min(), std::numeric_limits::max()); - for(unsigned int i = 0; i < n; ++i) - h_data[i] %= M; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::sort(h_data.begin(), h_data.end()); + thrust::host_vector h_data + = get_random_data(n, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + for(unsigned int i = 0; i < n; ++i) + h_data[i] %= M; - thrust::device_vector d_data = h_data; + thrust::sort(h_data.begin(), h_data.end()); - thrust::counting_iterator search_begin(0); - thrust::counting_iterator search_end(M); + thrust::device_vector d_data = h_data; - thrust::host_vector h_result(M); - thrust::device_vector d_result(M); + thrust::counting_iterator search_begin(0); + thrust::counting_iterator search_end(M); - thrust::lower_bound(h_data.begin(), h_data.end(), search_begin, search_end, h_result.begin()); + thrust::host_vector h_result(M); + thrust::device_vector d_result(M); - thrust::lower_bound(d_data.begin(), d_data.end(), search_begin, search_end, d_result.begin()); + thrust::lower_bound( + h_data.begin(), h_data.end(), search_begin, search_end, h_result.begin()); - ASSERT_EQ(h_result, d_result); + thrust::lower_bound( + d_data.begin(), d_data.end(), search_begin, search_end, d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } TEST(CountingIteratorTests, TestCountingIteratorDifference) diff --git a/test/test_dereference.cpp b/test/test_dereference.cpp index 0c2660ae0..805797a00 100644 --- a/test/test_dereference.cpp +++ b/test/test_dereference.cpp @@ -45,41 +45,62 @@ void simple_copy(Iterator1 first1, Iterator1 last1, Iterator2 first2) TEST(DereferenceTests, TestDeviceDereferenceDeviceVectorIterator) { - thrust::device_vector input = get_random_data( - 100, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector output(input.size(), 0); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - simple_copy(input.begin(), input.end(), output.begin()); + thrust::device_vector input = get_random_data( + 100, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector output(input.size(), 0); - ASSERT_EQ(input, output); + simple_copy(input.begin(), input.end(), output.begin()); + + ASSERT_EQ(input, output); + } } TEST(DereferenceTests, TestDeviceDereferenceDevicePtr) { - thrust::device_vector input = get_random_data( - 100, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector output(input.size(), 0); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::device_vector input = get_random_data( + 100, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector output(input.size(), 0); - thrust::device_ptr _first1 = &input[0]; - thrust::device_ptr _last1 = _first1 + input.size(); - thrust::device_ptr _first2 = &output[0]; + thrust::device_ptr _first1 = &input[0]; + thrust::device_ptr _last1 = _first1 + input.size(); + thrust::device_ptr _first2 = &output[0]; - simple_copy(_first1, _last1, _first2); + simple_copy(_first1, _last1, _first2); - ASSERT_EQ(input, output); + ASSERT_EQ(input, output); + } } TEST(DereferenceTests, TestDeviceDereferenceTransformIterator) { - thrust::device_vector input = get_random_data( - 100, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector output(input.size(), 0); - - simple_copy(thrust::make_transform_iterator(input.begin(), thrust::identity()), - thrust::make_transform_iterator(input.end(), thrust::identity()), - output.begin()); - - ASSERT_EQ(input, output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::device_vector input = get_random_data( + 100, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector output(input.size(), 0); + + simple_copy(thrust::make_transform_iterator(input.begin(), thrust::identity()), + thrust::make_transform_iterator(input.end(), thrust::identity()), + output.begin()); + + ASSERT_EQ(input, output); + } } TEST(DereferenceTests, TestDeviceDereferenceCountingIterator) @@ -114,4 +135,4 @@ TEST(DereferenceTests, TestDeviceDereferenceTransformedCountingIterator) ASSERT_EQ(output[2], -3); ASSERT_EQ(output[3], -4); ASSERT_EQ(output[4], -5); -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_device_delete.cpp b/test/test_device_delete.cpp index b42a9eb10..fa7c6f8b8 100644 --- a/test/test_device_delete.cpp +++ b/test/test_device_delete.cpp @@ -29,8 +29,7 @@ struct Foo { } - __host__ __device__ - ~Foo(void) + __host__ __device__ ~Foo(void) { #if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__) // __device__ overload diff --git a/test/test_equal.cpp b/test/test_equal.cpp index 0e6d46bd3..98802798b 100644 --- a/test/test_equal.cpp +++ b/test/test_equal.cpp @@ -64,48 +64,62 @@ TYPED_TEST(EqualsPrimitiveTests, TestEqual) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_data2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_data1 = h_data1; - thrust::device_vector d_data2 = h_data2; - - //empty ranges - ASSERT_EQ(thrust::equal(h_data1.begin(), h_data1.begin(), h_data1.begin()), true); - ASSERT_EQ(thrust::equal(d_data1.begin(), d_data1.begin(), d_data1.begin()), true); - - //symmetric cases - ASSERT_EQ(thrust::equal(h_data1.begin(), h_data1.end(), h_data1.begin()), true); - ASSERT_EQ(thrust::equal(d_data1.begin(), d_data1.end(), d_data1.begin()), true); - - if(size > 0) + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - h_data1[0] = 0; - h_data2[0] = 1; - d_data1[0] = 0; - d_data2[0] = 1; - - //different vectors - ASSERT_EQ(thrust::equal(h_data1.begin(), h_data1.end(), h_data2.begin()), false); - ASSERT_EQ(thrust::equal(d_data1.begin(), d_data1.end(), d_data2.begin()), false); - - //different predicates - ASSERT_EQ(thrust::equal( - h_data1.begin(), h_data1.begin() + 1, h_data2.begin(), thrust::less()), - true); - ASSERT_EQ(thrust::equal( - d_data1.begin(), d_data1.begin() + 1, d_data2.begin(), thrust::less()), - true); - ASSERT_EQ( - thrust::equal( - h_data1.begin(), h_data1.begin() + 1, h_data2.begin(), thrust::greater()), - false); - ASSERT_EQ( - thrust::equal( - d_data1.begin(), d_data1.begin() + 1, d_data2.begin(), thrust::greater()), - false); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_data2 = get_random_data( + size, std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_data1 = h_data1; + thrust::device_vector d_data2 = h_data2; + + //empty ranges + ASSERT_EQ(thrust::equal(h_data1.begin(), h_data1.begin(), h_data1.begin()), true); + ASSERT_EQ(thrust::equal(d_data1.begin(), d_data1.begin(), d_data1.begin()), true); + + //symmetric cases + ASSERT_EQ(thrust::equal(h_data1.begin(), h_data1.end(), h_data1.begin()), true); + ASSERT_EQ(thrust::equal(d_data1.begin(), d_data1.end(), d_data1.begin()), true); + + if(size > 0) + { + h_data1[0] = 0; + h_data2[0] = 1; + d_data1[0] = 0; + d_data2[0] = 1; + + //different vectors + ASSERT_EQ(thrust::equal(h_data1.begin(), h_data1.end(), h_data2.begin()), false); + ASSERT_EQ(thrust::equal(d_data1.begin(), d_data1.end(), d_data2.begin()), false); + + //different predicates + ASSERT_EQ( + thrust::equal( + h_data1.begin(), h_data1.begin() + 1, h_data2.begin(), thrust::less()), + true); + ASSERT_EQ( + thrust::equal( + d_data1.begin(), d_data1.begin() + 1, d_data2.begin(), thrust::less()), + true); + ASSERT_EQ(thrust::equal(h_data1.begin(), + h_data1.begin() + 1, + h_data2.begin(), + thrust::greater()), + false); + ASSERT_EQ(thrust::equal(d_data1.begin(), + d_data1.begin() + 1, + d_data2.begin(), + thrust::greater()), + false); + } } } } @@ -143,4 +157,4 @@ TEST(EqualTests, TestEqualDispatchImplicit) thrust::retag(vec.begin())); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} diff --git a/test/test_fill.cpp b/test/test_fill.cpp index 2c23ba6cc..ad604cdfd 100644 --- a/test/test_fill.cpp +++ b/test/test_fill.cpp @@ -114,47 +114,54 @@ TYPED_TEST(FillPrimitiveTests, TestFill) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::fill(h_data.begin() + std::min((size_t)1, size), - h_data.begin() + std::min((size_t)3, size), - T(0)); - thrust::fill(d_data.begin() + std::min((size_t)1, size), - d_data.begin() + std::min((size_t)3, size), - T(0)); + thrust::device_vector d_data = h_data; - ASSERT_EQ(h_data, d_data); + thrust::fill(h_data.begin() + std::min((size_t)1, size), + h_data.begin() + std::min((size_t)3, size), + T(0)); + thrust::fill(d_data.begin() + std::min((size_t)1, size), + d_data.begin() + std::min((size_t)3, size), + T(0)); - thrust::fill(h_data.begin() + std::min((size_t)117, size), - h_data.begin() + std::min((size_t)367, size), - T(1)); - thrust::fill(d_data.begin() + std::min((size_t)117, size), - d_data.begin() + std::min((size_t)367, size), - T(1)); + ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_data, d_data); + thrust::fill(h_data.begin() + std::min((size_t)117, size), + h_data.begin() + std::min((size_t)367, size), + T(1)); + thrust::fill(d_data.begin() + std::min((size_t)117, size), + d_data.begin() + std::min((size_t)367, size), + T(1)); - thrust::fill(h_data.begin() + std::min((size_t)8, size), - h_data.begin() + std::min((size_t)259, size), - T(2)); - thrust::fill(d_data.begin() + std::min((size_t)8, size), - d_data.begin() + std::min((size_t)259, size), - T(2)); + ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_data, d_data); + thrust::fill(h_data.begin() + std::min((size_t)8, size), + h_data.begin() + std::min((size_t)259, size), + T(2)); + thrust::fill(d_data.begin() + std::min((size_t)8, size), + d_data.begin() + std::min((size_t)259, size), + T(2)); - thrust::fill(h_data.begin() + std::min((size_t)3, size), h_data.end(), T(3)); - thrust::fill(d_data.begin() + std::min((size_t)3, size), d_data.end(), T(3)); + ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_data, d_data); + thrust::fill(h_data.begin() + std::min((size_t)3, size), h_data.end(), T(3)); + thrust::fill(d_data.begin() + std::min((size_t)3, size), d_data.end(), T(3)); - thrust::fill(h_data.begin(), h_data.end(), T(4)); - thrust::fill(d_data.begin(), d_data.end(), T(4)); + ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_data, d_data); + thrust::fill(h_data.begin(), h_data.end(), T(4)); + thrust::fill(d_data.begin(), d_data.end(), T(4)); + + ASSERT_EQ(h_data, d_data); + } } } @@ -254,45 +261,52 @@ TYPED_TEST(FillPrimitiveTests, TestFillN) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_data = h_data; + thrust::device_vector d_data = h_data; - size_t begin_offset = std::min(1, size); - thrust::fill_n( - h_data.begin() + begin_offset, std::min((size_t)3, size) - begin_offset, T(0)); - thrust::fill_n( - d_data.begin() + begin_offset, std::min((size_t)3, size) - begin_offset, T(0)); + size_t begin_offset = std::min(1, size); + thrust::fill_n( + h_data.begin() + begin_offset, std::min((size_t)3, size) - begin_offset, T(0)); + thrust::fill_n( + d_data.begin() + begin_offset, std::min((size_t)3, size) - begin_offset, T(0)); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); - begin_offset = std::min(117, size); - thrust::fill_n( - h_data.begin() + begin_offset, std::min((size_t)367, size) - begin_offset, T(1)); - thrust::fill_n( - d_data.begin() + begin_offset, std::min((size_t)367, size) - begin_offset, T(1)); + begin_offset = std::min(117, size); + thrust::fill_n( + h_data.begin() + begin_offset, std::min((size_t)367, size) - begin_offset, T(1)); + thrust::fill_n( + d_data.begin() + begin_offset, std::min((size_t)367, size) - begin_offset, T(1)); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); - begin_offset = std::min(8, size); - thrust::fill_n( - h_data.begin() + begin_offset, std::min((size_t)259, size) - begin_offset, T(2)); - thrust::fill_n( - d_data.begin() + begin_offset, std::min((size_t)259, size) - begin_offset, T(2)); + begin_offset = std::min(8, size); + thrust::fill_n( + h_data.begin() + begin_offset, std::min((size_t)259, size) - begin_offset, T(2)); + thrust::fill_n( + d_data.begin() + begin_offset, std::min((size_t)259, size) - begin_offset, T(2)); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); - begin_offset = std::min(3, size); - thrust::fill_n(h_data.begin() + begin_offset, h_data.size() - begin_offset, T(3)); - thrust::fill_n(d_data.begin() + begin_offset, d_data.size() - begin_offset, T(3)); + begin_offset = std::min(3, size); + thrust::fill_n(h_data.begin() + begin_offset, h_data.size() - begin_offset, T(3)); + thrust::fill_n(d_data.begin() + begin_offset, d_data.size() - begin_offset, T(3)); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); - thrust::fill_n(h_data.begin(), h_data.size(), T(4)); - thrust::fill_n(d_data.begin(), d_data.size(), T(4)); + thrust::fill_n(h_data.begin(), h_data.size(), T(4)); + thrust::fill_n(d_data.begin(), d_data.size(), T(4)); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); + } } } @@ -486,4 +500,4 @@ TEST(FillTests, TestFillNDispatchImplicit) thrust::fill_n(thrust::retag(vec.begin()), vec.size(), 0); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_find.cpp b/test/test_find.cpp index b4e2ea9cb..1d18570ec 100644 --- a/test/test_find.cpp +++ b/test/test_find.cpp @@ -253,23 +253,30 @@ TYPED_TEST(FindTests, TestFind) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - HostIterator h_iter; - DeviceIterator d_iter; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - h_iter = thrust::find(h_data.begin(), h_data.end(), T(0)); - d_iter = thrust::find(d_data.begin(), d_data.end(), T(0)); - ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + HostIterator h_iter; + DeviceIterator d_iter; - for(size_t i = 1; i < size; i *= 2) - { - T sample = h_data[i]; - h_iter = thrust::find(h_data.begin(), h_data.end(), sample); - d_iter = thrust::find(d_data.begin(), d_data.end(), sample); + h_iter = thrust::find(h_data.begin(), h_data.end(), T(0)); + d_iter = thrust::find(d_data.begin(), d_data.end(), T(0)); ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + + for(size_t i = 1; i < size; i *= 2) + { + T sample = h_data[i]; + h_iter = thrust::find(h_data.begin(), h_data.end(), sample); + d_iter = thrust::find(d_data.begin(), d_data.end(), sample); + ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + } } } } @@ -285,23 +292,32 @@ TYPED_TEST(FindTests, TestFindIf) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - HostIterator h_iter; - DeviceIterator d_iter; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - h_iter = thrust::find_if(h_data.begin(), h_data.end(), equal_to_value_pred(0)); - d_iter = thrust::find_if(d_data.begin(), d_data.end(), equal_to_value_pred(0)); - ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + HostIterator h_iter; + DeviceIterator d_iter; - for(size_t i = 1; i < size; i *= 2) - { - T sample = h_data[i]; - h_iter = thrust::find_if(h_data.begin(), h_data.end(), equal_to_value_pred(sample)); - d_iter = thrust::find_if(d_data.begin(), d_data.end(), equal_to_value_pred(sample)); + h_iter = thrust::find_if(h_data.begin(), h_data.end(), equal_to_value_pred(0)); + d_iter = thrust::find_if(d_data.begin(), d_data.end(), equal_to_value_pred(0)); ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + + for(size_t i = 1; i < size; i *= 2) + { + T sample = h_data[i]; + h_iter + = thrust::find_if(h_data.begin(), h_data.end(), equal_to_value_pred(sample)); + d_iter + = thrust::find_if(d_data.begin(), d_data.end(), equal_to_value_pred(sample)); + ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + } } } } @@ -317,25 +333,34 @@ TYPED_TEST(FindTests, TestFindIfNot) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - HostIterator h_iter; - DeviceIterator d_iter; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - h_iter = thrust::find_if_not(h_data.begin(), h_data.end(), not_equal_to_value_pred(0)); - d_iter = thrust::find_if_not(d_data.begin(), d_data.end(), not_equal_to_value_pred(0)); - ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + HostIterator h_iter; + DeviceIterator d_iter; - for(size_t i = 1; i < size; i *= 2) - { - T sample = h_data[i]; - h_iter = thrust::find_if_not( - h_data.begin(), h_data.end(), not_equal_to_value_pred(sample)); - d_iter = thrust::find_if_not( - d_data.begin(), d_data.end(), not_equal_to_value_pred(sample)); + h_iter + = thrust::find_if_not(h_data.begin(), h_data.end(), not_equal_to_value_pred(0)); + d_iter + = thrust::find_if_not(d_data.begin(), d_data.end(), not_equal_to_value_pred(0)); ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + + for(size_t i = 1; i < size; i *= 2) + { + T sample = h_data[i]; + h_iter = thrust::find_if_not( + h_data.begin(), h_data.end(), not_equal_to_value_pred(sample)); + d_iter = thrust::find_if_not( + d_data.begin(), d_data.end(), not_equal_to_value_pred(sample)); + ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + } } } } diff --git a/test/test_for_each.cpp b/test/test_for_each.cpp index 77fe6f47c..e1302a4ee 100644 --- a/test/test_for_each.cpp +++ b/test/test_for_each.cpp @@ -328,31 +328,38 @@ TYPED_TEST(ForEachPrimitiveTests, TestForEach) { const size_t output_size = std::min((size_t)10, 2 * size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - for(size_t i = 0; i < size; i++) - h_input[i] = ((size_t)h_input[i]) % output_size; + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_input = h_input; + for(size_t i = 0; i < size; i++) + h_input[i] = ((size_t)h_input[i]) % output_size; - thrust::host_vector h_output(output_size, (T)0); - thrust::device_vector d_output(output_size, (T)0); + thrust::device_vector d_input = h_input; - mark_present_for_each h_f; - mark_present_for_each d_f; - h_f.ptr = &h_output[0]; - d_f.ptr = (&d_output[0]).get(); + thrust::host_vector h_output(output_size, (T)0); + thrust::device_vector d_output(output_size, (T)0); - typename thrust::host_vector::iterator h_result - = thrust::for_each(h_input.begin(), h_input.end(), h_f); + mark_present_for_each h_f; + mark_present_for_each d_f; + h_f.ptr = &h_output[0]; + d_f.ptr = (&d_output[0]).get(); - typename thrust::device_vector::iterator d_result - = thrust::for_each(d_input.begin(), d_input.end(), d_f); + typename thrust::host_vector::iterator h_result + = thrust::for_each(h_input.begin(), h_input.end(), h_f); - ASSERT_EQ(h_output, d_output); - ASSERT_EQ_QUIET(h_result, h_input.end()); - ASSERT_EQ_QUIET(d_result, d_input.end()); + typename thrust::device_vector::iterator d_result + = thrust::for_each(d_input.begin(), d_input.end(), d_f); + + ASSERT_EQ(h_output, d_output); + ASSERT_EQ_QUIET(h_result, h_input.end()); + ASSERT_EQ_QUIET(d_result, d_input.end()); + } } } @@ -364,31 +371,38 @@ TYPED_TEST(ForEachPrimitiveTests, TestForEachN) { const size_t output_size = std::min((size_t)10, 2 * size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - for(size_t i = 0; i < size; i++) - h_input[i] = ((size_t)h_input[i]) % output_size; + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_input = h_input; + for(size_t i = 0; i < size; i++) + h_input[i] = ((size_t)h_input[i]) % output_size; - thrust::host_vector h_output(output_size, (T)0); - thrust::device_vector d_output(output_size, (T)0); + thrust::device_vector d_input = h_input; - mark_present_for_each h_f; - mark_present_for_each d_f; - h_f.ptr = &h_output[0]; - d_f.ptr = (&d_output[0]).get(); + thrust::host_vector h_output(output_size, (T)0); + thrust::device_vector d_output(output_size, (T)0); - typename thrust::host_vector::iterator h_result - = thrust::for_each_n(h_input.begin(), h_input.size(), h_f); + mark_present_for_each h_f; + mark_present_for_each d_f; + h_f.ptr = &h_output[0]; + d_f.ptr = (&d_output[0]).get(); - typename thrust::device_vector::iterator d_result - = thrust::for_each_n(d_input.begin(), d_input.size(), d_f); + typename thrust::host_vector::iterator h_result + = thrust::for_each_n(h_input.begin(), h_input.size(), h_f); - ASSERT_EQ(h_output, d_output); - ASSERT_EQ_QUIET(h_result, h_input.end()); - ASSERT_EQ_QUIET(d_result, d_input.end()); + typename thrust::device_vector::iterator d_result + = thrust::for_each_n(d_input.begin(), d_input.size(), d_f); + + ASSERT_EQ(h_output, d_output); + ASSERT_EQ_QUIET(h_result, h_input.end()); + ASSERT_EQ_QUIET(d_result, d_input.end()); + } } } @@ -478,4 +492,4 @@ TEST(ForEachVectorTests, TestForEachNWithLargeTypes) _TestForEachNWithLargeTypes(); _TestForEachNWithLargeTypes(); _TestForEachNWithLargeTypes(); // fails on Vista 64 w/ VS2008 -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_gather.cpp b/test/test_gather.cpp index 0402b60e3..1b4ccb627 100644 --- a/test/test_gather.cpp +++ b/test/test_gather.cpp @@ -69,8 +69,8 @@ TYPED_TEST(GatherTests, GatherSimple) } template -OutputIterator gather( - my_system& system, InputIterator, InputIterator, RandomAccessIterator, OutputIterator result) +OutputIterator +gather(my_system& system, InputIterator, InputIterator, RandomAccessIterator, OutputIterator result) { system.validate_dispatch(); return result; @@ -88,7 +88,7 @@ TEST(GatherTests, GatherDispatchExplicit) template OutputIterator - gather(my_tag, InputIterator, InputIterator, RandomAccessIterator, OutputIterator result) +gather(my_tag, InputIterator, InputIterator, RandomAccessIterator, OutputIterator result) { *result = 13; return result; @@ -119,26 +119,38 @@ TYPED_TEST(PrimitiveGatherTests, Gather) const size_t source_size = std::min((size_t)10, 2 * size); // source vectors to gather from - thrust::host_vector h_source = get_random_data(source_size, min, max); - thrust::device_vector d_source = h_source; - - // gather indices - thrust::host_vector h_map = get_random_data(size, min, max); - - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % source_size; - - thrust::device_vector d_map = h_map; - - // gather destination - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - thrust::gather(h_map.begin(), h_map.end(), h_source.begin(), h_output.begin()); - thrust::gather(d_map.begin(), d_map.end(), d_source.begin(), d_output.begin()); - - thrust::host_vector d_output_h = d_output; - ASSERT_EQ(h_output, d_output_h); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_source = get_random_data(source_size, min, max, seed_value); + thrust::device_vector d_source = h_source; + + // gather indices + thrust::host_vector h_map = get_random_data( + size, + min, + max, + seed_value + seed_value_addition + ); + + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % source_size; + + thrust::device_vector d_map = h_map; + + // gather destination + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + thrust::gather(h_map.begin(), h_map.end(), h_source.begin(), h_output.begin()); + thrust::gather(d_map.begin(), d_map.end(), d_source.begin(), d_output.begin()); + + thrust::host_vector d_output_h = d_output; + ASSERT_EQ(h_output, d_output_h); + } } } @@ -155,27 +167,39 @@ TYPED_TEST(PrimitiveGatherTests, GatherToDiscardIterator) const size_t source_size = std::min((size_t)10, 2 * size); // source vectors to gather from - thrust::host_vector h_source = get_random_data(source_size, min, max); - thrust::device_vector d_source = h_source; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - // gather indices - thrust::host_vector h_map = get_random_data(size, min, max); + thrust::host_vector h_source = get_random_data(source_size, min, max, seed_value); + thrust::device_vector d_source = h_source; - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % source_size; + // gather indices + thrust::host_vector h_map = get_random_data( + size, + min, + max, + seed_value + seed_value_addition + ); - thrust::device_vector d_map = h_map; + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % source_size; - thrust::discard_iterator<> h_result = thrust::gather( - h_map.begin(), h_map.end(), h_source.begin(), thrust::make_discard_iterator()); + thrust::device_vector d_map = h_map; - thrust::discard_iterator<> d_result = thrust::gather( - d_map.begin(), d_map.end(), d_source.begin(), thrust::make_discard_iterator()); + thrust::discard_iterator<> h_result = thrust::gather( + h_map.begin(), h_map.end(), h_source.begin(), thrust::make_discard_iterator()); - thrust::discard_iterator<> reference(size); + thrust::discard_iterator<> d_result = thrust::gather( + d_map.begin(), d_map.end(), d_source.begin(), thrust::make_discard_iterator()); - ASSERT_EQ(reference, h_result); - ASSERT_EQ(reference, d_result); + thrust::discard_iterator<> reference(size); + + ASSERT_EQ(reference, h_result); + ASSERT_EQ(reference, d_result); + } } } @@ -296,44 +320,61 @@ TYPED_TEST(PrimitiveGatherTests, GatherIf) const size_t source_size = std::min((size_t)10, 2 * size); // source vectors to gather from - thrust::host_vector h_source = get_random_data(source_size, min, max); - thrust::device_vector d_source = h_source; - - // gather indices - thrust::host_vector h_map = get_random_data(size, min, max); - - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % source_size; - - thrust::device_vector d_map = h_map; - - // gather stencil - thrust::host_vector h_stencil = get_random_data(size, min, max); - - for(size_t i = 0; i < size; i++) - h_stencil[i] = h_stencil[i] % 2; - - thrust::device_vector d_stencil = h_stencil; - - // gather destination - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - thrust::gather_if(h_map.begin(), - h_map.end(), - h_stencil.begin(), - h_source.begin(), - h_output.begin(), - is_even_gather_if()); - thrust::gather_if(d_map.begin(), - d_map.end(), - d_stencil.begin(), - d_source.begin(), - d_output.begin(), - is_even_gather_if()); - - thrust::host_vector d_output_h = d_output; - ASSERT_EQ(h_output, d_output_h); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_source = get_random_data(source_size, min, max, seed_value); + thrust::device_vector d_source = h_source; + + // gather indices + thrust::host_vector h_map = get_random_data( + size, + min, + max, + seed_value + seed_value_addition + ); + + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % source_size; + + thrust::device_vector d_map = h_map; + + // gather stencil + thrust::host_vector h_stencil = get_random_data( + size, + min, + max, + seed_value + 2 * seed_value_addition + ); + + for(size_t i = 0; i < size; i++) + h_stencil[i] = h_stencil[i] % 2; + + thrust::device_vector d_stencil = h_stencil; + + // gather destination + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + thrust::gather_if(h_map.begin(), + h_map.end(), + h_stencil.begin(), + h_source.begin(), + h_output.begin(), + is_even_gather_if()); + thrust::gather_if(d_map.begin(), + d_map.end(), + d_stencil.begin(), + d_source.begin(), + d_output.begin(), + is_even_gather_if()); + + thrust::host_vector d_output_h = d_output; + ASSERT_EQ(h_output, d_output_h); + } } } @@ -350,43 +391,62 @@ TYPED_TEST(PrimitiveGatherTests, GatherIfToDiscardIterator) const size_t source_size = std::min((size_t)10, 2 * size); // source vectors to gather from - thrust::host_vector h_source = get_random_data(source_size, min, max); - thrust::device_vector d_source = h_source; - - // gather indices - thrust::host_vector h_map = get_random_data(size, min, max); - - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % source_size; - - thrust::device_vector d_map = h_map; - - // gather stencil - thrust::host_vector h_stencil = get_random_data(size, min, max); - - for(size_t i = 0; i < size; i++) - h_stencil[i] = h_stencil[i] % 2; - - thrust::device_vector d_stencil = h_stencil; - - thrust::discard_iterator<> h_result = thrust::gather_if(h_map.begin(), - h_map.end(), - h_stencil.begin(), - h_source.begin(), - thrust::make_discard_iterator(), - is_even_gather_if()); - - thrust::discard_iterator<> d_result = thrust::gather_if(d_map.begin(), - d_map.end(), - d_stencil.begin(), - d_source.begin(), - thrust::make_discard_iterator(), - is_even_gather_if()); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ(reference, h_result); - ASSERT_EQ(reference, d_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_source = get_random_data(source_size, min, max, seed_value); + thrust::device_vector d_source = h_source; + + // gather indices + thrust::host_vector h_map = get_random_data( + size, + min, + max, + seed_value + seed_value_addition + ); + + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % source_size; + + thrust::device_vector d_map = h_map; + + // gather stencil + thrust::host_vector h_stencil = get_random_data( + size, + min, + max, + seed_value + seed_value_addition + ); + + for(size_t i = 0; i < size; i++) + h_stencil[i] = h_stencil[i] % 2; + + thrust::device_vector d_stencil = h_stencil; + + thrust::discard_iterator<> h_result + = thrust::gather_if(h_map.begin(), + h_map.end(), + h_stencil.begin(), + h_source.begin(), + thrust::make_discard_iterator(), + is_even_gather_if()); + + thrust::discard_iterator<> d_result + = thrust::gather_if(d_map.begin(), + d_map.end(), + d_stencil.begin(), + d_source.begin(), + thrust::make_discard_iterator(), + is_even_gather_if()); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ(reference, h_result); + ASSERT_EQ(reference, d_result); + } } } diff --git a/test/test_generate.cpp b/test/test_generate.cpp index 2a9a40503..4aec719f6 100644 --- a/test/test_generate.cpp +++ b/test/test_generate.cpp @@ -252,4 +252,4 @@ TEST(GenerateTests, TestGenerateTuple) ASSERT_EQ_QUIET(h, d); } -__THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END \ No newline at end of file +__THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END \ No newline at end of file diff --git a/test/test_inner_product.cpp b/test/test_inner_product.cpp index d20441af3..29ef986e5 100644 --- a/test/test_inner_product.cpp +++ b/test/test_inner_product.cpp @@ -129,17 +129,29 @@ TYPED_TEST(PrimitiveInnerProductTests, InnerProductWithRandomData) T min = (T)std::numeric_limits::min() / (size + 1); T max = (T)std::numeric_limits::max() / (size + 1); - thrust::host_vector h_v1 = get_random_data(size, min, max); - thrust::host_vector h_v2 = get_random_data(size, min, max); - - thrust::device_vector d_v1 = h_v1; - thrust::device_vector d_v2 = h_v2; - - T init = 13; - - T expected = thrust::inner_product(h_v1.begin(), h_v1.end(), h_v2.begin(), init); - T result = thrust::inner_product(d_v1.begin(), d_v1.end(), d_v2.begin(), init); - - ASSERT_NEAR(clip_infinity(expected), clip_infinity(result), error_margin); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_v1 = get_random_data(size, min, max, seed_value); + thrust::host_vector h_v2 = get_random_data( + size, + min, + max, + seed_value + seed_value_addition + ); + + thrust::device_vector d_v1 = h_v1; + thrust::device_vector d_v2 = h_v2; + + T init = 13; + + T expected = thrust::inner_product(h_v1.begin(), h_v1.end(), h_v2.begin(), init); + T result = thrust::inner_product(d_v1.begin(), d_v1.end(), d_v2.begin(), init); + + ASSERT_NEAR(clip_infinity(expected), clip_infinity(result), error_margin); + } } }; diff --git a/test/test_is_partitioned.cpp b/test/test_is_partitioned.cpp index 037bf17a4..c2ac2afd9 100644 --- a/test/test_is_partitioned.cpp +++ b/test/test_is_partitioned.cpp @@ -76,16 +76,24 @@ TYPED_TEST(IsPartitionedVectorTests, TestIsPartitioned) const size_t n = (1 << 16) + 13; - Vector v = get_random_data(n, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - v[0] = 1; - v[1] = 0; + Vector v = get_random_data( + n, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - ASSERT_EQ(false, thrust::is_partitioned(v.begin(), v.end(), is_even())); + v[0] = 1; + v[1] = 0; - thrust::partition(v.begin(), v.end(), is_even()); + ASSERT_EQ(false, thrust::is_partitioned(v.begin(), v.end(), is_even())); - ASSERT_EQ(true, thrust::is_partitioned(v.begin(), v.end(), is_even())); + thrust::partition(v.begin(), v.end(), is_even()); + + ASSERT_EQ(true, thrust::is_partitioned(v.begin(), v.end(), is_even())); + } } template @@ -119,4 +127,4 @@ TEST(IsPartitionedTests, TestIsPartitionedDispatchImplicit) thrust::is_partitioned(thrust::retag(vec.begin()), thrust::retag(vec.end()), 0); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_is_sorted.cpp b/test/test_is_sorted.cpp index 5819be6a2..29ea2fb0c 100644 --- a/test/test_is_sorted.cpp +++ b/test/test_is_sorted.cpp @@ -82,16 +82,24 @@ TYPED_TEST(IsSortedVectorTests, TestIsSorted) const size_t n = (1 << 16) + 13; - Vector v = get_random_data(n, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - v[0] = 1; - v[1] = 0; + Vector v = get_random_data( + n, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - ASSERT_EQ(thrust::is_sorted(v.begin(), v.end()), false); + v[0] = 1; + v[1] = 0; + + ASSERT_EQ(thrust::is_sorted(v.begin(), v.end()), false); - thrust::sort(v.begin(), v.end()); + thrust::sort(v.begin(), v.end()); - ASSERT_EQ(thrust::is_sorted(v.begin(), v.end()), true); + ASSERT_EQ(thrust::is_sorted(v.begin(), v.end()), true); + } } template diff --git a/test/test_is_sorted_until.cpp b/test/test_is_sorted_until.cpp index 0f4a4ae0f..d4cf22b0b 100644 --- a/test/test_is_sorted_until.cpp +++ b/test/test_is_sorted_until.cpp @@ -106,16 +106,24 @@ TYPED_TEST(IsSortedUntilVectorTests, TestIsSortedUntil) const size_t n = (1 << 16) + 13; - Vector v = get_random_data(n, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - v[0] = 1; - v[1] = 0; + Vector v = get_random_data( + n, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - ASSERT_EQ_QUIET(v.begin() + 1, thrust::is_sorted_until(v.begin(), v.end())); + v[0] = 1; + v[1] = 0; - thrust::sort(v.begin(), v.end()); + ASSERT_EQ_QUIET(v.begin() + 1, thrust::is_sorted_until(v.begin(), v.end())); - ASSERT_EQ_QUIET(v.end(), thrust::is_sorted_until(v.begin(), v.end())); + thrust::sort(v.begin(), v.end()); + + ASSERT_EQ_QUIET(v.end(), thrust::is_sorted_until(v.begin(), v.end())); + } } template diff --git a/test/test_max_element.cpp b/test/test_max_element.cpp index c01299fd6..837fac8e0 100644 --- a/test/test_max_element.cpp +++ b/test/test_max_element.cpp @@ -79,23 +79,30 @@ TYPED_TEST(MaxElementPrimitiveTests, TestMaxElement) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - typename thrust::host_vector::iterator h_max - = thrust::max_element(h_data.begin(), h_data.end()); - typename thrust::device_vector::iterator d_max - = thrust::max_element(d_data.begin(), d_data.end()); - - ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); - - typename thrust::host_vector::iterator h_min - = thrust::max_element(h_data.begin(), h_data.end(), thrust::less()); - typename thrust::device_vector::iterator d_min - = thrust::max_element(d_data.begin(), d_data.end(), thrust::less()); - - ASSERT_EQ(h_min - h_data.begin(), d_min - d_data.begin()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + typename thrust::host_vector::iterator h_max + = thrust::max_element(h_data.begin(), h_data.end()); + typename thrust::device_vector::iterator d_max + = thrust::max_element(d_data.begin(), d_data.end()); + + ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); + + typename thrust::host_vector::iterator h_min + = thrust::max_element(h_data.begin(), h_data.end(), thrust::less()); + typename thrust::device_vector::iterator d_min + = thrust::max_element(d_data.begin(), d_data.end(), thrust::less()); + + ASSERT_EQ(h_min - h_data.begin(), d_min - d_data.begin()); + } } } @@ -130,4 +137,4 @@ TEST(MaxElementTests, TestMaxElementDispatchImplicit) thrust::max_element(thrust::retag(vec.begin()), thrust::retag(vec.end())); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_memory.cpp b/test/test_memory.cpp index 1b4d6026c..aebeb4af0 100644 --- a/test/test_memory.cpp +++ b/test/test_memory.cpp @@ -232,7 +232,7 @@ TEST(MemoryTests, TestFreeDispatchExplicit) template thrust::pair, std::ptrdiff_t> - get_temporary_buffer(my_memory_system& system, std::ptrdiff_t size) +get_temporary_buffer(my_memory_system& system, std::ptrdiff_t size) { system.validate_dispatch(); diff --git a/test/test_merge.cpp b/test/test_merge.cpp index eb706b84a..4cb6f72fb 100644 --- a/test/test_merge.cpp +++ b/test/test_merge.cpp @@ -90,8 +90,8 @@ TEST(MergeTests, MergeDispatchExplicit) } template -OutputIterator merge( - my_tag, InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator result) +OutputIterator +merge(my_tag, InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator result) { *result = 13; return result; @@ -117,42 +117,56 @@ TYPED_TEST(PrimitiveMergeTests, MergeWithRandomData) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); size_t expanded_sizes[] = {0, 1, size / 2, size, size + 1, 2 * size}; size_t num_expanded_sizes = sizeof(expanded_sizes) / sizeof(size_t); - - thrust::host_vector random = get_random_data( - size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), - 0, - 255); - thrust::host_vector h_a(random.begin(), random.begin() + size); - thrust::host_vector h_b(random.begin() + size, random.end()); - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - for(size_t i = 0; i < num_expanded_sizes; i++) + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t expanded_size = expanded_sizes[i]; - - thrust::host_vector h_result(size + expanded_size); - thrust::device_vector d_result(size + expanded_size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::merge( - h_a.begin(), h_a.end(), h_b.begin(), h_b.begin() + expanded_size, h_result.begin()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::merge( - d_a.begin(), d_a.end(), d_b.begin(), d_b.begin() + expanded_size, d_result.begin()); - d_result.resize(d_end - d_result.begin()); - - thrust::host_vector d_result_h = d_result; - ASSERT_EQ(h_result, d_result_h); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random = get_random_data( + size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), + 0, + 255, + seed_value); + thrust::host_vector h_a(random.begin(), random.begin() + size); + thrust::host_vector h_b(random.begin() + size, random.end()); + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + for(size_t i = 0; i < num_expanded_sizes; i++) + { + size_t expanded_size = expanded_sizes[i]; + + thrust::host_vector h_result(size + expanded_size); + thrust::device_vector d_result(size + expanded_size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::merge(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.begin() + expanded_size, + h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::merge(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.begin() + expanded_size, + d_result.begin()); + d_result.resize(d_end - d_result.begin()); + + thrust::host_vector d_result_h = d_result; + ASSERT_EQ(h_result, d_result_h); + } } } } @@ -164,27 +178,39 @@ TYPED_TEST(PrimitiveMergeTests, MergeToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_a = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - thrust::discard_iterator<> h_result = thrust::merge( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> h_result = thrust::merge( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), thrust::make_discard_iterator()); - thrust::discard_iterator<> d_result = thrust::merge( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> d_result = thrust::merge( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), thrust::make_discard_iterator()); - thrust::discard_iterator<> reference(2 * size); + thrust::discard_iterator<> reference(2 * size); - ASSERT_EQ(reference, h_result); - ASSERT_EQ(reference, d_result); + ASSERT_EQ(reference, h_result); + ASSERT_EQ(reference, d_result); + } } } @@ -195,29 +221,49 @@ TYPED_TEST(PrimitiveMergeTests, MergeDescending) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::stable_sort(h_a.begin(), h_a.end(), thrust::greater()); - thrust::stable_sort(h_b.begin(), h_b.end(), thrust::greater()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector h_a = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(d_a.size() + d_b.size()); + thrust::stable_sort(h_a.begin(), h_a.end(), thrust::greater()); + thrust::stable_sort(h_b.begin(), h_b.end(), thrust::greater()); - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - h_end = thrust::merge( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin(), thrust::greater()); + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(d_a.size() + d_b.size()); - d_end = thrust::merge( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin(), thrust::greater()); + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - ASSERT_EQ(h_result, d_result); + h_end = thrust::merge(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.end(), + h_result.begin(), + thrust::greater()); + + d_end = thrust::merge(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.end(), + d_result.begin(), + thrust::greater()); + + ASSERT_EQ(h_result, d_result); + } } } diff --git a/test/test_merge_by_key.cpp b/test/test_merge_by_key.cpp index a50f49a2e..b21db35ac 100644 --- a/test/test_merge_by_key.cpp +++ b/test/test_merge_by_key.cpp @@ -171,21 +171,133 @@ TYPED_TEST(PrimitiveMergeByKeyTests, TestMergeByKeyWithRandomData) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector random_keys = get_random_data(size, 0, 255); - thrust::host_vector random_vals = get_random_data(size, 0, 255); - - size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - size_t num_denominators = sizeof(denominators) / sizeof(size_t); - - for(size_t i = 0; i < num_denominators; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t size_a = size / denominators[i]; + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random_keys = get_random_data( + size, + 0, + 255, + seed_value + ); + thrust::host_vector random_vals = get_random_data( + size, + 0, + 255, + seed_value + seed_value_addition + ); + + size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + size_t num_denominators = sizeof(denominators) / sizeof(size_t); + + for(size_t i = 0; i < num_denominators; ++i) + { + size_t size_a = size / denominators[i]; + + thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); + thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + + thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); + thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + + thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); + thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); + + thrust::device_vector d_a_keys = h_a_keys; + thrust::device_vector d_b_keys = h_b_keys; + + thrust::device_vector d_a_vals = h_a_vals; + thrust::device_vector d_b_vals = h_b_vals; + + thrust::host_vector h_result_keys(size); + thrust::host_vector h_result_vals(size); + + thrust::device_vector d_result_keys(size); + thrust::device_vector d_result_vals(size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::merge_by_key(h_a_keys.begin(), + h_a_keys.end(), + h_b_keys.begin(), + h_b_keys.end(), + h_a_vals.begin(), + h_b_vals.begin(), + h_result_keys.begin(), + h_result_vals.begin()); + h_result_keys.erase(h_end.first, h_result_keys.end()); + h_result_vals.erase(h_end.second, h_result_vals.end()); + + d_end = thrust::merge_by_key(d_a_keys.begin(), + d_a_keys.end(), + d_b_keys.begin(), + d_b_keys.end(), + d_a_vals.begin(), + d_b_vals.begin(), + d_result_keys.begin(), + d_result_vals.begin()); + d_result_keys.erase(d_end.first, d_result_keys.end()); + d_result_vals.erase(d_end.second, d_result_vals.end()); + + thrust::host_vector d_result_keys_h = d_result_keys; + thrust::host_vector d_result_vals_h = d_result_vals; + + ASSERT_EQ(h_result_keys, d_result_keys_h); + ASSERT_EQ(h_result_vals, d_result_vals_h); + } + } + } +} - thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); - thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); +TYPED_TEST(PrimitiveMergeByKeyTests, MergeByKeyToDiscardIterator) +{ + using T = typename TestFixture::input_type; - thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); - thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + const std::vector sizes = get_sizes(); + for(auto size : sizes) + { + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_a_keys = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + ); + thrust::host_vector h_b_keys = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_a_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + thrust::host_vector h_b_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 3 * seed_value_addition + ); thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); @@ -196,106 +308,37 @@ TYPED_TEST(PrimitiveMergeByKeyTests, TestMergeByKeyWithRandomData) thrust::device_vector d_a_vals = h_a_vals; thrust::device_vector d_b_vals = h_b_vals; - thrust::host_vector h_result_keys(size); - thrust::host_vector h_result_vals(size); - - thrust::device_vector d_result_keys(size); - thrust::device_vector d_result_vals(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::merge_by_key(h_a_keys.begin(), - h_a_keys.end(), - h_b_keys.begin(), - h_b_keys.end(), - h_a_vals.begin(), - h_b_vals.begin(), - h_result_keys.begin(), - h_result_vals.begin()); - h_result_keys.erase(h_end.first, h_result_keys.end()); - h_result_vals.erase(h_end.second, h_result_vals.end()); - - d_end = thrust::merge_by_key(d_a_keys.begin(), - d_a_keys.end(), - d_b_keys.begin(), - d_b_keys.end(), - d_a_vals.begin(), - d_b_vals.begin(), - d_result_keys.begin(), - d_result_vals.begin()); - d_result_keys.erase(d_end.first, d_result_keys.end()); - d_result_vals.erase(d_end.second, d_result_vals.end()); - - thrust::host_vector d_result_keys_h = d_result_keys; - thrust::host_vector d_result_vals_h = d_result_vals; - - ASSERT_EQ(h_result_keys, d_result_keys_h); - ASSERT_EQ(h_result_vals, d_result_vals_h); + typedef thrust::pair, thrust::discard_iterator<>> + discard_pair; + + discard_pair h_result = thrust::merge_by_key(h_a_keys.begin(), + h_a_keys.end(), + h_b_keys.begin(), + h_b_keys.end(), + h_a_vals.begin(), + h_b_vals.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator()); + + discard_pair d_result = thrust::merge_by_key(d_a_keys.begin(), + d_a_keys.end(), + d_b_keys.begin(), + d_b_keys.end(), + d_a_vals.begin(), + d_b_vals.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator()); + + thrust::discard_iterator<> reference(2 * size); + + ASSERT_EQ(reference, h_result.first); + ASSERT_EQ(reference, h_result.second); + ASSERT_EQ(reference, d_result.first); + ASSERT_EQ(reference, d_result.second); } } } -TYPED_TEST(PrimitiveMergeByKeyTests, MergeByKeyToDiscardIterator) -{ - using T = typename TestFixture::input_type; - - const std::vector sizes = get_sizes(); - for(auto size : sizes) - { - thrust::host_vector h_a_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); - thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); - - thrust::device_vector d_a_keys = h_a_keys; - thrust::device_vector d_b_keys = h_b_keys; - - thrust::device_vector d_a_vals = h_a_vals; - thrust::device_vector d_b_vals = h_b_vals; - - typedef thrust::pair, thrust::discard_iterator<>> discard_pair; - - discard_pair h_result = thrust::merge_by_key(h_a_keys.begin(), - h_a_keys.end(), - h_b_keys.begin(), - h_b_keys.end(), - h_a_vals.begin(), - h_b_vals.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator()); - - discard_pair d_result = thrust::merge_by_key(d_a_keys.begin(), - d_a_keys.end(), - d_b_keys.begin(), - d_b_keys.end(), - d_a_vals.begin(), - d_b_vals.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator()); - - thrust::discard_iterator<> reference(2 * size); - - ASSERT_EQ(reference, h_result.first); - ASSERT_EQ(reference, h_result.second); - ASSERT_EQ(reference, d_result.first); - ASSERT_EQ(reference, d_result.second); - } -} - TYPED_TEST(PrimitiveMergeByKeyTests, MergeByKeyDescending) { using T = typename TestFixture::input_type; @@ -303,71 +346,89 @@ TYPED_TEST(PrimitiveMergeByKeyTests, MergeByKeyDescending) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector random_keys = get_random_data(size, 0, 255); - thrust::host_vector random_vals = get_random_data(size, 0, 255); - - size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - size_t num_denominators = sizeof(denominators) / sizeof(size_t); - - for(size_t i = 0; i < num_denominators; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t size_a = size / denominators[i]; - - thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); - thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); - - thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); - thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); - - thrust::stable_sort(h_a_keys.begin(), h_a_keys.end(), thrust::greater()); - thrust::stable_sort(h_b_keys.begin(), h_b_keys.end(), thrust::greater()); - - thrust::device_vector d_a_keys = h_a_keys; - thrust::device_vector d_b_keys = h_b_keys; - - thrust::device_vector d_a_vals = h_a_vals; - thrust::device_vector d_b_vals = h_b_vals; - - thrust::host_vector h_result_keys(size); - thrust::host_vector h_result_vals(size); - - thrust::device_vector d_result_keys(size); - thrust::device_vector d_result_vals(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::merge_by_key(h_a_keys.begin(), - h_a_keys.end(), - h_b_keys.begin(), - h_b_keys.end(), - h_a_vals.begin(), - h_b_vals.begin(), - h_result_keys.begin(), - h_result_vals.begin(), - thrust::greater()); - h_result_keys.erase(h_end.first, h_result_keys.end()); - h_result_vals.erase(h_end.second, h_result_vals.end()); - - d_end = thrust::merge_by_key(d_a_keys.begin(), - d_a_keys.end(), - d_b_keys.begin(), - d_b_keys.end(), - d_a_vals.begin(), - d_b_vals.begin(), - d_result_keys.begin(), - d_result_vals.begin(), - thrust::greater()); - d_result_keys.erase(d_end.first, d_result_keys.end()); - d_result_vals.erase(d_end.second, d_result_vals.end()); - - ASSERT_EQ(h_result_keys, d_result_keys); - ASSERT_EQ(h_result_vals, d_result_vals); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random_keys = get_random_data( + size, + 0, + 255, + seed_value + ); + thrust::host_vector random_vals = get_random_data( + size, + 0, + 255, + seed_value + seed_value_addition + ); + + size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + size_t num_denominators = sizeof(denominators) / sizeof(size_t); + + for(size_t i = 0; i < num_denominators; ++i) + { + size_t size_a = size / denominators[i]; + + thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); + thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + + thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); + thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + + thrust::stable_sort(h_a_keys.begin(), h_a_keys.end(), thrust::greater()); + thrust::stable_sort(h_b_keys.begin(), h_b_keys.end(), thrust::greater()); + + thrust::device_vector d_a_keys = h_a_keys; + thrust::device_vector d_b_keys = h_b_keys; + + thrust::device_vector d_a_vals = h_a_vals; + thrust::device_vector d_b_vals = h_b_vals; + + thrust::host_vector h_result_keys(size); + thrust::host_vector h_result_vals(size); + + thrust::device_vector d_result_keys(size); + thrust::device_vector d_result_vals(size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::merge_by_key(h_a_keys.begin(), + h_a_keys.end(), + h_b_keys.begin(), + h_b_keys.end(), + h_a_vals.begin(), + h_b_vals.begin(), + h_result_keys.begin(), + h_result_vals.begin(), + thrust::greater()); + h_result_keys.erase(h_end.first, h_result_keys.end()); + h_result_vals.erase(h_end.second, h_result_vals.end()); + + d_end = thrust::merge_by_key(d_a_keys.begin(), + d_a_keys.end(), + d_b_keys.begin(), + d_b_keys.end(), + d_a_vals.begin(), + d_b_vals.begin(), + d_result_keys.begin(), + d_result_vals.begin(), + thrust::greater()); + d_result_keys.erase(d_end.first, d_result_keys.end()); + d_result_vals.erase(d_end.second, d_result_vals.end()); + + ASSERT_EQ(h_result_keys, d_result_keys); + ASSERT_EQ(h_result_vals, d_result_vals); + } } } } diff --git a/test/test_min_element.cpp b/test/test_min_element.cpp index 1013dcd54..a3aff0739 100644 --- a/test/test_min_element.cpp +++ b/test/test_min_element.cpp @@ -79,23 +79,30 @@ TYPED_TEST(MinElementPrimitiveTests, TestMinElement) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - typename thrust::host_vector::iterator h_min - = thrust::min_element(h_data.begin(), h_data.end()); - typename thrust::device_vector::iterator d_min - = thrust::min_element(d_data.begin(), d_data.end()); - - ASSERT_EQ(h_data.begin() - h_min, d_data.begin() - d_min); - - typename thrust::host_vector::iterator h_max - = thrust::min_element(h_data.begin(), h_data.end(), thrust::greater()); - typename thrust::device_vector::iterator d_max - = thrust::min_element(d_data.begin(), d_data.end(), thrust::greater()); - - ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + typename thrust::host_vector::iterator h_min + = thrust::min_element(h_data.begin(), h_data.end()); + typename thrust::device_vector::iterator d_min + = thrust::min_element(d_data.begin(), d_data.end()); + + ASSERT_EQ(h_data.begin() - h_min, d_data.begin() - d_min); + + typename thrust::host_vector::iterator h_max + = thrust::min_element(h_data.begin(), h_data.end(), thrust::greater()); + typename thrust::device_vector::iterator d_max + = thrust::min_element(d_data.begin(), d_data.end(), thrust::greater()); + + ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); + } } } @@ -130,4 +137,4 @@ TEST(MinElementTests, TestMinElementDispatchImplicit) thrust::min_element(thrust::retag(vec.begin()), thrust::retag(vec.end())); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_minmax_element.cpp b/test/test_minmax_element.cpp index ef498d190..6dbdbb183 100644 --- a/test/test_minmax_element.cpp +++ b/test/test_minmax_element.cpp @@ -77,36 +77,47 @@ TYPED_TEST(MinMaxElementPrimitiveTests, TestMinmaxElement) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - typename thrust::host_vector::iterator h_min; - typename thrust::host_vector::iterator h_max; - typename thrust::device_vector::iterator d_min; - typename thrust::device_vector::iterator d_max; - - h_min = thrust::minmax_element(h_data.begin(), h_data.end()).first; - d_min = thrust::minmax_element(d_data.begin(), d_data.end()).first; - h_max = thrust::minmax_element(h_data.begin(), h_data.end()).second; - d_max = thrust::minmax_element(d_data.begin(), d_data.end()).second; - - ASSERT_EQ(h_min - h_data.begin(), d_min - d_data.begin()); - ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); - - h_max = thrust::minmax_element(h_data.begin(), h_data.end(), thrust::greater()).first; - d_max = thrust::minmax_element(d_data.begin(), d_data.end(), thrust::greater()).first; - h_min = thrust::minmax_element(h_data.begin(), h_data.end(), thrust::greater()).second; - d_min = thrust::minmax_element(d_data.begin(), d_data.end(), thrust::greater()).second; - - ASSERT_EQ(h_min - h_data.begin(), d_min - d_data.begin()); - ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + typename thrust::host_vector::iterator h_min; + typename thrust::host_vector::iterator h_max; + typename thrust::device_vector::iterator d_min; + typename thrust::device_vector::iterator d_max; + + h_min = thrust::minmax_element(h_data.begin(), h_data.end()).first; + d_min = thrust::minmax_element(d_data.begin(), d_data.end()).first; + h_max = thrust::minmax_element(h_data.begin(), h_data.end()).second; + d_max = thrust::minmax_element(d_data.begin(), d_data.end()).second; + + ASSERT_EQ(h_min - h_data.begin(), d_min - d_data.begin()); + ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); + + h_max + = thrust::minmax_element(h_data.begin(), h_data.end(), thrust::greater()).first; + d_max + = thrust::minmax_element(d_data.begin(), d_data.end(), thrust::greater()).first; + h_min + = thrust::minmax_element(h_data.begin(), h_data.end(), thrust::greater()).second; + d_min + = thrust::minmax_element(d_data.begin(), d_data.end(), thrust::greater()).second; + + ASSERT_EQ(h_min - h_data.begin(), d_min - d_data.begin()); + ASSERT_EQ(h_max - h_data.begin(), d_max - d_data.begin()); + } } } template thrust::pair - minmax_element(my_system& system, ForwardIterator first, ForwardIterator) +minmax_element(my_system& system, ForwardIterator first, ForwardIterator) { system.validate_dispatch(); return thrust::make_pair(first, first); @@ -124,7 +135,7 @@ TEST(MinmaxElementTests, TestMinmaxElementDispatchExplicit) template thrust::pair - minmax_element(my_tag, ForwardIterator first, ForwardIterator) +minmax_element(my_tag, ForwardIterator first, ForwardIterator) { *first = 13; return thrust::make_pair(first, first); @@ -137,4 +148,4 @@ TEST(MinmaxElementTests, TestMinmaxElementDispatchImplicit) thrust::minmax_element(thrust::retag(vec.begin()), thrust::retag(vec.end())); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_mismatch.cpp b/test/test_mismatch.cpp index 29adcb484..3aa6de37a 100644 --- a/test/test_mismatch.cpp +++ b/test/test_mismatch.cpp @@ -57,7 +57,7 @@ TYPED_TEST(MismatchTests, TestMismatchSimple) template thrust::pair - mismatch(my_system& system, InputIterator1 first, InputIterator1, InputIterator2) +mismatch(my_system& system, InputIterator1 first, InputIterator1, InputIterator2) { system.validate_dispatch(); return thrust::make_pair(first, first); @@ -75,7 +75,7 @@ TEST(MismatchTests, TestMismatchDispatchExplicit) template thrust::pair - mismatch(my_tag, InputIterator1 first, InputIterator1, InputIterator2) +mismatch(my_tag, InputIterator1 first, InputIterator1, InputIterator2) { *first = 13; return thrust::make_pair(first, first); diff --git a/test/test_pair.cpp b/test/test_pair.cpp index f0321a9d6..bb64c58dd 100644 --- a/test/test_pair.cpp +++ b/test/test_pair.cpp @@ -239,14 +239,21 @@ TYPED_TEST(PairTests, TestPairComparison) TYPED_TEST(PairTests, TestPairGet) { using T = typename TestFixture::input_type; - thrust::host_vector data - = get_random_data(2, std::numeric_limits::min(), std::numeric_limits::max()); - ; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::pair p(data[0], data[1]); + thrust::host_vector data = get_random_data( + 2, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + ; - ASSERT_EQ(data[0], thrust::get<0>(p)); - ASSERT_EQ(data[1], thrust::get<1>(p)); + thrust::pair p(data[0], data[1]); + + ASSERT_EQ(data[0], thrust::get<0>(p)); + ASSERT_EQ(data[1], thrust::get<1>(p)); + } } TEST(PairTests, TestPairTupleSize) diff --git a/test/test_pair_reduce.cpp b/test/test_pair_reduce.cpp index d5e8ff453..b57d577a8 100644 --- a/test/test_pair_reduce.cpp +++ b/test/test_pair_reduce.cpp @@ -49,32 +49,43 @@ TYPED_TEST(PairReduceTests, TestPairReduce) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_p2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; + thrust::host_vector h_p1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + ; - thrust::host_vector

h_pairs(size); + thrust::host_vector h_p2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition); + ; - // zip up pairs on the host - thrust::transform( - h_p1.begin(), h_p1.end(), h_p2.begin(), h_pairs.begin(), make_pair_functor()); + thrust::host_vector

h_pairs(size); - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_p2 = h_p2; - thrust::device_vector

d_pairs = h_pairs; + // zip up pairs on the host + thrust::transform( + h_p1.begin(), h_p1.end(), h_p2.begin(), h_pairs.begin(), make_pair_functor()); - P init = thrust::make_pair(13, 13); + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_p2 = h_p2; + thrust::device_vector

d_pairs = h_pairs; - // reduce on the host - P h_result = thrust::reduce(h_pairs.begin(), h_pairs.end(), init, add_pairs()); + P init = thrust::make_pair(13, 13); - // reduce on the device - P d_result = thrust::reduce(d_pairs.begin(), d_pairs.end(), init, add_pairs()); + // reduce on the host + P h_result = thrust::reduce(h_pairs.begin(), h_pairs.end(), init, add_pairs()); - ASSERT_EQ_QUIET(h_result, d_result); + // reduce on the device + P d_result = thrust::reduce(d_pairs.begin(), d_pairs.end(), init, add_pairs()); + + ASSERT_EQ_QUIET(h_result, d_result); + } } } diff --git a/test/test_pair_scan.cpp b/test/test_pair_scan.cpp index 0c6192447..9ae98aedb 100644 --- a/test/test_pair_scan.cpp +++ b/test/test_pair_scan.cpp @@ -61,60 +61,73 @@ TYPED_TEST(PairScanVariablesTests, TestPairScan) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); typedef thrust::pair P; - - thrust::host_vector h_p1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_p2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector

h_pairs(size); - thrust::host_vector

h_output(size); - - // zip up pairs on the host - thrust::transform( - h_p1.begin(), h_p1.end(), h_p2.begin(), h_pairs.begin(), make_pair_functor()); - - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_p2 = h_p2; - thrust::device_vector

d_pairs = h_pairs; - thrust::device_vector

d_output(size); - - P init = thrust::make_pair(13, 13); - - // scan with plus - thrust::inclusive_scan(h_pairs.begin(), h_pairs.end(), h_output.begin(), add_pairs()); - thrust::inclusive_scan(d_pairs.begin(), d_pairs.end(), d_output.begin(), add_pairs()); - ASSERT_EQ_QUIET(h_output, d_output); - - // scan with maximum - // TODO: Workaround - thrust::inclusive_scan(h_pairs.begin(), - h_pairs.end(), - h_output.begin(), - maximum_pairs() /*thrust::maximum

()*/); - thrust::inclusive_scan(d_pairs.begin(), - d_pairs.end(), - d_output.begin(), - maximum_pairs() /*thrust::maximum

()*/); - ASSERT_EQ_QUIET(h_output, d_output); - - // scan with plus - thrust::exclusive_scan(h_pairs.begin(), h_pairs.end(), h_output.begin(), init, add_pairs()); - thrust::exclusive_scan(d_pairs.begin(), d_pairs.end(), d_output.begin(), init, add_pairs()); - ASSERT_EQ_QUIET(h_output, d_output); - - // scan with maximum - // TODO: Workaround - thrust::exclusive_scan(h_pairs.begin(), - h_pairs.end(), - h_output.begin(), - init, - maximum_pairs() /*thrust::maximum

()*/); - thrust::exclusive_scan(d_pairs.begin(), - d_pairs.end(), - d_output.begin(), - init, - maximum_pairs() /*thrust::maximum

()*/); - ASSERT_EQ_QUIET(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_p1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_p2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector

h_pairs(size); + thrust::host_vector

h_output(size); + + // zip up pairs on the host + thrust::transform( + h_p1.begin(), h_p1.end(), h_p2.begin(), h_pairs.begin(), make_pair_functor()); + + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_p2 = h_p2; + thrust::device_vector

d_pairs = h_pairs; + thrust::device_vector

d_output(size); + + P init = thrust::make_pair(13, 13); + + // scan with plus + thrust::inclusive_scan(h_pairs.begin(), h_pairs.end(), h_output.begin(), add_pairs()); + thrust::inclusive_scan(d_pairs.begin(), d_pairs.end(), d_output.begin(), add_pairs()); + ASSERT_EQ_QUIET(h_output, d_output); + + // scan with maximum + // TODO: Workaround + thrust::inclusive_scan(h_pairs.begin(), + h_pairs.end(), + h_output.begin(), + maximum_pairs() /*thrust::maximum

()*/); + thrust::inclusive_scan(d_pairs.begin(), + d_pairs.end(), + d_output.begin(), + maximum_pairs() /*thrust::maximum

()*/); + ASSERT_EQ_QUIET(h_output, d_output); + + // scan with plus + thrust::exclusive_scan( + h_pairs.begin(), h_pairs.end(), h_output.begin(), init, add_pairs()); + thrust::exclusive_scan( + d_pairs.begin(), d_pairs.end(), d_output.begin(), init, add_pairs()); + ASSERT_EQ_QUIET(h_output, d_output); + + // scan with maximum + // TODO: Workaround + thrust::exclusive_scan(h_pairs.begin(), + h_pairs.end(), + h_output.begin(), + init, + maximum_pairs() /*thrust::maximum

()*/); + thrust::exclusive_scan(d_pairs.begin(), + d_pairs.end(), + d_output.begin(), + init, + maximum_pairs() /*thrust::maximum

()*/); + ASSERT_EQ_QUIET(h_output, d_output); + } } } diff --git a/test/test_pair_sort.cpp b/test/test_pair_sort.cpp index 3d32d7945..83ec10b58 100644 --- a/test/test_pair_sort.cpp +++ b/test/test_pair_sort.cpp @@ -40,34 +40,44 @@ TYPED_TEST(PairSortTests, TestPairStableSortByKey) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_p2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; + thrust::host_vector h_p1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector

h_pairs(size); + thrust::host_vector h_p2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - thrust::host_vector h_values(size); - thrust::sequence(h_values.begin(), h_values.end()); + thrust::host_vector

h_pairs(size); - // zip up pairs on the host - thrust::transform( - h_p1.begin(), h_p1.end(), h_p2.begin(), h_pairs.begin(), make_pair_functor()); + thrust::host_vector h_values(size); + thrust::sequence(h_values.begin(), h_values.end()); - // device arrays - thrust::device_vector

d_pairs = h_pairs; - thrust::device_vector d_values = h_values; + // zip up pairs on the host + thrust::transform( + h_p1.begin(), h_p1.end(), h_p2.begin(), h_pairs.begin(), make_pair_functor()); - // sort on the host - thrust::stable_sort_by_key(h_pairs.begin(), h_pairs.end(), h_values.begin()); + // device arrays + thrust::device_vector

d_pairs = h_pairs; + thrust::device_vector d_values = h_values; - // sort on the device - thrust::stable_sort_by_key(d_pairs.begin(), d_pairs.end(), d_values.begin()); + // sort on the host + thrust::stable_sort_by_key(h_pairs.begin(), h_pairs.end(), h_values.begin()); - ASSERT_EQ_QUIET(h_pairs, d_pairs); - ASSERT_EQ_QUIET(h_values, d_values); + // sort on the device + thrust::stable_sort_by_key(d_pairs.begin(), d_pairs.end(), d_values.begin()); + + ASSERT_EQ_QUIET(h_pairs, d_pairs); + ASSERT_EQ_QUIET(h_values, d_values); + } } } diff --git a/test/test_pair_transform.cpp b/test/test_pair_transform.cpp index 5aef2e631..fa22f1317 100644 --- a/test/test_pair_transform.cpp +++ b/test/test_pair_transform.cpp @@ -50,38 +50,48 @@ TYPED_TEST(PairTransformTests, TestPairTransform) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_p1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_p2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; + thrust::host_vector h_p1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector

h_result(size); + thrust::host_vector h_p2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - thrust::device_vector d_p1 = h_p1; - thrust::device_vector d_p2 = h_p2; - thrust::device_vector

d_result(size); + thrust::host_vector

h_result(size); - // zip up pairs on the host - thrust::transform( - h_p1.begin(), h_p1.end(), h_p2.begin(), h_result.begin(), make_pair_functor()); + thrust::device_vector d_p1 = h_p1; + thrust::device_vector d_p2 = h_p2; + thrust::device_vector

d_result(size); - // zip up pairs on the device - thrust::transform( - d_p1.begin(), d_p1.end(), d_p2.begin(), d_result.begin(), make_pair_functor()); + // zip up pairs on the host + thrust::transform( + h_p1.begin(), h_p1.end(), h_p2.begin(), h_result.begin(), make_pair_functor()); - ASSERT_EQ_QUIET(h_result, d_result); + // zip up pairs on the device + thrust::transform( + d_p1.begin(), d_p1.end(), d_p2.begin(), d_result.begin(), make_pair_functor()); - // add pairs on the host - thrust::transform( - h_result.begin(), h_result.end(), h_result.begin(), h_result.begin(), add_pairs()); + ASSERT_EQ_QUIET(h_result, d_result); - // add pairs on the device - thrust::transform( - d_result.begin(), d_result.end(), d_result.begin(), d_result.begin(), add_pairs()); + // add pairs on the host + thrust::transform( + h_result.begin(), h_result.end(), h_result.begin(), h_result.begin(), add_pairs()); - ASSERT_EQ_QUIET(h_result, d_result); + // add pairs on the device + thrust::transform( + d_result.begin(), d_result.end(), d_result.begin(), d_result.begin(), add_pairs()); + + ASSERT_EQ_QUIET(h_result, d_result); + } } } diff --git a/test/test_partition.cpp b/test/test_partition.cpp index b33a76dbf..14c40cd10 100644 --- a/test/test_partition.cpp +++ b/test/test_partition.cpp @@ -320,23 +320,31 @@ TYPED_TEST(PartitionIntegerTests, TestPartition) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - typename thrust::host_vector::iterator h_iter - = thrust::partition(h_data.begin(), h_data.end(), is_even()); - typename thrust::device_vector::iterator d_iter - = thrust::partition(d_data.begin(), d_data.end(), is_even()); - - thrust::sort(h_data.begin(), h_iter); - thrust::sort(h_iter, h_data.end()); - thrust::sort(d_data.begin(), d_iter); - thrust::sort(d_iter, d_data.end()); - - ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + typename thrust::host_vector::iterator h_iter + = thrust::partition(h_data.begin(), h_data.end(), is_even()); + typename thrust::device_vector::iterator d_iter + = thrust::partition(d_data.begin(), d_data.end(), is_even()); + + thrust::sort(h_data.begin(), h_iter); + thrust::sort(h_iter, h_data.end()); + thrust::sort(d_data.begin(), d_iter); + thrust::sort(d_iter, d_data.end()); + + ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + } } }; @@ -346,26 +354,37 @@ TYPED_TEST(PartitionIntegerTests, TestPartitionStencil) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - thrust::device_vector d_stencil = h_stencil; - - typename thrust::host_vector::iterator h_iter - = thrust::partition(h_data.begin(), h_data.end(), h_stencil.begin(), is_even()); - typename thrust::device_vector::iterator d_iter - = thrust::partition(d_data.begin(), d_data.end(), d_stencil.begin(), is_even()); - - thrust::sort(h_data.begin(), h_iter); - thrust::sort(h_iter, h_data.end()); - thrust::sort(d_data.begin(), d_iter); - thrust::sort(d_iter, d_data.end()); - - ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition); + thrust::device_vector d_data = h_data; + thrust::device_vector d_stencil = h_stencil; + + typename thrust::host_vector::iterator h_iter + = thrust::partition(h_data.begin(), h_data.end(), h_stencil.begin(), is_even()); + typename thrust::device_vector::iterator d_iter + = thrust::partition(d_data.begin(), d_data.end(), d_stencil.begin(), is_even()); + + thrust::sort(h_data.begin(), h_iter); + thrust::sort(h_iter, h_data.end()); + thrust::sort(d_data.begin(), d_iter); + thrust::sort(d_iter, d_data.end()); + + ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + } } }; @@ -375,49 +394,57 @@ TYPED_TEST(PartitionIntegerTests, TestPartitionCopy) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); - size_t n_false = size - n_true; - - // setup output ranges - thrust::host_vector h_true_results(n_true, 0); - thrust::host_vector h_false_results(n_false, 0); - thrust::device_vector d_true_results(n_true, 0); - thrust::device_vector d_false_results(n_false, 0); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_ends = thrust::partition_copy(h_data.begin(), - h_data.end(), - h_true_results.begin(), - h_false_results.begin(), - is_even()); - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_ends = thrust::partition_copy(d_data.begin(), - d_data.end(), - d_true_results.begin(), - d_false_results.begin(), - is_even()); - - // check true output - ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); - ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); - thrust::sort(h_true_results.begin(), h_true_results.end()); - thrust::sort(d_true_results.begin(), d_true_results.end()); - ASSERT_EQ(h_true_results, d_true_results); - - // check false output - ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); - ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); - thrust::sort(h_false_results.begin(), h_false_results.end()); - thrust::sort(d_false_results.begin(), d_false_results.end()); - ASSERT_EQ(h_false_results, d_false_results); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); + size_t n_false = size - n_true; + + // setup output ranges + thrust::host_vector h_true_results(n_true, 0); + thrust::host_vector h_false_results(n_false, 0); + thrust::device_vector d_true_results(n_true, 0); + thrust::device_vector d_false_results(n_false, 0); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_ends = thrust::partition_copy(h_data.begin(), + h_data.end(), + h_true_results.begin(), + h_false_results.begin(), + is_even()); + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_ends = thrust::partition_copy(d_data.begin(), + d_data.end(), + d_true_results.begin(), + d_false_results.begin(), + is_even()); + + // check true output + ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); + ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); + thrust::sort(h_true_results.begin(), h_true_results.end()); + thrust::sort(d_true_results.begin(), d_true_results.end()); + ASSERT_EQ(h_true_results, d_true_results); + + // check false output + ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); + ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); + thrust::sort(h_false_results.begin(), h_false_results.end()); + thrust::sort(d_false_results.begin(), d_false_results.end()); + ASSERT_EQ(h_false_results, d_false_results); + } } }; @@ -427,54 +454,66 @@ TYPED_TEST(PartitionIntegerTests, TestPartitionCopyStencil) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - thrust::device_vector d_stencil = h_stencil; - - size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); - size_t n_false = size - n_true; - - // setup output ranges - thrust::host_vector h_true_results(n_true, 0); - thrust::host_vector h_false_results(n_false, 0); - thrust::device_vector d_true_results(n_true, 0); - thrust::device_vector d_false_results(n_false, 0); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_ends = thrust::partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - h_true_results.begin(), - h_false_results.begin(), - is_even()); - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_ends = thrust::partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - d_true_results.begin(), - d_false_results.begin(), - is_even()); - - // check true output - ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); - ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); - thrust::sort(h_true_results.begin(), h_true_results.end()); - thrust::sort(d_true_results.begin(), d_true_results.end()); - ASSERT_EQ(h_true_results, d_true_results); - - // check false output - ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); - ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); - thrust::sort(h_false_results.begin(), h_false_results.end()); - thrust::sort(d_false_results.begin(), d_false_results.end()); - ASSERT_EQ(h_false_results, d_false_results); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_data = h_data; + thrust::device_vector d_stencil = h_stencil; + + size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); + size_t n_false = size - n_true; + + // setup output ranges + thrust::host_vector h_true_results(n_true, 0); + thrust::host_vector h_false_results(n_false, 0); + thrust::device_vector d_true_results(n_true, 0); + thrust::device_vector d_false_results(n_false, 0); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_ends = thrust::partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + h_true_results.begin(), + h_false_results.begin(), + is_even()); + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_ends = thrust::partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + d_true_results.begin(), + d_false_results.begin(), + is_even()); + + // check true output + ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); + ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); + thrust::sort(h_true_results.begin(), h_true_results.end()); + thrust::sort(d_true_results.begin(), d_true_results.end()); + ASSERT_EQ(h_true_results, d_true_results); + + // check false output + ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); + ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); + thrust::sort(h_false_results.begin(), h_false_results.end()); + thrust::sort(d_false_results.begin(), d_false_results.end()); + ASSERT_EQ(h_false_results, d_false_results); + } } }; @@ -484,54 +523,66 @@ TYPED_TEST(PartitionIntegerTests, TestStablePartitionCopyStencil) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - thrust::device_vector d_stencil = h_stencil; - - size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); - size_t n_false = size - n_true; - - // setup output ranges - thrust::host_vector h_true_results(n_true, 0); - thrust::host_vector h_false_results(n_false, 0); - thrust::device_vector d_true_results(n_true, 0); - thrust::device_vector d_false_results(n_false, 0); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_ends = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - h_true_results.begin(), - h_false_results.begin(), - is_even()); - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_ends = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - d_true_results.begin(), - d_false_results.begin(), - is_even()); - - // check true output - ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); - ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); - thrust::sort(h_true_results.begin(), h_true_results.end()); - thrust::sort(d_true_results.begin(), d_true_results.end()); - ASSERT_EQ(h_true_results, d_true_results); - - // check false output - ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); - ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); - thrust::sort(h_false_results.begin(), h_false_results.end()); - thrust::sort(d_false_results.begin(), d_false_results.end()); - ASSERT_EQ(h_false_results, d_false_results); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_data = h_data; + thrust::device_vector d_stencil = h_stencil; + + size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); + size_t n_false = size - n_true; + + // setup output ranges + thrust::host_vector h_true_results(n_true, 0); + thrust::host_vector h_false_results(n_false, 0); + thrust::device_vector d_true_results(n_true, 0); + thrust::device_vector d_false_results(n_false, 0); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_ends = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + h_true_results.begin(), + h_false_results.begin(), + is_even()); + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_ends = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + d_true_results.begin(), + d_false_results.begin(), + is_even()); + + // check true output + ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); + ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); + thrust::sort(h_true_results.begin(), h_true_results.end()); + thrust::sort(d_true_results.begin(), d_true_results.end()); + ASSERT_EQ(h_true_results, d_true_results); + + // check false output + ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); + ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); + thrust::sort(h_false_results.begin(), h_false_results.end()); + thrust::sort(d_false_results.begin(), d_false_results.end()); + ASSERT_EQ(h_false_results, d_false_results); + } } }; @@ -541,95 +592,103 @@ TYPED_TEST(PartitionIntegerTests, TestPartitionCopyToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); - size_t n_false = size - n_true; - - // mask both ranges - thrust::pair, thrust::discard_iterator<>> h_result1 - = thrust::partition_copy(h_data.begin(), - h_data.end(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> d_result1 - = thrust::partition_copy(d_data.begin(), - d_data.end(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> reference1 - = thrust::make_pair(thrust::make_discard_iterator(n_true), - thrust::make_discard_iterator(n_false)); - - ASSERT_EQ_QUIET(reference1, h_result1); - ASSERT_EQ_QUIET(reference1, d_result1); - - // mask the false range - thrust::host_vector h_trues(n_true); - thrust::device_vector d_trues(n_true); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_result2 = thrust::partition_copy(h_data.begin(), - h_data.end(), - h_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_result2 = thrust::partition_copy(d_data.begin(), - d_data.end(), - d_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_reference2 - = thrust::make_pair(h_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_reference2 - = thrust::make_pair(d_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - ASSERT_EQ(h_trues, d_trues); - ASSERT_EQ_QUIET(h_reference2, h_result2); - ASSERT_EQ_QUIET(d_reference2, d_result2); - - // mask the true range - thrust::host_vector h_falses(n_false); - thrust::device_vector d_falses(n_false); - - thrust::pair, typename thrust::host_vector::iterator> - h_result3 = thrust::partition_copy(h_data.begin(), - h_data.end(), - thrust::make_discard_iterator(), - h_falses.begin(), - is_even()); - - thrust::pair, typename thrust::device_vector::iterator> - d_result3 = thrust::partition_copy(d_data.begin(), - d_data.end(), - thrust::make_discard_iterator(), - d_falses.begin(), - is_even()); - - thrust::pair, typename thrust::host_vector::iterator> - h_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), h_falses.begin() + n_false); - - thrust::pair, typename thrust::device_vector::iterator> - d_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), d_falses.begin() + n_false); - - ASSERT_EQ(h_falses, d_falses); - ASSERT_EQ_QUIET(h_reference3, h_result3); - ASSERT_EQ_QUIET(d_reference3, d_result3); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); + size_t n_false = size - n_true; + + // mask both ranges + thrust::pair, thrust::discard_iterator<>> h_result1 + = thrust::partition_copy(h_data.begin(), + h_data.end(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> d_result1 + = thrust::partition_copy(d_data.begin(), + d_data.end(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> reference1 + = thrust::make_pair(thrust::make_discard_iterator(n_true), + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ_QUIET(reference1, h_result1); + ASSERT_EQ_QUIET(reference1, d_result1); + + // mask the false range + thrust::host_vector h_trues(n_true); + thrust::device_vector d_trues(n_true); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_result2 = thrust::partition_copy(h_data.begin(), + h_data.end(), + h_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_result2 = thrust::partition_copy(d_data.begin(), + d_data.end(), + d_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_reference2 = thrust::make_pair(h_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_reference2 = thrust::make_pair(d_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ(h_trues, d_trues); + ASSERT_EQ_QUIET(h_reference2, h_result2); + ASSERT_EQ_QUIET(d_reference2, d_result2); + + // mask the true range + thrust::host_vector h_falses(n_false); + thrust::device_vector d_falses(n_false); + + thrust::pair, typename thrust::host_vector::iterator> + h_result3 = thrust::partition_copy(h_data.begin(), + h_data.end(), + thrust::make_discard_iterator(), + h_falses.begin(), + is_even()); + + thrust::pair, typename thrust::device_vector::iterator> + d_result3 = thrust::partition_copy(d_data.begin(), + d_data.end(), + thrust::make_discard_iterator(), + d_falses.begin(), + is_even()); + + thrust::pair, typename thrust::host_vector::iterator> + h_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + h_falses.begin() + n_false); + + thrust::pair, typename thrust::device_vector::iterator> + d_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + d_falses.begin() + n_false); + + ASSERT_EQ(h_falses, d_falses); + ASSERT_EQ_QUIET(h_reference3, h_result3); + ASSERT_EQ_QUIET(d_reference3, d_result3); + } } }; @@ -639,104 +698,117 @@ TYPED_TEST(PartitionIntegerTests, TestPartitionCopyStencilToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - thrust::device_vector d_stencil = h_stencil; - - size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); - size_t n_false = size - n_true; - - // mask both ranges - thrust::pair, thrust::discard_iterator<>> h_result1 - = thrust::partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> d_result1 - = thrust::partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> reference1 - = thrust::make_pair(thrust::make_discard_iterator(n_true), - thrust::make_discard_iterator(n_false)); - - ASSERT_EQ_QUIET(reference1, h_result1); - ASSERT_EQ_QUIET(reference1, d_result1); - - // mask the false range - thrust::host_vector h_trues(n_true); - thrust::device_vector d_trues(n_true); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_result2 = thrust::partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - h_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_result2 = thrust::partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - d_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_reference2 - = thrust::make_pair(h_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_reference2 - = thrust::make_pair(d_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - ASSERT_EQ(h_trues, d_trues); - ASSERT_EQ_QUIET(h_reference2, h_result2); - ASSERT_EQ_QUIET(d_reference2, d_result2); - - // mask the true range - thrust::host_vector h_falses(n_false); - thrust::device_vector d_falses(n_false); - - thrust::pair, typename thrust::host_vector::iterator> - h_result3 = thrust::partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - thrust::make_discard_iterator(), - h_falses.begin(), - is_even()); - - thrust::pair, typename thrust::device_vector::iterator> - d_result3 = thrust::partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - thrust::make_discard_iterator(), - d_falses.begin(), - is_even()); - - thrust::pair, typename thrust::host_vector::iterator> - h_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), h_falses.begin() + n_false); - - thrust::pair, typename thrust::device_vector::iterator> - d_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), d_falses.begin() + n_false); - - ASSERT_EQ(h_falses, d_falses); - ASSERT_EQ_QUIET(h_reference3, h_result3); - ASSERT_EQ_QUIET(d_reference3, d_result3); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_data = h_data; + thrust::device_vector d_stencil = h_stencil; + + size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); + size_t n_false = size - n_true; + + // mask both ranges + thrust::pair, thrust::discard_iterator<>> h_result1 + = thrust::partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> d_result1 + = thrust::partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> reference1 + = thrust::make_pair(thrust::make_discard_iterator(n_true), + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ_QUIET(reference1, h_result1); + ASSERT_EQ_QUIET(reference1, d_result1); + + // mask the false range + thrust::host_vector h_trues(n_true); + thrust::device_vector d_trues(n_true); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_result2 = thrust::partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + h_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_result2 = thrust::partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + d_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_reference2 = thrust::make_pair(h_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_reference2 = thrust::make_pair(d_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ(h_trues, d_trues); + ASSERT_EQ_QUIET(h_reference2, h_result2); + ASSERT_EQ_QUIET(d_reference2, d_result2); + + // mask the true range + thrust::host_vector h_falses(n_false); + thrust::device_vector d_falses(n_false); + + thrust::pair, typename thrust::host_vector::iterator> + h_result3 = thrust::partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + thrust::make_discard_iterator(), + h_falses.begin(), + is_even()); + + thrust::pair, typename thrust::device_vector::iterator> + d_result3 = thrust::partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + thrust::make_discard_iterator(), + d_falses.begin(), + is_even()); + + thrust::pair, typename thrust::host_vector::iterator> + h_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + h_falses.begin() + n_false); + + thrust::pair, typename thrust::device_vector::iterator> + d_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + d_falses.begin() + n_false); + + ASSERT_EQ(h_falses, d_falses); + ASSERT_EQ_QUIET(h_reference3, h_result3); + ASSERT_EQ_QUIET(d_reference3, d_result3); + } } }; @@ -746,18 +818,26 @@ TYPED_TEST(PartitionIntegerTests, TestStablePartition) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - typename thrust::host_vector::iterator h_iter - = thrust::stable_partition(h_data.begin(), h_data.end(), is_even()); - typename thrust::device_vector::iterator d_iter - = thrust::stable_partition(d_data.begin(), d_data.end(), is_even()); - - ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + typename thrust::host_vector::iterator h_iter + = thrust::stable_partition(h_data.begin(), h_data.end(), is_even()); + typename thrust::device_vector::iterator d_iter + = thrust::stable_partition(d_data.begin(), d_data.end(), is_even()); + + ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + } } }; @@ -767,21 +847,33 @@ TYPED_TEST(PartitionIntegerTests, TestStablePartitionStencil) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - thrust::device_vector d_stencil = h_stencil; - - typename thrust::host_vector::iterator h_iter = thrust::stable_partition( - h_data.begin(), h_data.end(), h_stencil.begin(), is_even()); - typename thrust::device_vector::iterator d_iter = thrust::stable_partition( - d_data.begin(), d_data.end(), d_stencil.begin(), is_even()); - - ASSERT_EQ(h_data, d_data); - ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_data = h_data; + thrust::device_vector d_stencil = h_stencil; + + typename thrust::host_vector::iterator h_iter = thrust::stable_partition( + h_data.begin(), h_data.end(), h_stencil.begin(), is_even()); + typename thrust::device_vector::iterator d_iter = thrust::stable_partition( + d_data.begin(), d_data.end(), d_stencil.begin(), is_even()); + + ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_iter - h_data.begin(), d_iter - d_data.begin()); + } } }; @@ -791,45 +883,53 @@ TYPED_TEST(PartitionIntegerTests, TestStablePartitionCopy) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); - size_t n_false = size - n_true; - - // setup output ranges - thrust::host_vector h_true_results(n_true, 0); - thrust::host_vector h_false_results(n_false, 0); - thrust::device_vector d_true_results(n_true, 0); - thrust::device_vector d_false_results(n_false, 0); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_ends = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - h_true_results.begin(), - h_false_results.begin(), - is_even()); - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_ends = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - d_true_results.begin(), - d_false_results.begin(), - is_even()); - - // check true output - ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); - ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); - ASSERT_EQ(h_true_results, d_true_results); - - // check false output - ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); - ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); - ASSERT_EQ(h_false_results, d_false_results); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); + size_t n_false = size - n_true; + + // setup output ranges + thrust::host_vector h_true_results(n_true, 0); + thrust::host_vector h_false_results(n_false, 0); + thrust::device_vector d_true_results(n_true, 0); + thrust::device_vector d_false_results(n_false, 0); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_ends = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + h_true_results.begin(), + h_false_results.begin(), + is_even()); + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_ends = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + d_true_results.begin(), + d_false_results.begin(), + is_even()); + + // check true output + ASSERT_EQ(h_ends.first - h_true_results.begin(), n_true); + ASSERT_EQ(d_ends.first - d_true_results.begin(), n_true); + ASSERT_EQ(h_true_results, d_true_results); + + // check false output + ASSERT_EQ(h_ends.second - h_false_results.begin(), n_false); + ASSERT_EQ(d_ends.second - d_false_results.begin(), n_false); + ASSERT_EQ(h_false_results, d_false_results); + } } }; @@ -839,95 +939,103 @@ TYPED_TEST(PartitionIntegerTests, TestStablePartitionCopyToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); - size_t n_false = size - n_true; - - // mask both ranges - thrust::pair, thrust::discard_iterator<>> h_result1 - = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> d_result1 - = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> reference1 - = thrust::make_pair(thrust::make_discard_iterator(n_true), - thrust::make_discard_iterator(n_false)); - - ASSERT_EQ_QUIET(reference1, h_result1); - ASSERT_EQ_QUIET(reference1, d_result1); - - // mask the false range - thrust::host_vector h_trues(n_true); - thrust::device_vector d_trues(n_true); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_result2 = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - h_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_result2 = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - d_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_reference2 - = thrust::make_pair(h_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_reference2 - = thrust::make_pair(d_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - ASSERT_EQ(h_trues, d_trues); - ASSERT_EQ_QUIET(h_reference2, h_result2); - ASSERT_EQ_QUIET(d_reference2, d_result2); - - // mask the true range - thrust::host_vector h_falses(n_false); - thrust::device_vector d_falses(n_false); - - thrust::pair, typename thrust::host_vector::iterator> - h_result3 = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - thrust::make_discard_iterator(), - h_falses.begin(), - is_even()); - - thrust::pair, typename thrust::device_vector::iterator> - d_result3 = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - thrust::make_discard_iterator(), - d_falses.begin(), - is_even()); - - thrust::pair, typename thrust::host_vector::iterator> - h_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), h_falses.begin() + n_false); - - thrust::pair, typename thrust::device_vector::iterator> - d_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), d_falses.begin() + n_false); - - ASSERT_EQ(h_falses, d_falses); - ASSERT_EQ_QUIET(h_reference3, h_result3); - ASSERT_EQ_QUIET(d_reference3, d_result3); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + size_t n_true = thrust::count_if(h_data.begin(), h_data.end(), is_even()); + size_t n_false = size - n_true; + + // mask both ranges + thrust::pair, thrust::discard_iterator<>> h_result1 + = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> d_result1 + = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> reference1 + = thrust::make_pair(thrust::make_discard_iterator(n_true), + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ_QUIET(reference1, h_result1); + ASSERT_EQ_QUIET(reference1, d_result1); + + // mask the false range + thrust::host_vector h_trues(n_true); + thrust::device_vector d_trues(n_true); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_result2 = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + h_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_result2 = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + d_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_reference2 = thrust::make_pair(h_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_reference2 = thrust::make_pair(d_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ(h_trues, d_trues); + ASSERT_EQ_QUIET(h_reference2, h_result2); + ASSERT_EQ_QUIET(d_reference2, d_result2); + + // mask the true range + thrust::host_vector h_falses(n_false); + thrust::device_vector d_falses(n_false); + + thrust::pair, typename thrust::host_vector::iterator> + h_result3 = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + thrust::make_discard_iterator(), + h_falses.begin(), + is_even()); + + thrust::pair, typename thrust::device_vector::iterator> + d_result3 = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + thrust::make_discard_iterator(), + d_falses.begin(), + is_even()); + + thrust::pair, typename thrust::host_vector::iterator> + h_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + h_falses.begin() + n_false); + + thrust::pair, typename thrust::device_vector::iterator> + d_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + d_falses.begin() + n_false); + + ASSERT_EQ(h_falses, d_falses); + ASSERT_EQ_QUIET(h_reference3, h_result3); + ASSERT_EQ_QUIET(d_reference3, d_result3); + } } }; @@ -937,104 +1045,116 @@ TYPED_TEST(PartitionIntegerTests, TestStablePartitionCopyStencilToDiscardIterato const std::vector sizes = get_sizes(); for(auto size : sizes) { - // setup input ranges - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - thrust::device_vector d_stencil = h_stencil; - - size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); - size_t n_false = size - n_true; - - // mask both ranges - thrust::pair, thrust::discard_iterator<>> h_result1 - = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> d_result1 - = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair, thrust::discard_iterator<>> reference1 - = thrust::make_pair(thrust::make_discard_iterator(n_true), - thrust::make_discard_iterator(n_false)); - - ASSERT_EQ_QUIET(reference1, h_result1); - ASSERT_EQ_QUIET(reference1, d_result1); - - // mask the false range - thrust::host_vector h_trues(n_true); - thrust::device_vector d_trues(n_true); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_result2 = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - h_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_result2 = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - d_trues.begin(), - thrust::make_discard_iterator(), - is_even()); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_reference2 - = thrust::make_pair(h_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_reference2 - = thrust::make_pair(d_trues.begin() + n_true, thrust::make_discard_iterator(n_false)); - - ASSERT_EQ(h_trues, d_trues); - ASSERT_EQ_QUIET(h_reference2, h_result2); - ASSERT_EQ_QUIET(d_reference2, d_result2); - - // mask the true range - thrust::host_vector h_falses(n_false); - thrust::device_vector d_falses(n_false); - - thrust::pair, typename thrust::host_vector::iterator> - h_result3 = thrust::stable_partition_copy(h_data.begin(), - h_data.end(), - h_stencil.begin(), - thrust::make_discard_iterator(), - h_falses.begin(), - is_even()); - - thrust::pair, typename thrust::device_vector::iterator> - d_result3 = thrust::stable_partition_copy(d_data.begin(), - d_data.end(), - d_stencil.begin(), - thrust::make_discard_iterator(), - d_falses.begin(), - is_even()); - - thrust::pair, typename thrust::host_vector::iterator> - h_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), h_falses.begin() + n_false); - - thrust::pair, typename thrust::device_vector::iterator> - d_reference3 - = thrust::make_pair(thrust::make_discard_iterator(n_true), d_falses.begin() + n_false); - - ASSERT_EQ(h_falses, d_falses); - ASSERT_EQ_QUIET(h_reference3, h_result3); - ASSERT_EQ_QUIET(d_reference3, d_result3); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + // setup input ranges + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_data = h_data; + thrust::device_vector d_stencil = h_stencil; + + size_t n_true = thrust::count_if(h_stencil.begin(), h_stencil.end(), is_even()); + size_t n_false = size - n_true; + + // mask both ranges + thrust::pair, thrust::discard_iterator<>> h_result1 + = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> d_result1 + = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair, thrust::discard_iterator<>> reference1 + = thrust::make_pair(thrust::make_discard_iterator(n_true), + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ_QUIET(reference1, h_result1); + ASSERT_EQ_QUIET(reference1, d_result1); + + // mask the false range + thrust::host_vector h_trues(n_true); + thrust::device_vector d_trues(n_true); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_result2 = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + h_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_result2 = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + d_trues.begin(), + thrust::make_discard_iterator(), + is_even()); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_reference2 = thrust::make_pair(h_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_reference2 = thrust::make_pair(d_trues.begin() + n_true, + thrust::make_discard_iterator(n_false)); + + ASSERT_EQ(h_trues, d_trues); + ASSERT_EQ_QUIET(h_reference2, h_result2); + ASSERT_EQ_QUIET(d_reference2, d_result2); + + // mask the true range + thrust::host_vector h_falses(n_false); + thrust::device_vector d_falses(n_false); + + thrust::pair, typename thrust::host_vector::iterator> + h_result3 = thrust::stable_partition_copy(h_data.begin(), + h_data.end(), + h_stencil.begin(), + thrust::make_discard_iterator(), + h_falses.begin(), + is_even()); + + thrust::pair, typename thrust::device_vector::iterator> + d_result3 = thrust::stable_partition_copy(d_data.begin(), + d_data.end(), + d_stencil.begin(), + thrust::make_discard_iterator(), + d_falses.begin(), + is_even()); + + thrust::pair, typename thrust::host_vector::iterator> + h_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + h_falses.begin() + n_false); + + thrust::pair, typename thrust::device_vector::iterator> + d_reference3 = thrust::make_pair(thrust::make_discard_iterator(n_true), + d_falses.begin() + n_false); + + ASSERT_EQ(h_falses, d_falses); + ASSERT_EQ_QUIET(h_reference3, h_result3); + ASSERT_EQ_QUIET(d_reference3, d_result3); + } } }; @@ -1607,4 +1727,4 @@ TEST(PartitionTests, TestStablePartitionCopyStencilDispatchImplicit) 0); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} diff --git a/test/test_partition_point.cpp b/test/test_partition_point.cpp index 1209d89cb..929e3b703 100644 --- a/test/test_partition_point.cpp +++ b/test/test_partition_point.cpp @@ -63,12 +63,20 @@ TYPED_TEST(PartitionPointVectorTests, TestPartitionPoint) const size_t n = (1 << 16) + 13; - Vector v = get_random_data(n, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + Vector v = get_random_data( + n, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - Iterator ref = thrust::stable_partition(v.begin(), v.end(), is_even()); + Iterator ref = thrust::stable_partition(v.begin(), v.end(), is_even()); - ASSERT_EQ(ref - v.begin(), - thrust::partition_point(v.begin(), v.end(), is_even()) - v.begin()); + ASSERT_EQ(ref - v.begin(), + thrust::partition_point(v.begin(), v.end(), is_even()) - v.begin()); + } } template @@ -105,4 +113,4 @@ TEST(PartitionPointTests, TestPartitionPointDispatchImplicit) thrust::retag(vec.begin()), thrust::retag(vec.begin()), 0); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} \ No newline at end of file diff --git a/test/test_reduce.cpp b/test/test_reduce.cpp index d00f9894f..6ffd9ce28 100644 --- a/test/test_reduce.cpp +++ b/test/test_reduce.cpp @@ -91,16 +91,24 @@ TYPED_TEST(ReducePrimitiveTests, TestReduce) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - T init = T(13); + T init = T(13); - T h_result = thrust::reduce(h_data.begin(), h_data.end(), init); - T d_result = thrust::reduce(d_data.begin(), d_data.end(), init); + T h_result = thrust::reduce(h_data.begin(), h_data.end(), init); + T d_result = thrust::reduce(d_data.begin(), d_data.end(), init); - ASSERT_EQ(h_result, d_result); + ASSERT_EQ(h_result, d_result); + } } } @@ -140,17 +148,25 @@ TYPED_TEST(ReduceIntegerTests, TestReduceWithOperator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_data = h_data; + thrust::device_vector d_data = h_data; - T init = T(3); + T init = T(3); - T cpu_result = thrust::reduce(h_data.begin(), h_data.end(), init, plus_mod_10()); - T gpu_result = thrust::reduce(d_data.begin(), d_data.end(), init, plus_mod_10()); + T cpu_result = thrust::reduce(h_data.begin(), h_data.end(), init, plus_mod_10()); + T gpu_result = thrust::reduce(d_data.begin(), d_data.end(), init, plus_mod_10()); - ASSERT_EQ(cpu_result, gpu_result); + ASSERT_EQ(cpu_result, gpu_result); + } } } @@ -226,4 +242,4 @@ TYPED_TEST(ReducePrimitiveTests, TestReduceCountingIterator) ASSERT_EQ(h_result, d_result); } } -} \ No newline at end of file +} diff --git a/test/test_reduce_by_key.cpp b/test/test_reduce_by_key.cpp index 470540d68..914f135f6 100644 --- a/test/test_reduce_by_key.cpp +++ b/test/test_reduce_by_key.cpp @@ -155,49 +155,65 @@ TYPED_TEST(ReduceByKeysIntegralTests, TestReduceByKey) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_keys_output(size); - thrust::host_vector h_vals_output(size); - thrust::device_vector d_keys_output(size); - thrust::device_vector d_vals_output(size); - - typedef typename thrust::host_vector::iterator HostKeyIterator; - typedef typename thrust::host_vector::iterator HostValIterator; - typedef typename thrust::device_vector::iterator DeviceKeyIterator; - typedef typename thrust::device_vector::iterator DeviceValIterator; - - typedef typename thrust::pair HostIteratorPair; - typedef typename thrust::pair DeviceIteratorPair; - - HostIteratorPair h_last = thrust::reduce_by_key(h_keys.begin(), - h_keys.end(), - h_vals.begin(), - h_keys_output.begin(), - h_vals_output.begin()); - DeviceIteratorPair d_last = thrust::reduce_by_key(d_keys.begin(), - d_keys.end(), - d_vals.begin(), - d_keys_output.begin(), - d_vals_output.begin()); - - ASSERT_EQ(h_last.first - h_keys_output.begin(), d_last.first - d_keys_output.begin()); - ASSERT_EQ(h_last.second - h_vals_output.begin(), d_last.second - d_vals_output.begin()); - - size_t N = h_last.first - h_keys_output.begin(); - - h_keys_output.resize(N); - h_vals_output.resize(N); - d_keys_output.resize(N); - d_vals_output.resize(N); - - ASSERT_EQ(h_keys_output, d_keys_output); - ASSERT_EQ(h_vals_output, d_vals_output); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + ); + thrust::host_vector h_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_keys_output(size); + thrust::host_vector h_vals_output(size); + thrust::device_vector d_keys_output(size); + thrust::device_vector d_vals_output(size); + + typedef typename thrust::host_vector::iterator HostKeyIterator; + typedef typename thrust::host_vector::iterator HostValIterator; + typedef typename thrust::device_vector::iterator DeviceKeyIterator; + typedef typename thrust::device_vector::iterator DeviceValIterator; + + typedef typename thrust::pair HostIteratorPair; + typedef typename thrust::pair DeviceIteratorPair; + + HostIteratorPair h_last = thrust::reduce_by_key(h_keys.begin(), + h_keys.end(), + h_vals.begin(), + h_keys_output.begin(), + h_vals_output.begin()); + DeviceIteratorPair d_last = thrust::reduce_by_key(d_keys.begin(), + d_keys.end(), + d_vals.begin(), + d_keys_output.begin(), + d_vals_output.begin()); + + ASSERT_EQ(h_last.first - h_keys_output.begin(), d_last.first - d_keys_output.begin()); + ASSERT_EQ(h_last.second - h_vals_output.begin(), d_last.second - d_vals_output.begin()); + + size_t N = h_last.first - h_keys_output.begin(); + + h_keys_output.resize(N); + h_vals_output.resize(N); + d_keys_output.resize(N); + d_vals_output.resize(N); + + ASSERT_EQ(h_keys_output, d_keys_output); + ASSERT_EQ(h_vals_output, d_vals_output); + } } }; @@ -209,45 +225,61 @@ TYPED_TEST(ReduceByKeysIntegralTests, TestReduceByKeyToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_keys_output(size); - thrust::host_vector h_vals_output(size); - thrust::device_vector d_keys_output(size); - thrust::device_vector d_vals_output(size); - - thrust::host_vector unique_keys = h_keys; - unique_keys.erase(thrust::unique(unique_keys.begin(), unique_keys.end()), - unique_keys.end()); - - // discard key output - size_t h_size = thrust::reduce_by_key(h_keys.begin(), - h_keys.end(), - h_vals.begin(), - thrust::make_discard_iterator(), - h_vals_output.begin()) - .second - - h_vals_output.begin(); - - size_t d_size = thrust::reduce_by_key(d_keys.begin(), - d_keys.end(), - d_vals.begin(), - thrust::make_discard_iterator(), - d_vals_output.begin()) - .second - - d_vals_output.begin(); - - h_vals_output.resize(h_size); - d_vals_output.resize(d_size); - - ASSERT_EQ(h_vals_output.size(), unique_keys.size()); - ASSERT_EQ(d_vals_output.size(), unique_keys.size()); - ASSERT_EQ(d_vals_output.size(), h_vals_output.size()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + ); + thrust::host_vector h_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_keys_output(size); + thrust::host_vector h_vals_output(size); + thrust::device_vector d_keys_output(size); + thrust::device_vector d_vals_output(size); + + thrust::host_vector unique_keys = h_keys; + unique_keys.erase(thrust::unique(unique_keys.begin(), unique_keys.end()), + unique_keys.end()); + + // discard key output + size_t h_size = thrust::reduce_by_key(h_keys.begin(), + h_keys.end(), + h_vals.begin(), + thrust::make_discard_iterator(), + h_vals_output.begin()) + .second + - h_vals_output.begin(); + + size_t d_size = thrust::reduce_by_key(d_keys.begin(), + d_keys.end(), + d_vals.begin(), + thrust::make_discard_iterator(), + d_vals_output.begin()) + .second + - d_vals_output.begin(); + + h_vals_output.resize(h_size); + d_vals_output.resize(d_size); + + ASSERT_EQ(h_vals_output.size(), unique_keys.size()); + ASSERT_EQ(d_vals_output.size(), unique_keys.size()); + ASSERT_EQ(d_vals_output.size(), h_vals_output.size()); + } } }; @@ -302,4 +334,4 @@ TEST(ReduceByKeysTests, TestReduceByKeyDispatchImplicit) thrust::retag(vec.begin())); ASSERT_EQ(13, vec.front()); -} \ No newline at end of file +} diff --git a/test/test_remove.cpp b/test/test_remove.cpp index 4de200341..f30c371e2 100644 --- a/test/test_remove.cpp +++ b/test/test_remove.cpp @@ -126,7 +126,7 @@ TYPED_TEST(RemoveTests, TestRemoveCopySimple) template OutputIterator - remove_copy(my_system& system, InputIterator, InputIterator, OutputIterator result, const T&) +remove_copy(my_system& system, InputIterator, InputIterator, OutputIterator result, const T&) { system.validate_dispatch(); return result; @@ -433,20 +433,28 @@ TYPED_TEST(RemoveVariableTests, TestRemove) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - size_t h_size = thrust::remove(h_data.begin(), h_data.end(), T(0)) - h_data.begin(); - size_t d_size = thrust::remove(d_data.begin(), d_data.end(), T(0)) - d_data.begin(); + thrust::device_vector d_data = h_data; - ASSERT_EQ(h_size, d_size); + size_t h_size = thrust::remove(h_data.begin(), h_data.end(), T(0)) - h_data.begin(); + size_t d_size = thrust::remove(d_data.begin(), d_data.end(), T(0)) - d_data.begin(); - h_data.resize(h_size); - d_data.resize(d_size); + ASSERT_EQ(h_size, d_size); - ASSERT_EQ(h_data, d_data); + h_data.resize(h_size); + d_data.resize(d_size); + + ASSERT_EQ(h_data, d_data); + } } } @@ -457,22 +465,30 @@ TYPED_TEST(RemoveVariableTests, TestRemoveIf) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_data = h_data; + thrust::device_vector d_data = h_data; - size_t h_size - = thrust::remove_if(h_data.begin(), h_data.end(), is_true()) - h_data.begin(); - size_t d_size - = thrust::remove_if(d_data.begin(), d_data.end(), is_true()) - d_data.begin(); + size_t h_size + = thrust::remove_if(h_data.begin(), h_data.end(), is_true()) - h_data.begin(); + size_t d_size + = thrust::remove_if(d_data.begin(), d_data.end(), is_true()) - d_data.begin(); - ASSERT_EQ(h_size, d_size); + ASSERT_EQ(h_size, d_size); - h_data.resize(h_size); - d_data.resize(d_size); + h_data.resize(h_size); + d_data.resize(d_size); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); + } } } @@ -483,28 +499,40 @@ TYPED_TEST(RemoveVariableTests, TestRemoveIfStencil) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_data = h_data; - - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_stencil = h_stencil; - - size_t h_size - = thrust::remove_if(h_data.begin(), h_data.end(), h_stencil.begin(), is_true()) - - h_data.begin(); - size_t d_size - = thrust::remove_if(d_data.begin(), d_data.end(), d_stencil.begin(), is_true()) - - d_data.begin(); - - ASSERT_EQ(h_size, d_size); - - h_data.resize(h_size); - d_data.resize(d_size); - - ASSERT_EQ(h_data, d_data); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::device_vector d_data = h_data; + + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_stencil = h_stencil; + + size_t h_size + = thrust::remove_if(h_data.begin(), h_data.end(), h_stencil.begin(), is_true()) + - h_data.begin(); + size_t d_size + = thrust::remove_if(d_data.begin(), d_data.end(), d_stencil.begin(), is_true()) + - d_data.begin(); + + ASSERT_EQ(h_size, d_size); + + h_data.resize(h_size); + d_data.resize(d_size); + + ASSERT_EQ(h_data, d_data); + } } } @@ -515,25 +543,35 @@ TYPED_TEST(RemoveVariableTests, TestRemoveCopy) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_data = h_data; + thrust::device_vector d_data = h_data; - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - size_t h_size = thrust::remove_copy(h_data.begin(), h_data.end(), h_result.begin(), T(0)) - - h_result.begin(); - size_t d_size = thrust::remove_copy(d_data.begin(), d_data.end(), d_result.begin(), T(0)) - - d_result.begin(); + size_t h_size + = thrust::remove_copy(h_data.begin(), h_data.end(), h_result.begin(), T(0)) + - h_result.begin(); + size_t d_size + = thrust::remove_copy(d_data.begin(), d_data.end(), d_result.begin(), T(0)) + - d_result.begin(); - ASSERT_EQ(h_size, d_size); + ASSERT_EQ(h_size, d_size); - h_data.resize(h_size); - d_data.resize(d_size); + h_data.resize(h_size); + d_data.resize(d_size); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); + } } } @@ -544,24 +582,32 @@ TYPED_TEST(RemoveVariableTests, TestRemoveCopyToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - size_t num_zeros = thrust::count(h_data.begin(), h_data.end(), T(0)); - size_t num_nonzeros = h_data.size() - num_zeros; + thrust::device_vector d_data = h_data; - thrust::discard_iterator<> h_result = thrust::remove_copy( - h_data.begin(), h_data.end(), thrust::make_discard_iterator(), T(0)); + size_t num_zeros = thrust::count(h_data.begin(), h_data.end(), T(0)); + size_t num_nonzeros = h_data.size() - num_zeros; - thrust::discard_iterator<> d_result = thrust::remove_copy( - d_data.begin(), d_data.end(), thrust::make_discard_iterator(), T(0)); + thrust::discard_iterator<> h_result = thrust::remove_copy( + h_data.begin(), h_data.end(), thrust::make_discard_iterator(), T(0)); - thrust::discard_iterator<> reference(num_nonzeros); + thrust::discard_iterator<> d_result = thrust::remove_copy( + d_data.begin(), d_data.end(), thrust::make_discard_iterator(), T(0)); - ASSERT_EQ(reference, h_result); - ASSERT_EQ(reference, d_result); + thrust::discard_iterator<> reference(num_nonzeros); + + ASSERT_EQ(reference, h_result); + ASSERT_EQ(reference, d_result); + } } } @@ -572,44 +618,53 @@ TYPED_TEST(RemoveVariableTests, TestRemoveCopyToDiscardIteratorZipped) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - size_t num_zeros = thrust::count(h_data.begin(), h_data.end(), T(0)); - size_t num_nonzeros = h_data.size() - num_zeros; - - typedef thrust::tuple::iterator, thrust::discard_iterator<>> - Tuple1; - typedef thrust::tuple::iterator, - thrust::discard_iterator<>> - Tuple2; - - typedef thrust::zip_iterator ZipIterator1; - typedef thrust::zip_iterator ZipIterator2; - - ZipIterator1 h_result = thrust::remove_copy( - thrust::make_zip_iterator(thrust::make_tuple(h_data.begin(), h_data.begin())), - thrust::make_zip_iterator(thrust::make_tuple(h_data.end(), h_data.end())), - thrust::make_zip_iterator( - thrust::make_tuple(h_output.begin(), thrust::make_discard_iterator())), - thrust::make_tuple(T(0), T(0))); - - ZipIterator2 d_result = thrust::remove_copy( - thrust::make_zip_iterator(thrust::make_tuple(d_data.begin(), d_data.begin())), - thrust::make_zip_iterator(thrust::make_tuple(d_data.end(), d_data.end())), - thrust::make_zip_iterator( - thrust::make_tuple(d_output.begin(), thrust::make_discard_iterator())), - thrust::make_tuple(T(0), T(0))); - - thrust::discard_iterator<> reference(num_nonzeros); - - ASSERT_EQ(h_output, d_output); - ASSERT_EQ_QUIET(reference, thrust::get<1>(h_result.get_iterator_tuple())); - ASSERT_EQ_QUIET(reference, thrust::get<1>(d_result.get_iterator_tuple())); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + size_t num_zeros = thrust::count(h_data.begin(), h_data.end(), T(0)); + size_t num_nonzeros = h_data.size() - num_zeros; + + typedef thrust::tuple::iterator, + thrust::discard_iterator<>> + Tuple1; + typedef thrust::tuple::iterator, + thrust::discard_iterator<>> + Tuple2; + + typedef thrust::zip_iterator ZipIterator1; + typedef thrust::zip_iterator ZipIterator2; + + ZipIterator1 h_result = thrust::remove_copy( + thrust::make_zip_iterator(thrust::make_tuple(h_data.begin(), h_data.begin())), + thrust::make_zip_iterator(thrust::make_tuple(h_data.end(), h_data.end())), + thrust::make_zip_iterator( + thrust::make_tuple(h_output.begin(), thrust::make_discard_iterator())), + thrust::make_tuple(T(0), T(0))); + + ZipIterator2 d_result = thrust::remove_copy( + thrust::make_zip_iterator(thrust::make_tuple(d_data.begin(), d_data.begin())), + thrust::make_zip_iterator(thrust::make_tuple(d_data.end(), d_data.end())), + thrust::make_zip_iterator( + thrust::make_tuple(d_output.begin(), thrust::make_discard_iterator())), + thrust::make_tuple(T(0), T(0))); + + thrust::discard_iterator<> reference(num_nonzeros); + + ASSERT_EQ(h_output, d_output); + ASSERT_EQ_QUIET(reference, thrust::get<1>(h_result.get_iterator_tuple())); + ASSERT_EQ_QUIET(reference, thrust::get<1>(d_result.get_iterator_tuple())); + } } } @@ -620,26 +675,34 @@ TYPED_TEST(RemoveVariableTests, TestRemoveCopyIf) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); - - size_t h_size - = thrust::remove_copy_if(h_data.begin(), h_data.end(), h_result.begin(), is_true()) - - h_result.begin(); - size_t d_size - = thrust::remove_copy_if(d_data.begin(), d_data.end(), d_result.begin(), is_true()) - - d_result.begin(); - - ASSERT_EQ(h_size, d_size); - - h_result.resize(h_size); - d_result.resize(d_size); - - ASSERT_EQ(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); + + size_t h_size = thrust::remove_copy_if( + h_data.begin(), h_data.end(), h_result.begin(), is_true()) + - h_result.begin(); + size_t d_size = thrust::remove_copy_if( + d_data.begin(), d_data.end(), d_result.begin(), is_true()) + - d_result.begin(); + + ASSERT_EQ(h_size, d_size); + + h_result.resize(h_size); + d_result.resize(d_size); + + ASSERT_EQ(h_result, d_result); + } } } @@ -650,23 +713,31 @@ TYPED_TEST(RemoveVariableTests, TestRemoveCopyIfToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - size_t num_false - = thrust::count_if(h_data.begin(), h_data.end(), thrust::not1(is_true())); + size_t num_false + = thrust::count_if(h_data.begin(), h_data.end(), thrust::not1(is_true())); - thrust::discard_iterator<> h_result = thrust::remove_copy_if( - h_data.begin(), h_data.end(), thrust::make_discard_iterator(), is_true()); + thrust::discard_iterator<> h_result = thrust::remove_copy_if( + h_data.begin(), h_data.end(), thrust::make_discard_iterator(), is_true()); - thrust::discard_iterator<> d_result = thrust::remove_copy_if( - d_data.begin(), d_data.end(), thrust::make_discard_iterator(), is_true()); + thrust::discard_iterator<> d_result = thrust::remove_copy_if( + d_data.begin(), d_data.end(), thrust::make_discard_iterator(), is_true()); - thrust::discard_iterator<> reference(num_false); + thrust::discard_iterator<> reference(num_false); - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } @@ -677,32 +748,47 @@ TYPED_TEST(RemoveVariableTests, TestRemoveCopyIfStencil) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_stencil = h_stencil; - - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); - - size_t h_size - = thrust::remove_copy_if( - h_data.begin(), h_data.end(), h_stencil.begin(), h_result.begin(), is_true()) - - h_result.begin(); - size_t d_size - = thrust::remove_copy_if( - d_data.begin(), d_data.end(), d_stencil.begin(), d_result.begin(), is_true()) - - d_result.begin(); - - ASSERT_EQ(h_size, d_size); - - h_result.resize(h_size); - d_result.resize(d_size); - - ASSERT_EQ(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + thrust::host_vector h_stencil + = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + thrust::device_vector d_stencil = h_stencil; + + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); + + size_t h_size = thrust::remove_copy_if(h_data.begin(), + h_data.end(), + h_stencil.begin(), + h_result.begin(), + is_true()) + - h_result.begin(); + size_t d_size = thrust::remove_copy_if(d_data.begin(), + d_data.end(), + d_stencil.begin(), + d_result.begin(), + is_true()) + - d_result.begin(); + + ASSERT_EQ(h_size, d_size); + + h_result.resize(h_size); + d_result.resize(d_size); + + ASSERT_EQ(h_result, d_result); + } } } @@ -713,34 +799,46 @@ TYPED_TEST(RemoveVariableTests, TestRemoveCopyIfStencilToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_stencil = h_stencil; - - size_t num_false - = thrust::count_if(h_stencil.begin(), h_stencil.end(), thrust::not1(is_true())); - - thrust::discard_iterator<> h_result - = thrust::remove_copy_if(h_data.begin(), - h_data.end(), - h_stencil.begin(), - thrust::make_discard_iterator(), - is_true()); - - thrust::discard_iterator<> d_result - = thrust::remove_copy_if(d_data.begin(), - d_data.end(), - d_stencil.begin(), - thrust::make_discard_iterator(), - is_true()); - - thrust::discard_iterator<> reference(num_false); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_stencil = h_stencil; + + size_t num_false + = thrust::count_if(h_stencil.begin(), h_stencil.end(), thrust::not1(is_true())); + + thrust::discard_iterator<> h_result + = thrust::remove_copy_if(h_data.begin(), + h_data.end(), + h_stencil.begin(), + thrust::make_discard_iterator(), + is_true()); + + thrust::discard_iterator<> d_result + = thrust::remove_copy_if(d_data.begin(), + d_data.end(), + d_stencil.begin(), + thrust::make_discard_iterator(), + is_true()); + + thrust::discard_iterator<> reference(num_false); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } diff --git a/test/test_replace.cpp b/test/test_replace.cpp index 63a9ccd9d..58ec9bd31 100644 --- a/test/test_replace.cpp +++ b/test/test_replace.cpp @@ -94,22 +94,30 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceWithRandomDataAndDifferentSizes) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - T new_value = (T)0; - T old_value = (T)1; + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; - thrust::replace(h_data.begin(), h_data.end(), old_value, new_value); - thrust::replace(d_data.begin(), d_data.end(), old_value, new_value); + T new_value = (T)0; + T old_value = (T)1; - ASSERT_EQ(h_data.size(), size); - ASSERT_EQ(d_data.size(), size); + thrust::replace(h_data.begin(), h_data.end(), old_value, new_value); + thrust::replace(d_data.begin(), d_data.end(), old_value, new_value); - thrust::host_vector h_data_d(d_data); - for(size_t i = 0; i < size; i++) - { - ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); + ASSERT_EQ(h_data.size(), size); + ASSERT_EQ(d_data.size(), size); + + thrust::host_vector h_data_d(d_data); + for(size_t i = 0; i < size; i++) + { + ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); + } } } } @@ -167,7 +175,7 @@ TEST(ReplaceTests, ReplaceCopyValidateDispatch) template OutputIterator - replace_copy(my_tag, InputIterator, InputIterator, OutputIterator result, const T&, const T&) +replace_copy(my_tag, InputIterator, InputIterator, OutputIterator result, const T&, const T&) { *result = 13; return result; @@ -193,25 +201,34 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceCopyWithRandomData) const std::vector sizes = get_sizes(); for(auto size : sizes) { - - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; - - T old_value = (T)0; - T new_value = (T)1; - - thrust::host_vector h_dest(size); - thrust::device_vector d_dest(size); - - thrust::replace_copy(h_data.begin(), h_data.end(), h_dest.begin(), old_value, new_value); - thrust::replace_copy(d_data.begin(), d_data.end(), d_dest.begin(), old_value, new_value); - - thrust::host_vector h_data_d(d_data); - thrust::host_vector h_dest_d(d_dest); - for(size_t i = 0; i < size; i++) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); - ASSERT_NEAR(h_dest[i], h_dest_d[i], T(0.1)); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; + + T old_value = (T)0; + T new_value = (T)1; + + thrust::host_vector h_dest(size); + thrust::device_vector d_dest(size); + + thrust::replace_copy( + h_data.begin(), h_data.end(), h_dest.begin(), old_value, new_value); + thrust::replace_copy( + d_data.begin(), d_data.end(), d_dest.begin(), old_value, new_value); + + thrust::host_vector h_data_d(d_data); + thrust::host_vector h_dest_d(d_dest); + for(size_t i = 0; i < size; i++) + { + ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); + ASSERT_NEAR(h_dest[i], h_dest_d[i], T(0.1)); + } } } } @@ -223,22 +240,38 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceCopyToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; - - T old_value = 0; - T new_value = 1; - - thrust::discard_iterator<> h_result = thrust::replace_copy( - h_data.begin(), h_data.end(), thrust::make_discard_iterator(), old_value, new_value); - - thrust::discard_iterator<> d_result = thrust::replace_copy( - d_data.begin(), d_data.end(), thrust::make_discard_iterator(), old_value, new_value); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ(reference, d_result); - ASSERT_EQ(reference, h_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; + + T old_value = 0; + T new_value = 1; + + thrust::discard_iterator<> h_result + = thrust::replace_copy(h_data.begin(), + h_data.end(), + thrust::make_discard_iterator(), + old_value, + new_value); + + thrust::discard_iterator<> d_result + = thrust::replace_copy(d_data.begin(), + d_data.end(), + thrust::make_discard_iterator(), + old_value, + new_value); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ(reference, d_result); + ASSERT_EQ(reference, h_result); + } } } @@ -404,16 +437,24 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceIfWithRandomData) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::replace_if(h_data.begin(), h_data.end(), less_than_five(), (T)0); - thrust::replace_if(d_data.begin(), d_data.end(), less_than_five(), (T)0); + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; - thrust::host_vector h_data_d(d_data); - for(size_t i = 0; i < size; i++) - { - ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); + thrust::replace_if(h_data.begin(), h_data.end(), less_than_five(), (T)0); + thrust::replace_if(d_data.begin(), d_data.end(), less_than_five(), (T)0); + + thrust::host_vector h_data_d(d_data); + for(size_t i = 0; i < size; i++) + { + ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); + } } } } @@ -468,8 +509,8 @@ TEST(ReplaceTests, ReplaceCopyIfDispatchExplicit) } template -OutputIterator replace_copy_if( - my_tag, InputIterator, InputIterator, OutputIterator result, Predicate, const T&) +OutputIterator +replace_copy_if(my_tag, InputIterator, InputIterator, OutputIterator result, Predicate, const T&) { *result = 13; return result; @@ -593,24 +634,31 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceCopyIfWithRandomData) const std::vector sizes = get_sizes(); for(auto size : sizes) { - - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; - - thrust::host_vector h_dest(size); - thrust::device_vector d_dest(size); - - thrust::replace_copy_if( - h_data.begin(), h_data.end(), h_dest.begin(), less_than_five(), 0); - thrust::replace_copy_if( - d_data.begin(), d_data.end(), d_dest.begin(), less_than_five(), 0); - - thrust::host_vector h_data_d(d_data); - thrust::host_vector h_dest_d(d_dest); - for(size_t i = 0; i < size; i++) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); - ASSERT_NEAR(h_dest[i], h_dest_d[i], T(0.1)); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; + + thrust::host_vector h_dest(size); + thrust::device_vector d_dest(size); + + thrust::replace_copy_if( + h_data.begin(), h_data.end(), h_dest.begin(), less_than_five(), 0); + thrust::replace_copy_if( + d_data.begin(), d_data.end(), d_dest.begin(), less_than_five(), 0); + + thrust::host_vector h_data_d(d_data); + thrust::host_vector h_dest_d(d_dest); + for(size_t i = 0; i < size; i++) + { + ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); + ASSERT_NEAR(h_dest[i], h_dest_d[i], T(0.1)); + } } } } @@ -622,19 +670,35 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceCopyIfToDiscardIteratorRandomData) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; - - thrust::discard_iterator<> h_result = thrust::replace_copy_if( - h_data.begin(), h_data.end(), thrust::make_discard_iterator(), less_than_five(), 0); - - thrust::discard_iterator<> d_result = thrust::replace_copy_if( - d_data.begin(), d_data.end(), thrust::make_discard_iterator(), less_than_five(), 0); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ(reference, h_result); - ASSERT_EQ(reference, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; + + thrust::discard_iterator<> h_result + = thrust::replace_copy_if(h_data.begin(), + h_data.end(), + thrust::make_discard_iterator(), + less_than_five(), + 0); + + thrust::discard_iterator<> d_result + = thrust::replace_copy_if(d_data.begin(), + d_data.end(), + thrust::make_discard_iterator(), + less_than_five(), + 0); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ(reference, h_result); + ASSERT_EQ(reference, d_result); + } } } @@ -645,34 +709,42 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceCopyIfStencil) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; - - thrust::host_vector h_stencil = get_random_data(size, 0, 10); - thrust::device_vector d_stencil = h_stencil; - - thrust::host_vector h_dest(size); - thrust::device_vector d_dest(size); - - thrust::replace_copy_if(h_data.begin(), - h_data.end(), - h_stencil.begin(), - h_dest.begin(), - less_than_five(), - 0); - thrust::replace_copy_if(d_data.begin(), - d_data.end(), - d_stencil.begin(), - d_dest.begin(), - less_than_five(), - 0); - - thrust::host_vector h_data_d(d_data); - thrust::host_vector h_dest_d(d_dest); - for(size_t i = 0; i < size; i++) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); - ASSERT_NEAR(h_dest[i], h_dest_d[i], T(0.1)); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; + + thrust::host_vector h_stencil = get_random_data(size, 0, 10, seed_value + seed_value_addition); + thrust::device_vector d_stencil = h_stencil; + + thrust::host_vector h_dest(size); + thrust::device_vector d_dest(size); + + thrust::replace_copy_if(h_data.begin(), + h_data.end(), + h_stencil.begin(), + h_dest.begin(), + less_than_five(), + 0); + thrust::replace_copy_if(d_data.begin(), + d_data.end(), + d_stencil.begin(), + d_dest.begin(), + less_than_five(), + 0); + + thrust::host_vector h_data_d(d_data); + thrust::host_vector h_dest_d(d_dest); + for(size_t i = 0; i < size; i++) + { + ASSERT_NEAR(h_data[i], h_data_d[i], T(0.1)); + ASSERT_NEAR(h_dest[i], h_dest_d[i], T(0.1)); + } } } } @@ -684,32 +756,39 @@ TYPED_TEST(PrimitiveReplaceTests, ReplaceCopyIfStencilToDiscardIteratorRandomDat const std::vector sizes = get_sizes(); for(auto size : sizes) { - - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; - - thrust::host_vector h_stencil = get_random_data(size, 0, 10); - thrust::device_vector d_stencil = h_stencil; - - thrust::discard_iterator<> h_result - = thrust::replace_copy_if(h_data.begin(), - h_data.end(), - h_stencil.begin(), - thrust::make_discard_iterator(), - less_than_five(), - 0); - - thrust::discard_iterator<> d_result - = thrust::replace_copy_if(d_data.begin(), - d_data.end(), - d_stencil.begin(), - thrust::make_discard_iterator(), - less_than_five(), - 0); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ(reference, h_result); - ASSERT_EQ(reference, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; + + thrust::host_vector h_stencil = get_random_data(size, 0, 10, seed_value + seed_value_addition); + thrust::device_vector d_stencil = h_stencil; + + thrust::discard_iterator<> h_result + = thrust::replace_copy_if(h_data.begin(), + h_data.end(), + h_stencil.begin(), + thrust::make_discard_iterator(), + less_than_five(), + 0); + + thrust::discard_iterator<> d_result + = thrust::replace_copy_if(d_data.begin(), + d_data.end(), + d_stencil.begin(), + thrust::make_discard_iterator(), + less_than_five(), + 0); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ(reference, h_result); + ASSERT_EQ(reference, d_result); + } } } diff --git a/test/test_reverse_iterator.cpp b/test/test_reverse_iterator.cpp index 9ec16f7b6..527201b5c 100644 --- a/test/test_reverse_iterator.cpp +++ b/test/test_reverse_iterator.cpp @@ -142,24 +142,32 @@ TYPED_TEST(PrimitiveReverseIteratorTests, ReverseIteratorExclusiveScan) const std::vector sizes = get_sizes(); for(auto size : sizes) { - T error_margin = (T)0.01 * size; - thrust::host_vector h_data = get_random_data(size, 0, 10); + SCOPED_TRACE(testing::Message() << "with size= " << size); + T error_margin = (T)0.01 * size; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + thrust::device_vector d_data = h_data; - thrust::exclusive_scan(thrust::make_reverse_iterator(h_data.end()), - thrust::make_reverse_iterator(h_data.begin()), - h_result.begin()); + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - thrust::exclusive_scan(thrust::make_reverse_iterator(d_data.end()), - thrust::make_reverse_iterator(d_data.begin()), - d_result.begin()); + thrust::exclusive_scan(thrust::make_reverse_iterator(h_data.end()), + thrust::make_reverse_iterator(h_data.begin()), + h_result.begin()); - thrust::host_vector h_result_d(d_result); - for(size_t i = 0; i < size; i++) - ASSERT_NEAR(h_result[i], h_result_d[i], error_margin); + thrust::exclusive_scan(thrust::make_reverse_iterator(d_data.end()), + thrust::make_reverse_iterator(d_data.begin()), + d_result.begin()); + + thrust::host_vector h_result_d(d_result); + for(size_t i = 0; i < size; i++) + ASSERT_NEAR(h_result[i], h_result_d[i], error_margin); + } } }; diff --git a/test/test_scan.cpp b/test/test_scan.cpp index ca298339a..18833e2f7 100644 --- a/test/test_scan.cpp +++ b/test/test_scan.cpp @@ -156,7 +156,7 @@ TYPED_TEST(ScanVectorTests, TestScanSimple) template OutputIterator - inclusive_scan(my_system& system, InputIterator, InputIterator, OutputIterator result) +inclusive_scan(my_system& system, InputIterator, InputIterator, OutputIterator result) { system.validate_dispatch(); return result; @@ -192,7 +192,7 @@ TEST(ScanTests, TestInclusiveScanDispatchImplicit) template OutputIterator - exclusive_scan(my_system& system, InputIterator, InputIterator, OutputIterator result) +exclusive_scan(my_system& system, InputIterator, InputIterator, OutputIterator result) { system.validate_dispatch(); return result; @@ -230,19 +230,26 @@ TEST(ScanTests, TestInclusiveScan32) { using T = int; size_t n = 32; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_input - = get_random_data(n, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - thrust::host_vector h_output(n); - thrust::device_vector d_output(n); + thrust::host_vector h_input = get_random_data( + n, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; - thrust::inclusive_scan(h_input.begin(), h_input.end(), h_output.begin()); - thrust::inclusive_scan(d_input.begin(), d_input.end(), d_output.begin()); + thrust::host_vector h_output(n); + thrust::device_vector d_output(n); + + thrust::inclusive_scan(h_input.begin(), h_input.end(), h_output.begin()); + thrust::inclusive_scan(d_input.begin(), d_input.end(), d_output.begin()); - thrust::host_vector h_output_d(d_output); - ASSERT_EQ(h_output_d, h_output); + thrust::host_vector h_output_d(d_output); + ASSERT_EQ(h_output_d, h_output); + } } TEST(ScanTests, TestExclusiveScan32) @@ -250,18 +257,25 @@ TEST(ScanTests, TestExclusiveScan32) using T = int; size_t n = 32; T init = 13; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_input - = get_random_data(n, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - thrust::host_vector h_output(n); - thrust::device_vector d_output(n); + thrust::host_vector h_input = get_random_data( + n, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(n); + thrust::device_vector d_output(n); - thrust::exclusive_scan(h_input.begin(), h_input.end(), h_output.begin(), init); - thrust::exclusive_scan(d_input.begin(), d_input.end(), d_output.begin(), init); + thrust::exclusive_scan(h_input.begin(), h_input.end(), h_output.begin(), init); + thrust::exclusive_scan(d_input.begin(), d_input.end(), d_output.begin(), init); - ASSERT_EQ(d_output, h_output); + ASSERT_EQ(d_output, h_output); + } } template @@ -344,22 +358,32 @@ TYPED_TEST(ScanVariablesTests, TestScanWithOperator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - thrust::inclusive_scan(h_input.begin(), h_input.end(), h_output.begin(), max_functor()); - thrust::inclusive_scan(d_input.begin(), d_input.end(), d_output.begin(), max_functor()); - ASSERT_EQ(d_output, h_output); - - thrust::exclusive_scan( - h_input.begin(), h_input.end(), h_output.begin(), T(13), max_functor()); - thrust::exclusive_scan( - d_input.begin(), d_input.end(), d_output.begin(), T(13), max_functor()); - ASSERT_EQ(d_output, h_output); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + thrust::inclusive_scan( + h_input.begin(), h_input.end(), h_output.begin(), max_functor()); + thrust::inclusive_scan( + d_input.begin(), d_input.end(), d_output.begin(), max_functor()); + ASSERT_EQ(d_output, h_output); + + thrust::exclusive_scan( + h_input.begin(), h_input.end(), h_output.begin(), T(13), max_functor()); + thrust::exclusive_scan( + d_input.begin(), d_input.end(), d_output.begin(), T(13), max_functor()); + ASSERT_EQ(d_output, h_output); + } } } @@ -368,38 +392,45 @@ TYPED_TEST(ScanVariablesTests, TestScanWithOperatorToDiscardIterator) using T = typename TestFixture::input_type; const std::vector sizes = get_sizes(); - for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::discard_iterator<> reference(size); - - thrust::discard_iterator<> h_result = thrust::inclusive_scan( - h_input.begin(), h_input.end(), thrust::make_discard_iterator(), max_functor()); - - thrust::discard_iterator<> d_result = thrust::inclusive_scan( - d_input.begin(), d_input.end(), thrust::make_discard_iterator(), max_functor()); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); - - h_result = thrust::exclusive_scan(h_input.begin(), - h_input.end(), - thrust::make_discard_iterator(), - T(13), - max_functor()); - - d_result = thrust::exclusive_scan(d_input.begin(), - d_input.end(), - thrust::make_discard_iterator(), - T(13), - max_functor()); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::discard_iterator<> reference(size); + + thrust::discard_iterator<> h_result = thrust::inclusive_scan( + h_input.begin(), h_input.end(), thrust::make_discard_iterator(), max_functor()); + + thrust::discard_iterator<> d_result = thrust::inclusive_scan( + d_input.begin(), d_input.end(), thrust::make_discard_iterator(), max_functor()); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + + h_result = thrust::exclusive_scan(h_input.begin(), + h_input.end(), + thrust::make_discard_iterator(), + T(13), + max_functor()); + + d_result = thrust::exclusive_scan(d_input.begin(), + d_input.end(), + thrust::make_discard_iterator(), + T(13), + max_functor()); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } @@ -408,46 +439,53 @@ TYPED_TEST(ScanVariablesTests, TestScan) using T = typename TestFixture::input_type; const std::vector sizes = get_sizes(); - for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - thrust::inclusive_scan(h_input.begin(), h_input.end(), h_output.begin()); - thrust::inclusive_scan(d_input.begin(), d_input.end(), d_output.begin()); - - thrust::host_vector h_output_d(d_output); - ASSERT_EQ(h_output_d, h_output); - - thrust::exclusive_scan(h_input.begin(), h_input.end(), h_output.begin()); - thrust::exclusive_scan(d_input.begin(), d_input.end(), d_output.begin()); - h_output_d = d_output; - ASSERT_EQ(h_output_d, h_output); - - thrust::exclusive_scan(h_input.begin(), h_input.end(), h_output.begin(), (T)11); - thrust::exclusive_scan(d_input.begin(), d_input.end(), d_output.begin(), (T)11); - h_output_d = d_output; - ASSERT_EQ(h_output_d, h_output); - - // in-place scans - h_output = h_input; - d_output = d_input; - thrust::inclusive_scan(h_output.begin(), h_output.end(), h_output.begin()); - thrust::inclusive_scan(d_output.begin(), d_output.end(), d_output.begin()); - h_output_d = d_output; - ASSERT_EQ(h_output_d, h_output); - - h_output = h_input; - d_output = d_input; - thrust::exclusive_scan(h_output.begin(), h_output.end(), h_output.begin()); - thrust::exclusive_scan(d_output.begin(), d_output.end(), d_output.begin()); - h_output_d = d_output; - ASSERT_EQ(h_output_d, h_output); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + thrust::inclusive_scan(h_input.begin(), h_input.end(), h_output.begin()); + thrust::inclusive_scan(d_input.begin(), d_input.end(), d_output.begin()); + + thrust::host_vector h_output_d(d_output); + ASSERT_EQ(h_output_d, h_output); + + thrust::exclusive_scan(h_input.begin(), h_input.end(), h_output.begin()); + thrust::exclusive_scan(d_input.begin(), d_input.end(), d_output.begin()); + h_output_d = d_output; + ASSERT_EQ(h_output_d, h_output); + + thrust::exclusive_scan(h_input.begin(), h_input.end(), h_output.begin(), (T)11); + thrust::exclusive_scan(d_input.begin(), d_input.end(), d_output.begin(), (T)11); + h_output_d = d_output; + ASSERT_EQ(h_output_d, h_output); + + // in-place scans + h_output = h_input; + d_output = d_input; + thrust::inclusive_scan(h_output.begin(), h_output.end(), h_output.begin()); + thrust::inclusive_scan(d_output.begin(), d_output.end(), d_output.begin()); + h_output_d = d_output; + ASSERT_EQ(h_output_d, h_output); + + h_output = h_input; + d_output = d_input; + thrust::exclusive_scan(h_output.begin(), h_output.end(), h_output.begin()); + thrust::exclusive_scan(d_output.begin(), d_output.end(), d_output.begin()); + h_output_d = d_output; + ASSERT_EQ(h_output_d, h_output); + } } } @@ -458,67 +496,87 @@ TYPED_TEST(ScanVariablesTests, TestScanToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; - thrust::discard_iterator<> h_result = thrust::inclusive_scan( - h_input.begin(), h_input.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> h_result = thrust::inclusive_scan( + h_input.begin(), h_input.end(), thrust::make_discard_iterator()); - thrust::discard_iterator<> d_result = thrust::inclusive_scan( - d_input.begin(), d_input.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> d_result = thrust::inclusive_scan( + d_input.begin(), d_input.end(), thrust::make_discard_iterator()); - thrust::discard_iterator<> reference(size); + thrust::discard_iterator<> reference(size); - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); - h_result = thrust::exclusive_scan( - h_input.begin(), h_input.end(), thrust::make_discard_iterator(), (T)11); + h_result = thrust::exclusive_scan( + h_input.begin(), h_input.end(), thrust::make_discard_iterator(), (T)11); - d_result = thrust::exclusive_scan( - d_input.begin(), d_input.end(), thrust::make_discard_iterator(), (T)11); + d_result = thrust::exclusive_scan( + d_input.begin(), d_input.end(), thrust::make_discard_iterator(), (T)11); - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } TEST(ScanTests, TestScanMixedTypes) { const unsigned int n = 113; - - thrust::host_vector h_input = get_random_data( - n, std::numeric_limits::min(), std::numeric_limits::max()); - for(size_t i = 0; i < n; i++) - h_input[i] %= 10; - thrust::device_vector d_input = h_input; - - thrust::host_vector h_float_output(n); - thrust::device_vector d_float_output(n); - thrust::host_vector h_int_output(n); - thrust::device_vector d_int_output(n); - - //mixed input/output types - thrust::inclusive_scan(h_input.begin(), h_input.end(), h_float_output.begin()); - thrust::inclusive_scan(d_input.begin(), d_input.end(), d_float_output.begin()); - ASSERT_EQ(d_float_output, h_float_output); - - thrust::exclusive_scan(h_input.begin(), h_input.end(), h_float_output.begin(), (float)3.5); - thrust::exclusive_scan(d_input.begin(), d_input.end(), d_float_output.begin(), (float)3.5); - ASSERT_EQ(d_float_output, h_float_output); - - thrust::exclusive_scan(h_input.begin(), h_input.end(), h_float_output.begin(), (int)3); - thrust::exclusive_scan(d_input.begin(), d_input.end(), d_float_output.begin(), (int)3); - ASSERT_EQ(d_float_output, h_float_output); - - thrust::exclusive_scan(h_input.begin(), h_input.end(), h_int_output.begin(), (int)3); - thrust::exclusive_scan(d_input.begin(), d_input.end(), d_int_output.begin(), (int)3); - ASSERT_EQ(d_int_output, h_int_output); - - thrust::exclusive_scan(h_input.begin(), h_input.end(), h_int_output.begin(), (float)3.5); - thrust::exclusive_scan(d_input.begin(), d_input.end(), d_int_output.begin(), (float)3.5); - ASSERT_EQ(d_int_output, h_int_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + + thrust::host_vector h_input = get_random_data( + n, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + ); + + for(size_t i = 0; i < n; i++) + h_input[i] %= 10; + thrust::device_vector d_input = h_input; + + thrust::host_vector h_float_output(n); + thrust::device_vector d_float_output(n); + thrust::host_vector h_int_output(n); + thrust::device_vector d_int_output(n); + + //mixed input/output types + thrust::inclusive_scan(h_input.begin(), h_input.end(), h_float_output.begin()); + thrust::inclusive_scan(d_input.begin(), d_input.end(), d_float_output.begin()); + ASSERT_EQ(d_float_output, h_float_output); + + thrust::exclusive_scan(h_input.begin(), h_input.end(), h_float_output.begin(), (float)3.5); + thrust::exclusive_scan(d_input.begin(), d_input.end(), d_float_output.begin(), (float)3.5); + ASSERT_EQ(d_float_output, h_float_output); + + thrust::exclusive_scan(h_input.begin(), h_input.end(), h_float_output.begin(), (int)3); + thrust::exclusive_scan(d_input.begin(), d_input.end(), d_float_output.begin(), (int)3); + ASSERT_EQ(d_float_output, h_float_output); + + thrust::exclusive_scan(h_input.begin(), h_input.end(), h_int_output.begin(), (int)3); + thrust::exclusive_scan(d_input.begin(), d_input.end(), d_int_output.begin(), (int)3); + ASSERT_EQ(d_int_output, h_int_output); + + thrust::exclusive_scan(h_input.begin(), h_input.end(), h_int_output.begin(), (float)3.5); + thrust::exclusive_scan(d_input.begin(), d_input.end(), d_int_output.begin(), (float)3.5); + ASSERT_EQ(d_int_output, h_int_output); + } } template diff --git a/test/test_scan_by_key.cpp b/test/test_scan_by_key.cpp index 6c000a607..194c298a4 100644 --- a/test/test_scan_by_key.cpp +++ b/test/test_scan_by_key.cpp @@ -114,8 +114,8 @@ TEST(ScanByKeyTests, TestInclusiveScanByKeyDispatchExplicit) } template -OutputIterator inclusive_scan_by_key( - my_tag, InputIterator1, InputIterator1, InputIterator2, OutputIterator result) +OutputIterator +inclusive_scan_by_key(my_tag, InputIterator1, InputIterator1, InputIterator2, OutputIterator result) { *result = 13; return result; @@ -229,8 +229,8 @@ TEST(ScanByKeyTests, TestExclusiveScanByKeyDispatchExplicit) } template -OutputIterator exclusive_scan_by_key( - my_tag, InputIterator1, InputIterator1, InputIterator2, OutputIterator result) +OutputIterator +exclusive_scan_by_key(my_tag, InputIterator1, InputIterator1, InputIterator2, OutputIterator result) { *result = 13; return result; @@ -413,6 +413,7 @@ TYPED_TEST(ScanByKeyVariablesTests, TestInclusiveScanByKey) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); thrust::host_vector h_keys(size); thrust::default_random_engine rng; for(size_t i = 0, k = 0; i < size; i++) @@ -423,20 +424,27 @@ TYPED_TEST(ScanByKeyVariablesTests, TestInclusiveScanByKey) } thrust::device_vector d_keys = h_keys; - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - for(size_t i = 0; i < size; i++) - h_vals[i] = i % 10; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - thrust::inclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_output.begin()); - thrust::inclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_output.begin()); - ASSERT_EQ(d_output, h_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vals = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + for(size_t i = 0; i < size; i++) + h_vals[i] = i % 10; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + thrust::inclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_output.begin()); + thrust::inclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_output.begin()); + ASSERT_EQ(d_output, h_output); + } } } @@ -447,6 +455,7 @@ TYPED_TEST(ScanByKeyVariablesTests, TestExclusiveScanByKey) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); thrust::host_vector h_keys(size); thrust::default_random_engine rng; for(size_t i = 0, k = 0; i < size; i++) @@ -457,28 +466,35 @@ TYPED_TEST(ScanByKeyVariablesTests, TestExclusiveScanByKey) } thrust::device_vector d_keys = h_keys; - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - for(size_t i = 0; i < size; i++) - h_vals[i] = i % 10; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - // without init - thrust::exclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_output.begin()); - thrust::exclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_output.begin()); - ASSERT_EQ(d_output, h_output); - - // with init - thrust::exclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_output.begin(), (T)11); - thrust::exclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_output.begin(), (T)11); - ASSERT_EQ(d_output, h_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vals = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + for(size_t i = 0; i < size; i++) + h_vals[i] = i % 10; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + // without init + thrust::exclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_output.begin()); + thrust::exclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_output.begin()); + ASSERT_EQ(d_output, h_output); + + // with init + thrust::exclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_output.begin(), (T)11); + thrust::exclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_output.begin(), (T)11); + ASSERT_EQ(d_output, h_output); + } } } @@ -497,6 +513,7 @@ TYPED_TEST(ScanByKeyVariablesTests, TestInclusiveScanByKeyInPlace) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); thrust::host_vector h_keys(size); thrust::default_random_engine rng; for(size_t i = 0, k = 0; i < size; i++) @@ -507,23 +524,30 @@ TYPED_TEST(ScanByKeyVariablesTests, TestInclusiveScanByKeyInPlace) } thrust::device_vector d_keys = h_keys; - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - for(size_t i = 0; i < size; i++) - h_vals[i] = i % 10; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - // in-place scans - h_output = h_vals; - d_output = d_vals; - thrust::inclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_output.begin(), h_output.begin()); - thrust::inclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_output.begin(), d_output.begin()); - ASSERT_EQ(d_output, h_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vals = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + for(size_t i = 0; i < size; i++) + h_vals[i] = i % 10; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + // in-place scans + h_output = h_vals; + d_output = d_vals; + thrust::inclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_output.begin(), h_output.begin()); + thrust::inclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_output.begin(), d_output.begin()); + ASSERT_EQ(d_output, h_output); + } } } @@ -534,6 +558,7 @@ TYPED_TEST(ScanByKeyVariablesTests, TestExclusiveScanByKeyInPlace) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); thrust::host_vector h_keys(size); thrust::default_random_engine rng; for(size_t i = 0, k = 0; i < size; i++) @@ -544,19 +569,26 @@ TYPED_TEST(ScanByKeyVariablesTests, TestExclusiveScanByKeyInPlace) } thrust::device_vector d_keys = h_keys; - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - for(size_t i = 0; i < size; i++) - h_vals[i] = i % 10; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_output = h_vals; - thrust::device_vector d_output = d_vals; - thrust::exclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_output.begin(), h_output.begin(), (T)11); - thrust::exclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_output.begin(), d_output.begin(), (T)11); - ASSERT_EQ(d_output, h_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_vals = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + for(size_t i = 0; i < size; i++) + h_vals[i] = i % 10; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_output = h_vals; + thrust::device_vector d_output = d_vals; + thrust::exclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_output.begin(), h_output.begin(), (T)11); + thrust::exclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_output.begin(), d_output.begin(), (T)11); + ASSERT_EQ(d_output, h_output); + } } } @@ -574,89 +606,107 @@ TEST(ScanByKeyTests, TestScanByKeyMixedTypes) } thrust::device_vector d_keys = h_keys; - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - for(size_t i = 0; i < size; i++) - h_vals[i] %= 10; - thrust::device_vector d_vals = h_vals; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_float_output(size); - thrust::device_vector d_float_output(size); - thrust::host_vector h_int_output(size); - thrust::device_vector d_int_output(size); + thrust::host_vector h_vals = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + for(size_t i = 0; i < size; i++) + h_vals[i] %= 10; + thrust::device_vector d_vals = h_vals; - //mixed vals/output types - thrust::inclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_float_output.begin()); - thrust::inclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_float_output.begin()); - ASSERT_EQ(d_float_output, h_float_output); + thrust::host_vector h_float_output(size); + thrust::device_vector d_float_output(size); + thrust::host_vector h_int_output(size); + thrust::device_vector d_int_output(size); - thrust::exclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_float_output.begin(), (float)3.5); - thrust::exclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_float_output.begin(), (float)3.5); - ASSERT_EQ(d_float_output, h_float_output); + //mixed vals/output types + thrust::inclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_float_output.begin()); + thrust::inclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_float_output.begin()); + ASSERT_EQ(d_float_output, h_float_output); - thrust::exclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_float_output.begin(), (int)3); - thrust::exclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_float_output.begin(), (int)3); - ASSERT_EQ(d_float_output, h_float_output); + thrust::exclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_float_output.begin(), (float)3.5); + thrust::exclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_float_output.begin(), (float)3.5); + ASSERT_EQ(d_float_output, h_float_output); - thrust::exclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_int_output.begin(), (int)3); - thrust::exclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_int_output.begin(), (int)3); - ASSERT_EQ(d_int_output, h_int_output); + thrust::exclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_float_output.begin(), (int)3); + thrust::exclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_float_output.begin(), (int)3); + ASSERT_EQ(d_float_output, h_float_output); - thrust::exclusive_scan_by_key( - h_keys.begin(), h_keys.end(), h_vals.begin(), h_int_output.begin(), (float)3.5); - thrust::exclusive_scan_by_key( - d_keys.begin(), d_keys.end(), d_vals.begin(), d_int_output.begin(), (float)3.5); - ASSERT_EQ(d_int_output, h_int_output); + thrust::exclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_int_output.begin(), (int)3); + thrust::exclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_int_output.begin(), (int)3); + ASSERT_EQ(d_int_output, h_int_output); + + thrust::exclusive_scan_by_key( + h_keys.begin(), h_keys.end(), h_vals.begin(), h_int_output.begin(), (float)3.5); + thrust::exclusive_scan_by_key( + d_keys.begin(), d_keys.end(), d_vals.begin(), d_int_output.begin(), (float)3.5); + ASSERT_EQ(d_int_output, h_int_output); + } } TEST(ScanByKeyTests, TestScanByKeyLargeInput) { const unsigned int N = 1 << 20; - thrust::host_vector vals_sizes = get_random_data( - 10, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_vals - = get_random_data(N, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_vals = h_vals; + thrust::host_vector vals_sizes = get_random_data( + 10, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector h_output(N, 0); - thrust::device_vector d_output(N, 0); + thrust::host_vector h_vals = get_random_data( + N, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_vals = h_vals; - for(unsigned int i = 0; i < vals_sizes.size(); i++) - { - const unsigned int n = vals_sizes[i] % N; + thrust::host_vector h_output(N, 0); + thrust::device_vector d_output(N, 0); - // define segments - thrust::host_vector h_keys(n); - thrust::default_random_engine rng; - for(size_t i = 0, k = 0; i < n; i++) + for(unsigned int i = 0; i < vals_sizes.size(); i++) { - h_keys[i] = k; - if(rng() % 100 == 0) - k++; + const unsigned int n = vals_sizes[i] % N; + + // define segments + thrust::host_vector h_keys(n); + thrust::default_random_engine rng; + for(size_t i = 0, k = 0; i < n; i++) + { + h_keys[i] = k; + if(rng() % 100 == 0) + k++; + } + thrust::device_vector d_keys = h_keys; + + thrust::inclusive_scan_by_key( + h_keys.begin(), h_keys.begin() + n, h_vals.begin(), h_output.begin()); + thrust::inclusive_scan_by_key( + d_keys.begin(), d_keys.begin() + n, d_vals.begin(), d_output.begin()); + ASSERT_EQ(d_output, h_output); + + thrust::inclusive_scan_by_key( + h_keys.begin(), h_keys.begin() + n, h_vals.begin(), h_output.begin()); + thrust::inclusive_scan_by_key( + d_keys.begin(), d_keys.begin() + n, d_vals.begin(), d_output.begin()); + ASSERT_EQ(d_output, h_output); } - thrust::device_vector d_keys = h_keys; - - thrust::inclusive_scan_by_key( - h_keys.begin(), h_keys.begin() + n, h_vals.begin(), h_output.begin()); - thrust::inclusive_scan_by_key( - d_keys.begin(), d_keys.begin() + n, d_vals.begin(), d_output.begin()); - ASSERT_EQ(d_output, h_output); - - thrust::inclusive_scan_by_key( - h_keys.begin(), h_keys.begin() + n, h_vals.begin(), h_output.begin()); - thrust::inclusive_scan_by_key( - d_keys.begin(), d_keys.begin() + n, d_vals.begin(), d_output.begin()); - ASSERT_EQ(d_output, h_output); } } diff --git a/test/test_scatter.cpp b/test/test_scatter.cpp index cdb565bb9..55284beab 100644 --- a/test/test_scatter.cpp +++ b/test/test_scatter.cpp @@ -110,28 +110,38 @@ TYPED_TEST(ScatterPrimitiveTests, TestScatter) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); + const size_t output_size = std::min((size_t)10, 2 * size); thrust::host_vector h_input(size, (T)1); thrust::device_vector d_input(size, (T)1); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + - thrust::host_vector h_map - = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); + thrust::host_vector h_map + = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % output_size; + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % output_size; - thrust::device_vector d_map = h_map; + thrust::device_vector d_map = h_map; - thrust::host_vector h_output(output_size, T(0)); - thrust::device_vector d_output(output_size, T(0)); + thrust::host_vector h_output(output_size, T(0)); + thrust::device_vector d_output(output_size, T(0)); - thrust::scatter(h_input.begin(), h_input.end(), h_map.begin(), h_output.begin()); - thrust::scatter(d_input.begin(), d_input.end(), d_map.begin(), d_output.begin()); + thrust::scatter(h_input.begin(), h_input.end(), h_map.begin(), h_output.begin()); + thrust::scatter(d_input.begin(), d_input.end(), d_map.begin(), d_output.begin()); - ASSERT_EQ(h_output, d_output); + ASSERT_EQ(h_output, d_output); + } } } @@ -142,27 +152,37 @@ TYPED_TEST(ScatterPrimitiveTests, TestScatterToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); + const size_t output_size = std::min((size_t)10, 2 * size); thrust::host_vector h_input(size, (T)1); thrust::device_vector d_input(size, (T)1); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + - thrust::host_vector h_map - = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); + thrust::host_vector h_map + = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % output_size; + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % output_size; - thrust::device_vector d_map = h_map; + thrust::device_vector d_map = h_map; - thrust::scatter( - h_input.begin(), h_input.end(), h_map.begin(), thrust::make_discard_iterator()); - thrust::scatter( - d_input.begin(), d_input.end(), d_map.begin(), thrust::make_discard_iterator()); + thrust::scatter( + h_input.begin(), h_input.end(), h_map.begin(), thrust::make_discard_iterator()); + thrust::scatter( + d_input.begin(), d_input.end(), d_map.begin(), thrust::make_discard_iterator()); - // there's nothing to check -- just make sure it compiles + // there's nothing to check -- just make sure it compiles + } } } @@ -284,34 +304,42 @@ TYPED_TEST(ScatterPrimitiveTests, TestScatterIf) thrust::host_vector h_input(size, T(1)); thrust::device_vector d_input(size, T(1)); - - thrust::host_vector h_map - = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); - - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % output_size; - - thrust::device_vector d_map = h_map; - - thrust::host_vector h_output(output_size, T(0)); - thrust::device_vector d_output(output_size, T(0)); - - thrust::scatter_if(h_input.begin(), - h_input.end(), - h_map.begin(), - h_map.begin(), - h_output.begin(), - is_even_scatter_if()); - thrust::scatter_if(d_input.begin(), - d_input.end(), - d_map.begin(), - d_map.begin(), - d_output.begin(), - is_even_scatter_if()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + + thrust::host_vector h_map + = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % output_size; + + thrust::device_vector d_map = h_map; + + thrust::host_vector h_output(output_size, T(0)); + thrust::device_vector d_output(output_size, T(0)); + + thrust::scatter_if(h_input.begin(), + h_input.end(), + h_map.begin(), + h_map.begin(), + h_output.begin(), + is_even_scatter_if()); + thrust::scatter_if(d_input.begin(), + d_input.end(), + d_map.begin(), + d_map.begin(), + d_output.begin(), + is_even_scatter_if()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -322,33 +350,43 @@ TYPED_TEST(ScatterPrimitiveTests, TestScatterIfToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); + const size_t output_size = std::min((size_t)10, 2 * size); thrust::host_vector h_input(size, T(1)); thrust::device_vector d_input(size, T(1)); - - thrust::host_vector h_map - = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); - - for(size_t i = 0; i < size; i++) - h_map[i] = h_map[i] % output_size; - - thrust::device_vector d_map = h_map; - - thrust::scatter_if(h_input.begin(), - h_input.end(), - h_map.begin(), - h_map.begin(), - thrust::make_discard_iterator(), - is_even_scatter_if()); - thrust::scatter_if(d_input.begin(), - d_input.end(), - d_map.begin(), - d_map.begin(), - thrust::make_discard_iterator(), - is_even_scatter_if()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + + thrust::host_vector h_map + = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + + for(size_t i = 0; i < size; i++) + h_map[i] = h_map[i] % output_size; + + thrust::device_vector d_map = h_map; + + thrust::scatter_if(h_input.begin(), + h_input.end(), + h_map.begin(), + h_map.begin(), + thrust::make_discard_iterator(), + is_even_scatter_if()); + thrust::scatter_if(d_input.begin(), + d_input.end(), + d_map.begin(), + d_map.begin(), + thrust::make_discard_iterator(), + is_even_scatter_if()); + } } } @@ -433,4 +471,4 @@ TYPED_TEST(ScatterTests, TestScatterIfCountingIterator) output.begin()); ASSERT_EQ(output, map); -} \ No newline at end of file +} diff --git a/test/test_seed.hpp b/test/test_seed.hpp new file mode 100644 index 000000000..6508ae6b4 --- /dev/null +++ b/test/test_seed.hpp @@ -0,0 +1,27 @@ +/* + * Copyright 2008-2013 NVIDIA Corporation + * Modifications Copyright© 2020 Advanced Micro Devices, Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef TEST_SEED_HPP_ +#define TEST_SEED_HPP_ + +static constexpr int random_seeds_count = 2; +static constexpr unsigned int seeds [] = {0, 2, 1000}; +static constexpr size_t seed_size = sizeof(seeds) / sizeof(seeds[0]); + +static constexpr unsigned int seed_value_addition = 100; + +#endif // TEST_SEED_HPP_ diff --git a/test/test_set_difference.cpp b/test/test_set_difference.cpp index 6446fae17..295b6166a 100644 --- a/test/test_set_difference.cpp +++ b/test/test_set_difference.cpp @@ -105,42 +105,57 @@ TYPED_TEST(SetDifferencePrimitiveTests, TestSetDifference) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); size_t expanded_sizes[] = {0, 1, size / 2, size, size + 1, 2 * size}; size_t num_expanded_sizes = sizeof(expanded_sizes) / sizeof(size_t); - thrust::host_vector random = get_random_data( - size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), - 0, - 255); - - thrust::host_vector h_a(random.begin(), random.begin() + size); - thrust::host_vector h_b(random.begin() + size, random.end()); - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - for(size_t i = 0; i < num_expanded_sizes; i++) + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t expanded_size = expanded_sizes[i]; - - thrust::host_vector h_result(size + expanded_size); - thrust::device_vector d_result(size + expanded_size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_difference( - h_a.begin(), h_a.end(), h_b.begin(), h_b.begin() + expanded_size, h_result.begin()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_difference( - d_a.begin(), d_a.end(), d_b.begin(), d_b.begin() + expanded_size, d_result.begin()); - d_result.resize(d_end - d_result.begin()); - - ASSERT_EQ(h_result, d_result); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random = get_random_data( + size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), + 0, + 255, + seed_value); + + thrust::host_vector h_a(random.begin(), random.begin() + size); + thrust::host_vector h_b(random.begin() + size, random.end()); + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + for(size_t i = 0; i < num_expanded_sizes; i++) + { + size_t expanded_size = expanded_sizes[i]; + + thrust::host_vector h_result(size + expanded_size); + thrust::device_vector d_result(size + expanded_size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_difference(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.begin() + expanded_size, + h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_difference(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.begin() + expanded_size, + d_result.begin()); + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } } @@ -153,32 +168,39 @@ TYPED_TEST(SetDifferencePrimitiveTests, TestSetDifferenceEquivalentRanges) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a = temp; - thrust::sort(h_a.begin(), h_a.end()); - thrust::host_vector h_b = h_a; + thrust::host_vector temp = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector h_a = temp; + thrust::sort(h_a.begin(), h_a.end()); + thrust::host_vector h_b = h_a; - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - h_end = thrust::set_difference( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); - h_result.resize(h_end - h_result.begin()); + h_end = thrust::set_difference( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.resize(h_end - h_result.begin()); - d_end = thrust::set_difference( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + d_end = thrust::set_difference( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); - d_result.resize(d_end - d_result.begin()); + d_result.resize(d_end - d_result.begin()); - ASSERT_EQ(h_result, d_result); + ASSERT_EQ(h_result, d_result); + } } } @@ -190,41 +212,49 @@ TYPED_TEST(SetDifferencePrimitiveTests, TestSetDifferenceMultiset) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - // restrict elements to [min,13) - for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - int temp = static_cast(*i); - temp %= 13; - *i = temp; - } + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::sort(h_a.begin(), h_a.end()); - thrust::sort(h_b.begin(), h_b.end()); + // restrict elements to [min,13) + for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + { + int temp = static_cast(*i); + temp %= 13; + *i = temp; + } - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + thrust::sort(h_a.begin(), h_a.end()); + thrust::sort(h_b.begin(), h_b.end()); - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - h_end = thrust::set_difference( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); - h_result.resize(h_end - h_result.begin()); + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - d_end = thrust::set_difference( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - d_result.resize(d_end - d_result.begin()); + h_end = thrust::set_difference( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_difference( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); - ASSERT_EQ(h_result, d_result); + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } diff --git a/test/test_set_difference_by_key.cpp b/test/test_set_difference_by_key.cpp index 7a375eaae..cacde7efe 100644 --- a/test/test_set_difference_by_key.cpp +++ b/test/test_set_difference_by_key.cpp @@ -155,50 +155,141 @@ TYPED_TEST(SetDifferenceByKeyPrimitiveTests, TestSetDifferenceByKey) using T = typename TestFixture::input_type; const std::vector sizes = get_sizes(); - for(auto size : sizes) { - thrust::host_vector temp - = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); - - thrust::host_vector random_keys - = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); - thrust::host_vector random_vals - = get_random_data(size, - std::numeric_limits::min(), - std::numeric_limits::max()); - - size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - size_t num_denominators = sizeof(denominators) / sizeof(size_t); - - for(size_t i = 0; i < num_denominators; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t size_a = size / denominators[i]; - - thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); - thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); - - thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); - thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); - - thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); - thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); - - thrust::device_vector d_a_keys = h_a_keys; - thrust::device_vector d_b_keys = h_b_keys; - - thrust::device_vector d_a_vals = h_a_vals; - thrust::device_vector d_b_vals = h_b_vals; + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + + thrust::host_vector random_keys = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector random_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + size_t num_denominators = sizeof(denominators) / sizeof(size_t); + + for(size_t i = 0; i < num_denominators; ++i) + { + size_t size_a = size / denominators[i]; + + thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); + thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + + thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); + thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + + thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); + thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); + + thrust::device_vector d_a_keys = h_a_keys; + thrust::device_vector d_b_keys = h_b_keys; + + thrust::device_vector d_a_vals = h_a_vals; + thrust::device_vector d_b_vals = h_b_vals; + + thrust::host_vector h_result_keys(size); + thrust::host_vector h_result_vals(size); + + thrust::device_vector d_result_keys(size); + thrust::device_vector d_result_vals(size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_difference_by_key(h_a_keys.begin(), + h_a_keys.end(), + h_b_keys.begin(), + h_b_keys.end(), + h_a_vals.begin(), + h_b_vals.begin(), + h_result_keys.begin(), + h_result_vals.begin()); + h_result_keys.erase(h_end.first, h_result_keys.end()); + h_result_vals.erase(h_end.second, h_result_vals.end()); + + d_end = thrust::set_difference_by_key(d_a_keys.begin(), + d_a_keys.end(), + d_b_keys.begin(), + d_b_keys.end(), + d_a_vals.begin(), + d_b_vals.begin(), + d_result_keys.begin(), + d_result_vals.begin()); + d_result_keys.erase(d_end.first, d_result_keys.end()); + d_result_vals.erase(d_end.second, d_result_vals.end()); + + ASSERT_EQ(h_result_keys, d_result_keys); + ASSERT_EQ(h_result_vals, d_result_vals); + } + } + } +} - thrust::host_vector h_result_keys(size); - thrust::host_vector h_result_vals(size); +TYPED_TEST(SetDifferenceByKeyPrimitiveTests, TestSetDifferenceByKeyEquivalentRanges) +{ + using T = typename TestFixture::input_type; - thrust::device_vector d_result_keys(size); - thrust::device_vector d_result_vals(size); + const std::vector sizes = get_sizes();\ + for(auto size : sizes) + { + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a_key = temp; + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::host_vector h_b_key = h_a_key; + + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + thrust::host_vector h_result_key(size), h_result_val(size); + thrust::device_vector d_result_key(size), d_result_val(size); thrust::pair::iterator, typename thrust::host_vector::iterator> @@ -208,168 +299,118 @@ TYPED_TEST(SetDifferenceByKeyPrimitiveTests, TestSetDifferenceByKey) typename thrust::device_vector::iterator> d_end; - h_end = thrust::set_difference_by_key(h_a_keys.begin(), - h_a_keys.end(), - h_b_keys.begin(), - h_b_keys.end(), - h_a_vals.begin(), - h_b_vals.begin(), - h_result_keys.begin(), - h_result_vals.begin()); - h_result_keys.erase(h_end.first, h_result_keys.end()); - h_result_vals.erase(h_end.second, h_result_vals.end()); - - d_end = thrust::set_difference_by_key(d_a_keys.begin(), - d_a_keys.end(), - d_b_keys.begin(), - d_b_keys.end(), - d_a_vals.begin(), - d_b_vals.begin(), - d_result_keys.begin(), - d_result_vals.begin()); - d_result_keys.erase(d_end.first, d_result_keys.end()); - d_result_vals.erase(d_end.second, d_result_vals.end()); - - ASSERT_EQ(h_result_keys, d_result_keys); - ASSERT_EQ(h_result_vals, d_result_vals); + h_end = thrust::set_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } } } -TYPED_TEST(SetDifferenceByKeyPrimitiveTests, TestSetDifferenceByKeyEquivalentRanges) +TYPED_TEST(SetDifferenceByKeyPrimitiveTests, TestSetDifferenceByKeyMultiset) { using T = typename TestFixture::input_type; const std::vector sizes = get_sizes(); - for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key = temp; - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::host_vector h_b_key = h_a_key; - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - thrust::host_vector h_result_key(size), h_result_val(size); - thrust::device_vector d_result_key(size), d_result_val(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); - } -} - -TYPED_TEST(SetDifferenceByKeyPrimitiveTests, TestSetDifferenceByKeyMultiset) -{ - using T = typename TestFixture::input_type; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + // restrict elements to [min,13) + for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + { + int temp = static_cast(*i); + temp %= 13; + *i = temp; + } + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::sort(h_b_key.begin(), h_b_key.end()); + + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + thrust::host_vector h_result_key(size), h_result_val(size); + thrust::device_vector d_result_key(size), d_result_val(size); - const std::vector sizes = get_sizes(); + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; - for(auto size : sizes) - { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; - // restrict elements to [min,13) - for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) - { - int temp = static_cast(*i); - temp %= 13; - *i = temp; + h_end = thrust::set_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::sort(h_b_key.begin(), h_b_key.end()); - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - thrust::host_vector h_result_key(size), h_result_val(size); - thrust::device_vector d_result_key(size), d_result_val(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); } } diff --git a/test/test_set_difference_by_key_descending.cpp b/test/test_set_difference_by_key_descending.cpp index c9de25eaa..f5aaa7e47 100644 --- a/test/test_set_difference_by_key_descending.cpp +++ b/test/test_set_difference_by_key_descending.cpp @@ -85,62 +85,78 @@ TYPED_TEST(SetDifferenceByKeyDescendingPrimitiveTests, TestSetDifferenceByKeyDes for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); - thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); - - thrust::host_vector h_a_val = get_random_data( - h_a_key.size(), std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - h_b_key.size(), std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - thrust::host_vector h_result_key(size), h_result_val(size); - thrust::device_vector d_result_key(size), d_result_val(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin(), - thrust::greater()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin(), - thrust::greater()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); + thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); + + thrust::host_vector h_a_val = get_random_data( + h_a_key.size(), + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + h_b_key.size(), + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + thrust::host_vector h_result_key(size), h_result_val(size); + thrust::device_vector d_result_key(size), d_result_val(size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin(), + thrust::greater()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin(), + thrust::greater()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); + } } } diff --git a/test/test_set_difference_descending.cpp b/test/test_set_difference_descending.cpp index e316993e7..07f30b7d8 100644 --- a/test/test_set_difference_descending.cpp +++ b/test/test_set_difference_descending.cpp @@ -60,36 +60,51 @@ TYPED_TEST(SetDifferenceDescendingPrimitiveTests, TestSetDifferenceDescending) using T = typename TestFixture::input_type; const std::vector sizes = get_sizes(); - for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); - - thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); - thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_difference( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin(), thrust::greater()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_difference( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin(), thrust::greater()); - - d_result.resize(d_end - d_result.begin()); - - ASSERT_EQ(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); + + thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); + thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_difference(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.end(), + h_result.begin(), + thrust::greater()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_difference(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.end(), + d_result.begin(), + thrust::greater()); + + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } diff --git a/test/test_set_intersection.cpp b/test/test_set_intersection.cpp index 471077ba2..703204f11 100644 --- a/test/test_set_intersection.cpp +++ b/test/test_set_intersection.cpp @@ -104,42 +104,57 @@ TYPED_TEST(SetIntersectionPrimitiveTests, TestSetIntersectionSimple) const std::vector sizes = get_sizes(); for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); size_t expanded_sizes[] = {0, 1, size / 2, size, size + 1, 2 * size}; size_t num_expanded_sizes = sizeof(expanded_sizes) / sizeof(size_t); - thrust::host_vector random = get_random_data( - size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), - 0, - 255); - - thrust::host_vector h_a(random.begin(), random.begin() + size); - thrust::host_vector h_b(random.begin() + size, random.end()); - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - for(size_t i = 0; i < num_expanded_sizes; i++) + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t expanded_size = expanded_sizes[i]; - - thrust::host_vector h_result(size + expanded_size); - thrust::device_vector d_result(size + expanded_size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_intersection( - h_a.begin(), h_a.end(), h_b.begin(), h_b.begin() + expanded_size, h_result.begin()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_intersection( - d_a.begin(), d_a.end(), d_b.begin(), d_b.begin() + expanded_size, d_result.begin()); - d_result.resize(d_end - d_result.begin()); - - ASSERT_EQ(h_result, d_result); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random = get_random_data( + size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), + 0, + 255, + seed_value); + + thrust::host_vector h_a(random.begin(), random.begin() + size); + thrust::host_vector h_b(random.begin() + size, random.end()); + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + for(size_t i = 0; i < num_expanded_sizes; i++) + { + size_t expanded_size = expanded_sizes[i]; + + thrust::host_vector h_result(size + expanded_size); + thrust::device_vector d_result(size + expanded_size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_intersection(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.begin() + expanded_size, + h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_intersection(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.begin() + expanded_size, + d_result.begin()); + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } } @@ -152,35 +167,43 @@ TYPED_TEST(SetIntersectionPrimitiveTests, TestSetIntersectionToDiscardIterator) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); - thrust::sort(h_a.begin(), h_a.end()); - thrust::sort(h_b.begin(), h_b.end()); + thrust::sort(h_a.begin(), h_a.end()); + thrust::sort(h_b.begin(), h_b.end()); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - thrust::discard_iterator<> h_result; - thrust::discard_iterator<> d_result; + thrust::discard_iterator<> h_result; + thrust::discard_iterator<> d_result; - thrust::host_vector h_reference(size); - typename thrust::host_vector::iterator h_end = thrust::set_intersection( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_reference.begin()); - h_reference.erase(h_end, h_reference.end()); + thrust::host_vector h_reference(size); + typename thrust::host_vector::iterator h_end = thrust::set_intersection( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_reference.begin()); + h_reference.erase(h_end, h_reference.end()); - h_result = thrust::set_intersection( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), thrust::make_discard_iterator()); + h_result = thrust::set_intersection( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), thrust::make_discard_iterator()); - d_result = thrust::set_intersection( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), thrust::make_discard_iterator()); + d_result = thrust::set_intersection( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), thrust::make_discard_iterator()); - thrust::discard_iterator<> reference(h_reference.size()); + thrust::discard_iterator<> reference(h_reference.size()); - EXPECT_EQ(reference, h_result); - EXPECT_EQ(reference, d_result); + EXPECT_EQ(reference, h_result); + EXPECT_EQ(reference, d_result); + } } } @@ -192,32 +215,40 @@ TYPED_TEST(SetIntersectionPrimitiveTests, TestSetIntersectionEquivalentRanges) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a = temp; - thrust::sort(h_a.begin(), h_a.end()); - thrust::host_vector h_b = h_a; + thrust::host_vector temp = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector h_a = temp; + thrust::sort(h_a.begin(), h_a.end()); + thrust::host_vector h_b = h_a; - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - h_end = thrust::set_intersection( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); - h_result.resize(h_end - h_result.begin()); + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - d_end = thrust::set_intersection( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + h_end = thrust::set_intersection( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_intersection( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); - d_result.resize(d_end - d_result.begin()); + d_result.resize(d_end - d_result.begin()); - ASSERT_EQ(h_result, d_result); + ASSERT_EQ(h_result, d_result); + } } } @@ -229,41 +260,49 @@ TYPED_TEST(SetIntersectionPrimitiveTests, TestSetIntersectionMultiset) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - // restrict elements to [min,13) - for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - int temp = static_cast(*i); - temp %= 13; - *i = temp; - } + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::sort(h_a.begin(), h_a.end()); - thrust::sort(h_b.begin(), h_b.end()); + // restrict elements to [min,13) + for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + { + int temp = static_cast(*i); + temp %= 13; + *i = temp; + } - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); + thrust::sort(h_a.begin(), h_a.end()); + thrust::sort(h_b.begin(), h_b.end()); - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - h_end = thrust::set_intersection( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); - h_result.resize(h_end - h_result.begin()); + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); - d_end = thrust::set_intersection( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_intersection( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.resize(h_end - h_result.begin()); - d_result.resize(d_end - d_result.begin()); + d_end = thrust::set_intersection( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + + d_result.resize(d_end - d_result.begin()); - ASSERT_EQ(h_result, d_result); + ASSERT_EQ(h_result, d_result); + } } } diff --git a/test/test_set_intersection_by_key.cpp b/test/test_set_intersection_by_key.cpp index 3efbd6bc8..8da31b27d 100644 --- a/test/test_set_intersection_by_key.cpp +++ b/test/test_set_intersection_by_key.cpp @@ -157,37 +157,134 @@ TYPED_TEST(SetIntersectionByKeyPrimitiveTests, TestSetDifferenceByKey) const std::vector sizes = get_sizes(); for(auto size : sizes) { - - thrust::host_vector random_keys = get_random_data(size, 0, 255); - thrust::host_vector random_vals = get_random_data(size, 0, 255); - - size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - size_t num_denominators = sizeof(denominators) / sizeof(size_t); - - for(size_t i = 0; i < num_denominators; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t size_a = size / denominators[i]; - - thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); - thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); - - thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); - thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); - - thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); - thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); - - thrust::device_vector d_a_keys = h_a_keys; - thrust::device_vector d_b_keys = h_b_keys; + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random_keys = get_random_data( + size, + 0, + 255, + seed_value + ); + thrust::host_vector random_vals = get_random_data( + size, + 0, + 255, + seed_value + seed_value_addition + ); + + size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + size_t num_denominators = sizeof(denominators) / sizeof(size_t); + + for(size_t i = 0; i < num_denominators; ++i) + { + size_t size_a = size / denominators[i]; + + thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); + thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + + thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); + thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + + thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); + thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); + + thrust::device_vector d_a_keys = h_a_keys; + thrust::device_vector d_b_keys = h_b_keys; + + thrust::device_vector d_a_vals = h_a_vals; + thrust::device_vector d_b_vals = h_b_vals; + + thrust::host_vector h_result_keys(size); + thrust::host_vector h_result_vals(size); + + thrust::device_vector d_result_keys(size); + thrust::device_vector d_result_vals(size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_difference_by_key(h_a_keys.begin(), + h_a_keys.end(), + h_b_keys.begin(), + h_b_keys.end(), + h_a_vals.begin(), + h_b_vals.begin(), + h_result_keys.begin(), + h_result_vals.begin()); + h_result_keys.erase(h_end.first, h_result_keys.end()); + h_result_vals.erase(h_end.second, h_result_vals.end()); + + d_end = thrust::set_difference_by_key(d_a_keys.begin(), + d_a_keys.end(), + d_b_keys.begin(), + d_b_keys.end(), + d_a_vals.begin(), + d_b_vals.begin(), + d_result_keys.begin(), + d_result_vals.begin()); + d_result_keys.erase(d_end.first, d_result_keys.end()); + d_result_vals.erase(d_end.second, d_result_vals.end()); + + ASSERT_EQ(h_result_keys, d_result_keys); + ASSERT_EQ(h_result_vals, d_result_vals); + } + } + } +} - thrust::device_vector d_a_vals = h_a_vals; - thrust::device_vector d_b_vals = h_b_vals; +TYPED_TEST(SetIntersectionByKeyPrimitiveTests, TestSetDifferenceByKeyEquivalentRanges) +{ + using T = typename TestFixture::input_type; - thrust::host_vector h_result_keys(size); - thrust::host_vector h_result_vals(size); + const std::vector sizes = get_sizes(); - thrust::device_vector d_result_keys(size); - thrust::device_vector d_result_vals(size); + for(auto size : sizes) + { + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a_key = temp; + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::host_vector h_b_key = h_a_key; + + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + thrust::host_vector h_result_key(size), h_result_val(size); + thrust::device_vector d_result_key(size), d_result_val(size); thrust::pair::iterator, typename thrust::host_vector::iterator> @@ -197,35 +294,35 @@ TYPED_TEST(SetIntersectionByKeyPrimitiveTests, TestSetDifferenceByKey) typename thrust::device_vector::iterator> d_end; - h_end = thrust::set_difference_by_key(h_a_keys.begin(), - h_a_keys.end(), - h_b_keys.begin(), - h_b_keys.end(), - h_a_vals.begin(), - h_b_vals.begin(), - h_result_keys.begin(), - h_result_vals.begin()); - h_result_keys.erase(h_end.first, h_result_keys.end()); - h_result_vals.erase(h_end.second, h_result_vals.end()); - - d_end = thrust::set_difference_by_key(d_a_keys.begin(), - d_a_keys.end(), - d_b_keys.begin(), - d_b_keys.end(), - d_a_vals.begin(), - d_b_vals.begin(), - d_result_keys.begin(), - d_result_vals.begin()); - d_result_keys.erase(d_end.first, d_result_keys.end()); - d_result_vals.erase(d_end.second, d_result_vals.end()); - - ASSERT_EQ(h_result_keys, d_result_keys); - ASSERT_EQ(h_result_vals, d_result_vals); + h_end = thrust::set_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } } } -TYPED_TEST(SetIntersectionByKeyPrimitiveTests, TestSetDifferenceByKeyEquivalentRanges) +TYPED_TEST(SetIntersectionByKeyPrimitiveTests, TestSetDifferenceByKeyMultiset) { using T = typename TestFixture::input_type; @@ -233,132 +330,84 @@ TYPED_TEST(SetIntersectionByKeyPrimitiveTests, TestSetDifferenceByKeyEquivalentR for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key = temp; - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::host_vector h_b_key = h_a_key; - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - thrust::host_vector h_result_key(size), h_result_val(size); - thrust::device_vector d_result_key(size), d_result_val(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); - } -} - -TYPED_TEST(SetIntersectionByKeyPrimitiveTests, TestSetDifferenceByKeyMultiset) -{ - using T = typename TestFixture::input_type; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + // restrict elements to [min,13) + for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + { + int temp = static_cast(*i); + temp %= 13; + *i = temp; + } + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::sort(h_b_key.begin(), h_b_key.end()); + + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + thrust::host_vector h_result_key(size), h_result_val(size); + thrust::device_vector d_result_key(size), d_result_val(size); - const std::vector sizes = get_sizes(); + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; - for(auto size : sizes) - { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; - // restrict elements to [min,13) - for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) - { - int temp = static_cast(*i); - temp %= 13; - *i = temp; + h_end = thrust::set_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::sort(h_b_key.begin(), h_b_key.end()); - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - thrust::host_vector h_result_key(size), h_result_val(size); - thrust::device_vector d_result_key(size), d_result_val(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); } } diff --git a/test/test_set_intersection_by_key_descending.cpp b/test/test_set_intersection_by_key_descending.cpp index 4df33126e..c2d865a51 100644 --- a/test/test_set_intersection_by_key_descending.cpp +++ b/test/test_set_intersection_by_key_descending.cpp @@ -76,58 +76,70 @@ TYPED_TEST(SetIntersectionByKeyDescendingPrimitiveTests, TestSetIntersectionByKe for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); - thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); - - thrust::host_vector h_a_val = get_random_data( - h_a_key.size(), std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - - thrust::host_vector h_result_key(size), h_result_val(size); - thrust::device_vector d_result_key(size), d_result_val(size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_intersection_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_result_key.begin(), - h_result_val.begin(), - thrust::greater()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_intersection_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_result_key.begin(), - d_result_val.begin(), - thrust::greater()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - thrust::host_vector d_result_key_H(d_result_key), d_result_val_H(d_result_val); - ASSERT_EQ(h_result_key, d_result_key_H); - ASSERT_EQ(h_result_val, d_result_val_H); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); + thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); + + thrust::host_vector h_a_val = get_random_data( + h_a_key.size(), + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + + thrust::host_vector h_result_key(size), h_result_val(size); + thrust::device_vector d_result_key(size), d_result_val(size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_intersection_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_result_key.begin(), + h_result_val.begin(), + thrust::greater()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_intersection_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_result_key.begin(), + d_result_val.begin(), + thrust::greater()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + thrust::host_vector d_result_key_H(d_result_key), d_result_val_H(d_result_val); + ASSERT_EQ(h_result_key, d_result_key_H); + ASSERT_EQ(h_result_val, d_result_val_H); + } } } diff --git a/test/test_set_intersection_descending.cpp b/test/test_set_intersection_descending.cpp index 5e785912d..59c289044 100644 --- a/test/test_set_intersection_descending.cpp +++ b/test/test_set_intersection_descending.cpp @@ -61,33 +61,49 @@ TYPED_TEST(SetIntersectionDescendingPrimitiveTests, TestSetIntersectionDescendin for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); - - thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); - thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_intersection( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin(), thrust::greater()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_intersection( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin(), thrust::greater()); - - d_result.resize(d_end - d_result.begin()); - - ASSERT_EQ(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); + + thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); + thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_intersection(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.end(), + h_result.begin(), + thrust::greater()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_intersection(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.end(), + d_result.begin(), + thrust::greater()); + + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } diff --git a/test/test_set_intersection_key_value.cpp b/test/test_set_intersection_key_value.cpp index bdda5d55e..4f9c41223 100644 --- a/test/test_set_intersection_key_value.cpp +++ b/test/test_set_intersection_key_value.cpp @@ -32,47 +32,67 @@ TYPED_TEST(SetIntersectionKeyValueTests, TestSetIntersectionKeyValue) for(auto size : sizes) { - thrust::host_vector h_keys_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_keys_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(size), h_b(size); - - for(size_t i = 0; i < size; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - h_a[i] = T(h_keys_a[i], h_values_a[i]); - h_b[i] = T(h_keys_b[i], h_values_b[i]); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys_a = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_values_a = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_keys_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + thrust::host_vector h_values_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 3 * seed_value_addition + ); + + thrust::host_vector h_a(size), h_b(size); + + for(size_t i = 0; i < size; ++i) + { + h_a[i] = T(h_keys_a[i], h_values_a[i]); + h_b[i] = T(h_keys_b[i], h_values_b[i]); + } + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(size); + thrust::device_vector d_result(size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_intersection( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_intersection( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + + d_result.resize(d_end - d_result.begin()); + + thrust::host_vector d_result_host(d_result); + + ASSERT_EQ(h_result, d_result_host); } - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - thrust::host_vector h_result(size); - thrust::device_vector d_result(size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_intersection( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_intersection( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); - - d_result.resize(d_end - d_result.begin()); - - thrust::host_vector d_result_host(d_result); - - ASSERT_EQ(h_result, d_result_host); } } diff --git a/test/test_set_symmetric_difference.cpp b/test/test_set_symmetric_difference.cpp index 4b3d7fe44..c462b56fc 100644 --- a/test/test_set_symmetric_difference.cpp +++ b/test/test_set_symmetric_difference.cpp @@ -29,61 +29,48 @@ TESTS_DEFINE(SetSymmetricDifferenceTests, FullTestsParams); TESTS_DEFINE(SetSymmetricDifferencePrimitiveTests, NumericalTestsParams); TESTS_DEFINE(SetSymmetricDifferenceIntegerTests, IntegerTestsParams); -template -OutputIterator set_symmetric_difference(my_system &system, +template +OutputIterator set_symmetric_difference(my_system& system, InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator result) { - system.validate_dispatch(); - return result; + system.validate_dispatch(); + return result; } TEST(SetSymmetricDifferenceTests, TestSetSymmetricDifferenceDispatchExplicit) { - thrust::device_vector vec(1); + thrust::device_vector vec(1); - my_system sys(0); - thrust::set_symmetric_difference(sys, - vec.begin(), - vec.begin(), - vec.begin(), - vec.begin(), - vec.begin()); + my_system sys(0); + thrust::set_symmetric_difference( + sys, vec.begin(), vec.begin(), vec.begin(), vec.begin(), vec.begin()); - ASSERT_EQ(true, sys.is_valid()); + ASSERT_EQ(true, sys.is_valid()); } - -template -OutputIterator set_symmetric_difference(my_tag, - InputIterator1, - InputIterator1, - InputIterator2, - InputIterator2, - OutputIterator result) +template +OutputIterator set_symmetric_difference( + my_tag, InputIterator1, InputIterator1, InputIterator2, InputIterator2, OutputIterator result) { - *result = 13; - return result; + *result = 13; + return result; } TEST(SetSymmetricDifferenceTests, TestSetSymmetricDifferenceDispatchImplicit) { - thrust::device_vector vec(1); + thrust::device_vector vec(1); - thrust::set_symmetric_difference(thrust::retag(vec.begin()), - thrust::retag(vec.begin()), - thrust::retag(vec.begin()), - thrust::retag(vec.begin()), - thrust::retag(vec.begin())); + thrust::set_symmetric_difference(thrust::retag(vec.begin()), + thrust::retag(vec.begin()), + thrust::retag(vec.begin()), + thrust::retag(vec.begin()), + thrust::retag(vec.begin())); - ASSERT_EQ(13, vec.front()); + ASSERT_EQ(13, vec.front()); } TYPED_TEST(SetSymmetricDifferenceTests, TestSetSymmetricDifferenceSimple) @@ -91,22 +78,32 @@ TYPED_TEST(SetSymmetricDifferenceTests, TestSetSymmetricDifferenceSimple) using Vector = typename TestFixture::input_type; using Iterator = typename Vector::iterator; - Vector a(4), b(5); + Vector a(4), b(5); - a[0] = 0; a[1] = 2; a[2] = 4; a[3] = 6; - b[0] = 0; b[1] = 3; b[2] = 3; b[3] = 4; b[4] = 7; + a[0] = 0; + a[1] = 2; + a[2] = 4; + a[3] = 6; + b[0] = 0; + b[1] = 3; + b[2] = 3; + b[3] = 4; + b[4] = 7; - Vector ref(5); - ref[0] = 2; ref[1] = 3; ref[2] = 3; ref[3] = 6; ref[4] = 7; + Vector ref(5); + ref[0] = 2; + ref[1] = 3; + ref[2] = 3; + ref[3] = 6; + ref[4] = 7; - Vector result(5); + Vector result(5); - Iterator end = thrust::set_symmetric_difference(a.begin(), a.end(), - b.begin(), b.end(), - result.begin()); + Iterator end + = thrust::set_symmetric_difference(a.begin(), a.end(), b.begin(), b.end(), result.begin()); - EXPECT_EQ(result.end(), end); - ASSERT_EQ(ref, result); + EXPECT_EQ(result.end(), end); + ASSERT_EQ(ref, result); } TYPED_TEST(SetSymmetricDifferencePrimitiveTests, TestSetSymmetricDifference) @@ -117,42 +114,58 @@ TYPED_TEST(SetSymmetricDifferencePrimitiveTests, TestSetSymmetricDifference) for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); size_t expanded_sizes[] = {0, 1, size / 2, size, size + 1, 2 * size}; size_t num_expanded_sizes = sizeof(expanded_sizes) / sizeof(size_t); - thrust::host_vector random = get_random_data( - size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), 0, 255); - - thrust::host_vector h_a(random.begin(), random.begin() + size); - thrust::host_vector h_b(random.begin() + size, random.end()); - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - for (size_t i = 0; i < num_expanded_sizes; i++) + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t expanded_size = expanded_sizes[i]; - - thrust::host_vector h_result(size + expanded_size); - thrust::device_vector d_result(size + expanded_size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_symmetric_difference(h_a.begin(), h_a.end(), - h_b.begin(), h_b.begin() + expanded_size, - h_result.begin()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_symmetric_difference(d_a.begin(), d_a.end(), - d_b.begin(), d_b.begin() + expanded_size, - d_result.begin()); - d_result.resize(d_end - d_result.begin()); - - ASSERT_EQ(h_result, d_result); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random = get_random_data( + size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), + 0, + 255, + seed_value + ); + + thrust::host_vector h_a(random.begin(), random.begin() + size); + thrust::host_vector h_b(random.begin() + size, random.end()); + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + for(size_t i = 0; i < num_expanded_sizes; i++) + { + size_t expanded_size = expanded_sizes[i]; + + thrust::host_vector h_result(size + expanded_size); + thrust::device_vector d_result(size + expanded_size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_symmetric_difference(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.begin() + expanded_size, + h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_symmetric_difference(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.begin() + expanded_size, + d_result.begin()); + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } } @@ -165,32 +178,39 @@ TYPED_TEST(SetSymmetricDifferencePrimitiveTests, TestSetSymmetricDifferenceEquiv for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a = temp; thrust::sort(h_a.begin(), h_a.end()); - thrust::host_vector h_b = h_a; + thrust::host_vector temp = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector h_a = temp; + thrust::sort(h_a.begin(), h_a.end()); + thrust::host_vector h_b = h_a; - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(h_result.size()); + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(h_result.size()); - h_end = thrust::set_symmetric_difference(h_a.begin(), h_a.end(), - h_b.begin(), h_b.end(), - h_result.begin()); - h_result.erase(h_end, h_result.end()); + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - d_end = thrust::set_symmetric_difference(d_a.begin(), d_a.end(), - d_b.begin(), d_b.end(), - d_result.begin()); - d_result.erase(d_end, d_result.end()); + h_end = thrust::set_symmetric_difference( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.erase(h_end, h_result.end()); - ASSERT_EQ(h_result, d_result); + d_end = thrust::set_symmetric_difference( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + d_result.erase(d_end, d_result.end()); + + ASSERT_EQ(h_result, d_result); + } } } @@ -202,45 +222,49 @@ TYPED_TEST(SetSymmetricDifferencePrimitiveTests, TestSetSymmetricDifferenceMulti for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - // restrict elements to [min,13) - for(typename thrust::host_vector::iterator i = temp.begin(); - i != temp.end(); - ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - int temp = static_cast(*i); - temp %= 13; - *i = temp; - } + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::sort(h_a.begin(), h_a.end()); - thrust::sort(h_b.begin(), h_b.end()); + // restrict elements to [min,13) + for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + { + int temp = static_cast(*i); + temp %= 13; + *i = temp; + } - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(h_result.size()); + thrust::sort(h_a.begin(), h_a.end()); + thrust::sort(h_b.begin(), h_b.end()); - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - h_end = thrust::set_difference(h_a.begin(), h_a.end(), - h_b.begin(), h_b.end(), - h_result.begin()); - h_result.erase(h_end, h_result.end()); + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(h_result.size()); - d_end = thrust::set_difference(d_a.begin(), d_a.end(), - d_b.begin(), d_b.end(), - d_result.begin()); - d_result.erase(d_end, d_result.end()); + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_difference( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.erase(h_end, h_result.end()); - ASSERT_EQ_QUIET(h_result, d_result); + d_end = thrust::set_difference( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + d_result.erase(d_end, d_result.end()); + + ASSERT_EQ_QUIET(h_result, d_result); + } } } @@ -254,50 +278,67 @@ TYPED_TEST(SetSymmetricDifferenceIntegerTests, TestSetSymmetricDifferenceKeyValu { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_keys_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_keys_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(size), h_b(size); - for(size_t i = 0; i < size; ++i) + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - h_a[i] = T(h_keys_a[i], h_values_a[i]); - - if( i % 2 == 1 ) - h_b[i] = T(h_keys_b[i], h_values_b[i]); - else - h_b[i] = T(h_keys_a[i], h_values_a[i]); - } - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys_a = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_values_a = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_keys_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + thrust::host_vector h_values_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 3 * seed_value_addition + ); + + thrust::host_vector h_a(size), h_b(size); + for(size_t i = 0; i < size; ++i) + { + h_a[i] = T(h_keys_a[i], h_values_a[i]); + + if(i % 2 == 1) + h_b[i] = T(h_keys_b[i], h_values_b[i]); + else + h_b[i] = T(h_keys_a[i], h_values_a[i]); + } + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(h_result.size()); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(h_result.size()); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - h_end = thrust::set_symmetric_difference(h_a.begin(), h_a.end(), - h_b.begin(), h_b.end(), - h_result.begin()); - h_result.erase(h_end, h_result.end()); + h_end = thrust::set_symmetric_difference( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.erase(h_end, h_result.end()); - d_end = thrust::set_symmetric_difference(d_a.begin(), d_a.end(), - d_b.begin(), d_b.end(), - d_result.begin()); + d_end = thrust::set_symmetric_difference( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); - d_result.erase(d_end, d_result.end()); + d_result.erase(d_end, d_result.end()); - ASSERT_EQ_QUIET(h_result, d_result); + ASSERT_EQ_QUIET(h_result, d_result); + } } } diff --git a/test/test_set_symmetric_difference_by_key.cpp b/test/test_set_symmetric_difference_by_key.cpp index c9a68aff2..af9915a1e 100644 --- a/test/test_set_symmetric_difference_by_key.cpp +++ b/test/test_set_symmetric_difference_by_key.cpp @@ -167,38 +167,139 @@ TYPED_TEST(SetSymmetricDifferenceByKeyPrimitiveTests, TestSetSymmetricDifference for(auto size : sizes) { - thrust::host_vector random_keys = get_random_data(size, 0, 255); - thrust::host_vector random_vals = get_random_data(size, 0, 255); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random_keys = get_random_data( + size, + 0, + 255, + seed_value + ); + thrust::host_vector random_vals = get_random_data( + size, + 0, + 255, + seed_value + seed_value_addition + ); + + size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + size_t num_denominators = sizeof(denominators) / sizeof(size_t); + + for(size_t i = 0; i < num_denominators; ++i) + { + size_t size_a = size / denominators[i]; + + thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); + thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + + thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); + thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + + thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); + thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); + + thrust::device_vector d_a_keys = h_a_keys; + thrust::device_vector d_b_keys = h_b_keys; + + thrust::device_vector d_a_vals = h_a_vals; + thrust::device_vector d_b_vals = h_b_vals; + + size_t max_size = h_a_keys.size() + h_b_keys.size(); + + thrust::host_vector h_result_keys(max_size); + thrust::host_vector h_result_vals(max_size); + + thrust::device_vector d_result_keys(max_size); + thrust::device_vector d_result_vals(max_size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_symmetric_difference_by_key(h_a_keys.begin(), + h_a_keys.end(), + h_b_keys.begin(), + h_b_keys.end(), + h_a_vals.begin(), + h_b_vals.begin(), + h_result_keys.begin(), + h_result_vals.begin()); + h_result_keys.erase(h_end.first, h_result_keys.end()); + h_result_vals.erase(h_end.second, h_result_vals.end()); + + d_end = thrust::set_symmetric_difference_by_key(d_a_keys.begin(), + d_a_keys.end(), + d_b_keys.begin(), + d_b_keys.end(), + d_a_vals.begin(), + d_b_vals.begin(), + d_result_keys.begin(), + d_result_vals.begin()); + d_result_keys.erase(d_end.first, d_result_keys.end()); + d_result_vals.erase(d_end.second, d_result_vals.end()); + + ASSERT_EQ(h_result_keys, d_result_keys); + ASSERT_EQ(h_result_vals, d_result_vals); + } + } + } +} - size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - size_t num_denominators = sizeof(denominators) / sizeof(size_t); +TYPED_TEST(SetSymmetricDifferenceByKeyPrimitiveTests, + TestSetSymmetricDifferenceByKeyEquivalentRanges) +{ + using T = typename TestFixture::input_type; - for(size_t i = 0; i < num_denominators; ++i) - { - size_t size_a = size / denominators[i]; + const std::vector sizes = get_sizes(); - thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); - thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + for(auto size : sizes) + { + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); - thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + thrust::host_vector temp = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); - thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); + thrust::host_vector h_a_key = temp; + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::host_vector h_b_key = h_a_key; - thrust::device_vector d_a_keys = h_a_keys; - thrust::device_vector d_b_keys = h_b_keys; + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); - thrust::device_vector d_a_vals = h_a_vals; - thrust::device_vector d_b_vals = h_b_vals; + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; - size_t max_size = h_a_keys.size() + h_b_keys.size(); + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; - thrust::host_vector h_result_keys(max_size); - thrust::host_vector h_result_vals(max_size); + size_t max_size = h_a_key.size() + h_b_key.size(); - thrust::device_vector d_result_keys(max_size); - thrust::device_vector d_result_vals(max_size); + thrust::host_vector h_result_key(max_size), h_result_val(max_size); + thrust::device_vector d_result_key(max_size), d_result_val(max_size); thrust::pair::iterator, typename thrust::host_vector::iterator> @@ -208,36 +309,35 @@ TYPED_TEST(SetSymmetricDifferenceByKeyPrimitiveTests, TestSetSymmetricDifference typename thrust::device_vector::iterator> d_end; - h_end = thrust::set_symmetric_difference_by_key(h_a_keys.begin(), - h_a_keys.end(), - h_b_keys.begin(), - h_b_keys.end(), - h_a_vals.begin(), - h_b_vals.begin(), - h_result_keys.begin(), - h_result_vals.begin()); - h_result_keys.erase(h_end.first, h_result_keys.end()); - h_result_vals.erase(h_end.second, h_result_vals.end()); - - d_end = thrust::set_symmetric_difference_by_key(d_a_keys.begin(), - d_a_keys.end(), - d_b_keys.begin(), - d_b_keys.end(), - d_a_vals.begin(), - d_b_vals.begin(), - d_result_keys.begin(), - d_result_vals.begin()); - d_result_keys.erase(d_end.first, d_result_keys.end()); - d_result_vals.erase(d_end.second, d_result_vals.end()); - - ASSERT_EQ(h_result_keys, d_result_keys); - ASSERT_EQ(h_result_vals, d_result_vals); + h_end = thrust::set_symmetric_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_symmetric_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } } } -TYPED_TEST(SetSymmetricDifferenceByKeyPrimitiveTests, - TestSetSymmetricDifferenceByKeyEquivalentRanges) +TYPED_TEST(SetSymmetricDifferenceByKeyPrimitiveTests, TestSetSymmetricDifferenceByKeyMultiset) { using T = typename TestFixture::input_type; @@ -245,135 +345,85 @@ TYPED_TEST(SetSymmetricDifferenceByKeyPrimitiveTests, for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key = temp; - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::host_vector h_b_key = h_a_key; - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - size_t max_size = h_a_key.size() + h_b_key.size(); - - thrust::host_vector h_result_key(max_size), h_result_val(max_size); - thrust::device_vector d_result_key(max_size), d_result_val(max_size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_symmetric_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_symmetric_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); - } -} - -TYPED_TEST(SetSymmetricDifferenceByKeyPrimitiveTests, TestSetSymmetricDifferenceByKeyMultiset) -{ - using T = typename TestFixture::input_type; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + // restrict elements to [min,13) + for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + { + int temp = static_cast(*i); + temp %= 13; + *i = temp; + } + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::sort(h_b_key.begin(), h_b_key.end()); + + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + size_t max_size = h_a_key.size() + h_b_key.size(); + thrust::host_vector h_result_key(max_size), h_result_val(max_size); + thrust::device_vector d_result_key(max_size), d_result_val(max_size); - const std::vector sizes = get_sizes(); + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; - for(auto size : sizes) - { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; - // restrict elements to [min,13) - for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) - { - int temp = static_cast(*i); - temp %= 13; - *i = temp; + h_end = thrust::set_symmetric_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_symmetric_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::sort(h_b_key.begin(), h_b_key.end()); - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - size_t max_size = h_a_key.size() + h_b_key.size(); - thrust::host_vector h_result_key(max_size), h_result_val(max_size); - thrust::device_vector d_result_key(max_size), d_result_val(max_size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_symmetric_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_symmetric_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); } } diff --git a/test/test_set_symmetric_difference_by_key_descending.cpp b/test/test_set_symmetric_difference_by_key_descending.cpp index 0f9210a0b..92bee98e3 100644 --- a/test/test_set_symmetric_difference_by_key_descending.cpp +++ b/test/test_set_symmetric_difference_by_key_descending.cpp @@ -94,63 +94,79 @@ TYPED_TEST(SetSymmetricDifferenceByKeyDescendingPrimitiveTests, for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); - thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); - - thrust::host_vector h_a_val = get_random_data( - h_a_key.size(), std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - h_b_key.size(), std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - size_t max_size = h_a_key.size() + h_b_key.size(); - thrust::host_vector h_result_key(max_size), h_result_val(max_size); - thrust::device_vector d_result_key(max_size), d_result_val(max_size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_symmetric_difference_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin(), - thrust::greater()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_symmetric_difference_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin(), - thrust::greater()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); + thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); + + thrust::host_vector h_a_val = get_random_data( + h_a_key.size(), + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + h_b_key.size(), + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + size_t max_size = h_a_key.size() + h_b_key.size(); + thrust::host_vector h_result_key(max_size), h_result_val(max_size); + thrust::device_vector d_result_key(max_size), d_result_val(max_size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_symmetric_difference_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin(), + thrust::greater()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_symmetric_difference_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin(), + thrust::greater()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); + } } } diff --git a/test/test_set_symmetric_difference_descending.cpp b/test/test_set_symmetric_difference_descending.cpp index 96ce05682..c87c2ce54 100644 --- a/test/test_set_symmetric_difference_descending.cpp +++ b/test/test_set_symmetric_difference_descending.cpp @@ -66,33 +66,49 @@ TYPED_TEST(SetSymmetricDifferenceDescendingPrimitiveTests, TestSetSymmetricDiffe for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); - - thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); - thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(h_result.size()); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_symmetric_difference( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin(), thrust::greater()); - h_result.erase(h_end, h_result.end()); - - d_end = thrust::set_symmetric_difference( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin(), thrust::greater()); - - d_result.erase(d_end, d_result.end()); - - ASSERT_EQ(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); + + thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); + thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(h_result.size()); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_symmetric_difference(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.end(), + h_result.begin(), + thrust::greater()); + h_result.erase(h_end, h_result.end()); + + d_end = thrust::set_symmetric_difference(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.end(), + d_result.begin(), + thrust::greater()); + + d_result.erase(d_end, d_result.end()); + + ASSERT_EQ(h_result, d_result); + } } } diff --git a/test/test_set_union.cpp b/test/test_set_union.cpp index c237f0765..7574509d7 100644 --- a/test/test_set_union.cpp +++ b/test/test_set_union.cpp @@ -139,42 +139,57 @@ TYPED_TEST(SetUnionPrimitiveTests, TestSetUnion) for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); size_t expanded_sizes[] = {0, 1, size / 2, size, size + 1, 2 * size}; size_t num_expanded_sizes = sizeof(expanded_sizes) / sizeof(size_t); - thrust::host_vector random = get_random_data( - size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), - 0, - 255); - - thrust::host_vector h_a(random.begin(), random.begin() + size); - thrust::host_vector h_b(random.begin() + size, random.end()); - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - for(size_t i = 0; i < num_expanded_sizes; i++) + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t expanded_size = expanded_sizes[i]; - - thrust::host_vector h_result(size + expanded_size); - thrust::device_vector d_result(size + expanded_size); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_union( - h_a.begin(), h_a.end(), h_b.begin(), h_b.begin() + expanded_size, h_result.begin()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_union( - d_a.begin(), d_a.end(), d_b.begin(), d_b.begin() + expanded_size, d_result.begin()); - d_result.resize(d_end - d_result.begin()); - - ASSERT_EQ(h_result, d_result); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector random = get_random_data( + size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), + 0, + 255, + seed_value); + + thrust::host_vector h_a(random.begin(), random.begin() + size); + thrust::host_vector h_b(random.begin() + size, random.end()); + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + for(size_t i = 0; i < num_expanded_sizes; i++) + { + size_t expanded_size = expanded_sizes[i]; + + thrust::host_vector h_result(size + expanded_size); + thrust::device_vector d_result(size + expanded_size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_union(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.begin() + expanded_size, + h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_union(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.begin() + expanded_size, + d_result.begin()); + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } } @@ -187,35 +202,43 @@ TYPED_TEST(SetUnionPrimitiveTests, TestSetUnionToDiscardIterator) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); - thrust::sort(h_a.begin(), h_a.end()); - thrust::sort(h_b.begin(), h_b.end()); + thrust::sort(h_a.begin(), h_a.end()); + thrust::sort(h_b.begin(), h_b.end()); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - thrust::discard_iterator<> h_result; - thrust::discard_iterator<> d_result; + thrust::discard_iterator<> h_result; + thrust::discard_iterator<> d_result; - thrust::host_vector h_reference(2 * size); - typename thrust::host_vector::iterator h_end = thrust::set_union( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_reference.begin()); - h_reference.erase(h_end, h_reference.end()); + thrust::host_vector h_reference(2 * size); + typename thrust::host_vector::iterator h_end = thrust::set_union( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_reference.begin()); + h_reference.erase(h_end, h_reference.end()); - h_result = thrust::set_union( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), thrust::make_discard_iterator()); + h_result = thrust::set_union( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), thrust::make_discard_iterator()); - d_result = thrust::set_union( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), thrust::make_discard_iterator()); + d_result = thrust::set_union( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), thrust::make_discard_iterator()); - thrust::discard_iterator<> reference(h_reference.size()); + thrust::discard_iterator<> reference(h_reference.size()); - EXPECT_EQ(reference, h_result); - EXPECT_EQ(reference, d_result); + EXPECT_EQ(reference, h_result); + EXPECT_EQ(reference, d_result); + } } } diff --git a/test/test_set_union_by_key.cpp b/test/test_set_union_by_key.cpp index c4610cfc6..4df2b6ddc 100644 --- a/test/test_set_union_by_key.cpp +++ b/test/test_set_union_by_key.cpp @@ -160,40 +160,146 @@ TYPED_TEST(SetUnionByKeyPrimitiveTests, TestSetUnionByKey) for(auto size : sizes) { - thrust::host_vector temp = get_random_data(size, 0, 255); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + size, + 0, + 255, + seed_value + ); + + thrust::host_vector random_keys = get_random_data( + size, + 0, + 255, + seed_value + seed_value_addition + ); + thrust::host_vector random_vals = get_random_data( + size, + 0, + 255, + seed_value + 2 * seed_value_addition + ); + + size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + size_t num_denominators = sizeof(denominators) / sizeof(size_t); + + for(size_t i = 0; i < num_denominators; ++i) + { + size_t size_a = size / denominators[i]; + + thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); + thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + + thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); + thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + + thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); + thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); + + thrust::device_vector d_a_keys = h_a_keys; + thrust::device_vector d_b_keys = h_b_keys; + + thrust::device_vector d_a_vals = h_a_vals; + thrust::device_vector d_b_vals = h_b_vals; + + size_t max_size = h_a_keys.size() + h_b_keys.size(); + + thrust::host_vector h_result_keys(max_size); + thrust::host_vector h_result_vals(max_size); + + thrust::device_vector d_result_keys(max_size); + thrust::device_vector d_result_vals(max_size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_union_by_key(h_a_keys.begin(), + h_a_keys.end(), + h_b_keys.begin(), + h_b_keys.end(), + h_a_vals.begin(), + h_b_vals.begin(), + h_result_keys.begin(), + h_result_vals.begin()); + h_result_keys.erase(h_end.first, h_result_keys.end()); + h_result_vals.erase(h_end.second, h_result_vals.end()); + + d_end = thrust::set_union_by_key(d_a_keys.begin(), + d_a_keys.end(), + d_b_keys.begin(), + d_b_keys.end(), + d_a_vals.begin(), + d_b_vals.begin(), + d_result_keys.begin(), + d_result_vals.begin()); + d_result_keys.erase(d_end.first, d_result_keys.end()); + d_result_vals.erase(d_end.second, d_result_vals.end()); + + ASSERT_EQ(h_result_keys, d_result_keys); + ASSERT_EQ(h_result_vals, d_result_vals); + } + } + } +} - thrust::host_vector random_keys = get_random_data(size, 0, 255); - thrust::host_vector random_vals = get_random_data(size, 0, 255); +TYPED_TEST(SetUnionByKeyPrimitiveTests, + seed_value_addition TestSetUnionByKeyEquivalentRanges) +{ + using T = typename TestFixture::input_type; - size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - size_t num_denominators = sizeof(denominators) / sizeof(size_t); + const std::vector sizes = get_sizes(); - for(size_t i = 0; i < num_denominators; ++i) + for(auto size : sizes) + { + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - size_t size_a = size / denominators[i]; + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a_keys(random_keys.begin(), random_keys.begin() + size_a); - thrust::host_vector h_b_keys(random_keys.begin() + size_a, random_keys.end()); + thrust::host_vector temp = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector h_a_vals(random_vals.begin(), random_vals.begin() + size_a); - thrust::host_vector h_b_vals(random_vals.begin() + size_a, random_vals.end()); + thrust::host_vector h_a_key = temp; + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::host_vector h_b_key = h_a_key; - thrust::stable_sort(h_a_keys.begin(), h_a_keys.end()); - thrust::stable_sort(h_b_keys.begin(), h_b_keys.end()); + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - thrust::device_vector d_a_keys = h_a_keys; - thrust::device_vector d_b_keys = h_b_keys; + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); - thrust::device_vector d_a_vals = h_a_vals; - thrust::device_vector d_b_vals = h_b_vals; + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; - size_t max_size = h_a_keys.size() + h_b_keys.size(); + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; - thrust::host_vector h_result_keys(max_size); - thrust::host_vector h_result_vals(max_size); + size_t max_size = h_a_key.size() + h_b_key.size(); - thrust::device_vector d_result_keys(max_size); - thrust::device_vector d_result_vals(max_size); + thrust::host_vector h_result_key(max_size), h_result_val(max_size); + thrust::device_vector d_result_key(max_size), d_result_val(max_size); thrust::pair::iterator, typename thrust::host_vector::iterator> @@ -203,35 +309,35 @@ TYPED_TEST(SetUnionByKeyPrimitiveTests, TestSetUnionByKey) typename thrust::device_vector::iterator> d_end; - h_end = thrust::set_union_by_key(h_a_keys.begin(), - h_a_keys.end(), - h_b_keys.begin(), - h_b_keys.end(), - h_a_vals.begin(), - h_b_vals.begin(), - h_result_keys.begin(), - h_result_vals.begin()); - h_result_keys.erase(h_end.first, h_result_keys.end()); - h_result_vals.erase(h_end.second, h_result_vals.end()); - - d_end = thrust::set_union_by_key(d_a_keys.begin(), - d_a_keys.end(), - d_b_keys.begin(), - d_b_keys.end(), - d_a_vals.begin(), - d_b_vals.begin(), - d_result_keys.begin(), - d_result_vals.begin()); - d_result_keys.erase(d_end.first, d_result_keys.end()); - d_result_vals.erase(d_end.second, d_result_vals.end()); - - ASSERT_EQ(h_result_keys, d_result_keys); - ASSERT_EQ(h_result_vals, d_result_vals); + h_end = thrust::set_union_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_union_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } } } -TYPED_TEST(SetUnionByKeyPrimitiveTests, TestSetUnionByKeyEquivalentRanges) +TYPED_TEST(SetUnionByKeyPrimitiveTests, TestSetUnionByKeyMultiset) { using T = typename TestFixture::input_type; @@ -239,136 +345,85 @@ TYPED_TEST(SetUnionByKeyPrimitiveTests, TestSetUnionByKeyEquivalentRanges) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key = temp; - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::host_vector h_b_key = h_a_key; - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - size_t max_size = h_a_key.size() + h_b_key.size(); - - thrust::host_vector h_result_key(max_size), h_result_val(max_size); - thrust::device_vector d_result_key(max_size), d_result_val(max_size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_union_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_union_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); - } -} - -TYPED_TEST(SetUnionByKeyPrimitiveTests, TestSetUnionByKeyMultiset) -{ - using T = typename TestFixture::input_type; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + // restrict elements to [min,13) + for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) + { + int temp = static_cast(*i); + temp %= 13; + *i = temp; + } + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end()); + thrust::sort(h_b_key.begin(), h_b_key.end()); + + thrust::host_vector h_a_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + size_t max_size = h_a_key.size() + h_b_key.size(); + thrust::host_vector h_result_key(max_size), h_result_val(max_size); + thrust::device_vector d_result_key(max_size), d_result_val(max_size); - const std::vector sizes = get_sizes(); + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; - for(auto size : sizes) - { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; - // restrict elements to [min,13) - for(typename thrust::host_vector::iterator i = temp.begin(); i != temp.end(); ++i) - { - int temp = static_cast(*i); - temp %= 13; - *i = temp; + h_end = thrust::set_union_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_union_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); } - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end()); - thrust::sort(h_b_key.begin(), h_b_key.end()); - - thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - size_t max_size = h_a_key.size() + h_b_key.size(); - thrust::host_vector h_result_key(max_size), h_result_val(max_size); - thrust::device_vector d_result_key(max_size), d_result_val(max_size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_union_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_union_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); } } diff --git a/test/test_set_union_by_key_descending.cpp b/test/test_set_union_by_key_descending.cpp index c53d57ef9..bb08fa6d5 100644 --- a/test/test_set_union_by_key_descending.cpp +++ b/test/test_set_union_by_key_descending.cpp @@ -88,64 +88,79 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingEqu for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); - thrust::host_vector h_b_key(temp.begin() + size, temp.end()); - - thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); - thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); - - thrust::host_vector h_a_val = get_random_data( - h_a_key.size(), std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_b_val = get_random_data( - h_b_key.size(), std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_a_key = h_a_key; - thrust::device_vector d_b_key = h_b_key; - - thrust::device_vector d_a_val = h_a_val; - thrust::device_vector d_b_val = h_b_val; - - size_t max_size = h_a_key.size() + h_b_key.size(); - thrust::host_vector h_result_key(max_size), h_result_val(max_size); - thrust::device_vector d_result_key(max_size), d_result_val(max_size); - - thrust::pair::iterator, - typename thrust::host_vector::iterator> - h_end; - - thrust::pair::iterator, - typename thrust::device_vector::iterator> - d_end; - - h_end = thrust::set_union_by_key(h_a_key.begin(), - h_a_key.end(), - h_b_key.begin(), - h_b_key.end(), - h_a_val.begin(), - h_b_val.begin(), - h_result_key.begin(), - h_result_val.begin(), - thrust::greater()); - h_result_key.erase(h_end.first, h_result_key.end()); - h_result_val.erase(h_end.second, h_result_val.end()); - - d_end = thrust::set_union_by_key(d_a_key.begin(), - d_a_key.end(), - d_b_key.begin(), - d_b_key.end(), - d_a_val.begin(), - d_b_val.begin(), - d_result_key.begin(), - d_result_val.begin(), - thrust::greater()); - d_result_key.erase(d_end.first, d_result_key.end()); - d_result_val.erase(d_end.second, d_result_val.end()); - - ASSERT_EQ(h_result_key, d_result_key); - ASSERT_EQ(h_result_val, d_result_val); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a_key(temp.begin(), temp.begin() + size); + thrust::host_vector h_b_key(temp.begin() + size, temp.end()); + + thrust::sort(h_a_key.begin(), h_a_key.end(), thrust::greater()); + thrust::sort(h_b_key.begin(), h_b_key.end(), thrust::greater()); + + thrust::host_vector h_a_val = get_random_data( + h_a_key.size(), + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_b_val = get_random_data( + h_b_key.size(), + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_a_key = h_a_key; + thrust::device_vector d_b_key = h_b_key; + + thrust::device_vector d_a_val = h_a_val; + thrust::device_vector d_b_val = h_b_val; + + size_t max_size = h_a_key.size() + h_b_key.size(); + thrust::host_vector h_result_key(max_size), h_result_val(max_size); + thrust::device_vector d_result_key(max_size), d_result_val(max_size); + + thrust::pair::iterator, + typename thrust::host_vector::iterator> + h_end; + + thrust::pair::iterator, + typename thrust::device_vector::iterator> + d_end; + + h_end = thrust::set_union_by_key(h_a_key.begin(), + h_a_key.end(), + h_b_key.begin(), + h_b_key.end(), + h_a_val.begin(), + h_b_val.begin(), + h_result_key.begin(), + h_result_val.begin(), + thrust::greater()); + h_result_key.erase(h_end.first, h_result_key.end()); + h_result_val.erase(h_end.second, h_result_val.end()); + + d_end = thrust::set_union_by_key(d_a_key.begin(), + d_a_key.end(), + d_b_key.begin(), + d_b_key.end(), + d_a_val.begin(), + d_b_val.begin(), + d_result_key.begin(), + d_result_val.begin(), + thrust::greater()); + d_result_key.erase(d_end.first, d_result_key.end()); + d_result_val.erase(d_end.second, d_result_val.end()); + + ASSERT_EQ(h_result_key, d_result_key); + ASSERT_EQ(h_result_val, d_result_val); + } } } @@ -192,19 +207,24 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescending) for(auto size : sizes) { +for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) +{ +unsigned int seed_value = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; +SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + thrust::host_vector temp = get_random_data( - size, - 0, - 255); + size, + 0, + 255, seed_value); thrust::host_vector random_keys = get_random_data( - size, - 0, - 255); + size, + 0, + 255, seed_value); thrust::host_vector random_vals = get_random_data( - size, - 0, - 255); + size, + 0, + 255, seed_value); size_t denominators[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; size_t num_denominators = sizeof(denominators) / sizeof(size_t); @@ -271,6 +291,7 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescending) } } } +} TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingEquivalentRanges) @@ -281,8 +302,13 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingEqu for(auto size : sizes) { +for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) +{ +unsigned int seed_value = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; +SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + thrust::host_vector temp = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); thrust::host_vector h_a_key = temp; @@ -290,10 +316,10 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingEqu thrust::host_vector h_b_key = h_a_key; thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); thrust::device_vector d_a_key = h_a_key; thrust::device_vector d_b_key = h_b_key; @@ -310,12 +336,12 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingEqu typename thrust::host_vector::iterator, typename thrust::host_vector::iterator > h_end; - + thrust::pair< typename thrust::device_vector::iterator, typename thrust::device_vector::iterator > d_end; - + h_end = thrust::set_union_by_key(h_a_key.begin(), h_a_key.end(), h_b_key.begin(), h_b_key.end(), h_a_val.begin(), @@ -338,6 +364,7 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingEqu ASSERT_EQ(h_result_val, d_result_val); } } +} TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingMultiset) { @@ -347,8 +374,13 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingMul for(auto size : sizes) { +for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) +{ +unsigned int seed_value = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; +SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); // restrict elements to [min,13) for(typename thrust::host_vector::iterator i = temp.begin(); @@ -367,9 +399,9 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingMul thrust::sort(h_b_key.begin(), h_b_key.end()); thrust::host_vector h_a_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); thrust::host_vector h_b_val = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); thrust::device_vector d_a_key = h_a_key; thrust::device_vector d_b_key = h_b_key; @@ -390,7 +422,7 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingMul typename thrust::device_vector::iterator, typename thrust::device_vector::iterator > d_end; - + h_end = thrust::set_union_by_key(h_a_key.begin(), h_a_key.end(), h_b_key.begin(), h_b_key.end(), h_a_val.begin(), @@ -412,4 +444,5 @@ TYPED_TEST(SetUnionByKeyDescendingPrimitiveTests, TestSetUnionByKeyDescendingMul ASSERT_EQ(h_result_key, d_result_key); ASSERT_EQ(h_result_val, d_result_val); } +} }*/ diff --git a/test/test_set_union_descending.cpp b/test/test_set_union_descending.cpp index 5055cd252..259ea30ea 100644 --- a/test/test_set_union_descending.cpp +++ b/test/test_set_union_descending.cpp @@ -67,33 +67,49 @@ TYPED_TEST(SetUnionDescendingPrimitiveTests, TestSetUnionDescending) for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); - - thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); - thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(h_result.size()); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_union( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin(), thrust::greater()); - h_result.erase(h_end, h_result.end()); - - d_end = thrust::set_union( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin(), thrust::greater()); - - d_result.erase(d_end, d_result.end()); - - ASSERT_EQ(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); + + thrust::sort(h_a.begin(), h_a.end(), thrust::greater()); + thrust::sort(h_b.begin(), h_b.end(), thrust::greater()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(h_result.size()); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_union(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.end(), + h_result.begin(), + thrust::greater()); + h_result.erase(h_end, h_result.end()); + + d_end = thrust::set_union(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.end(), + d_result.begin(), + thrust::greater()); + + d_result.erase(d_end, d_result.end()); + + ASSERT_EQ(h_result, d_result); + } } } diff --git a/test/test_set_union_key_value.cpp b/test/test_set_union_key_value.cpp index c870ec1d9..629cadd8d 100644 --- a/test/test_set_union_key_value.cpp +++ b/test/test_set_union_key_value.cpp @@ -33,43 +33,65 @@ TYPED_TEST(SetUnionKeyValuePrimitiveTests, TestSetUnionKeyValue) for(auto size : sizes) { - thrust::host_vector h_keys_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_keys_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(size), h_b(size); - for(size_t i = 0; i < size; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - h_a[i] = T(h_keys_a[i], h_values_a[i]); - h_b[i] = T(h_keys_b[i], h_values_b[i]); - } - - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys_a = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_values_a = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_keys_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + thrust::host_vector h_values_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 3 * seed_value_addition + ); + + thrust::host_vector h_a(size), h_b(size); + for(size_t i = 0; i < size; ++i) + { + h_a[i] = T(h_keys_a[i], h_values_a[i]); + h_b[i] = T(h_keys_b[i], h_values_b[i]); + } + + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(d_a.size() + d_b.size()); - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(d_a.size() + d_b.size()); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - h_end = thrust::set_union(h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); - h_result.erase(h_end, h_result.end()); + h_end = thrust::set_union( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin()); + h_result.erase(h_end, h_result.end()); - d_end = thrust::set_union(d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); - d_result.erase(d_end, d_result.end()); + d_end = thrust::set_union( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin()); + d_result.erase(d_end, d_result.end()); - thrust::host_vector d_result_h(d_result); - EXPECT_EQ(h_result, d_result_h); + thrust::host_vector d_result_h(d_result); + EXPECT_EQ(h_result, d_result_h); + } } } @@ -82,45 +104,73 @@ TYPED_TEST(SetUnionKeyValuePrimitiveTests, TestSetUnionKeyValueDescending) for(auto size : sizes) { - thrust::host_vector h_keys_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_a = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_keys_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_values_b = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_a(size), h_b(size); - for(size_t i = 0; i < size; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - h_a[i] = T(h_keys_a[i], h_values_a[i]); - h_b[i] = T(h_keys_b[i], h_values_b[i]); - } - - thrust::stable_sort(h_a.begin(), h_a.end(), thrust::greater()); - thrust::stable_sort(h_b.begin(), h_b.end(), thrust::greater()); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys_a = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_values_a = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_keys_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + thrust::host_vector h_values_b = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 3 * seed_value_addition + ); + + thrust::host_vector h_a(size), h_b(size); + for(size_t i = 0; i < size; ++i) + { + h_a[i] = T(h_keys_a[i], h_values_a[i]); + h_b[i] = T(h_keys_b[i], h_values_b[i]); + } + + thrust::stable_sort(h_a.begin(), h_a.end(), thrust::greater()); + thrust::stable_sort(h_b.begin(), h_b.end(), thrust::greater()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + thrust::host_vector h_result(h_a.size() + h_b.size()); + thrust::device_vector d_result(d_a.size() + d_b.size()); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; - - thrust::host_vector h_result(h_a.size() + h_b.size()); - thrust::device_vector d_result(d_a.size() + d_b.size()); - - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_union( - h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_result.begin(), thrust::greater()); - h_result.erase(h_end, h_result.end()); - - d_end = thrust::set_union( - d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), d_result.begin(), thrust::greater()); - d_result.erase(d_end, d_result.end()); + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; - thrust::host_vector d_result_h(d_result); - EXPECT_EQ(h_result, d_result_h); + h_end = thrust::set_union(h_a.begin(),seed_value + h_a.end(), + h_b.begin(), + h_b.end(), + h_result.begin(), + thrust::greater()); + h_result.erase(h_end, h_result.end()); + + d_end = thrust::set_union(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.end(), + d_result.begin(), + thrust::greater()); + d_result.erase(d_end, d_result.end()); + + thrust::host_vector d_result_h(d_result); + EXPECT_EQ(h_result, d_result_h); + } } } @@ -129,46 +179,60 @@ TYPED_TEST(SetUnionKeyValueTests, TestSetUnionKeyValueSimple) using Vector = typename TestFixture::input_type; using Iterator = typename Vector::iterator; - Vector a(3), b(4); + Vector a(3), b(4); - a[0] = 0; a[1] = 2; a[2] = 4; - b[0] = 0; b[1] = 3; b[2] = 3; b[3] = 4; + a[0] = 0; + a[1] = 2; + a[2] = 4; + b[0] = 0; + b[1] = 3; + b[2] = 3; + b[3] = 4; - Vector ref(5); - ref[0] = 0; ref[1] = 2; ref[2] = 3; ref[3] = 3; ref[4] = 4; + Vector ref(5); + ref[0] = 0; + ref[1] = 2; + ref[2] = 3; + ref[3] = 3; + ref[4] = 4; - Vector result(5); + Vector result(5); - Iterator end = thrust::set_union(a.begin(), a.end(), - b.begin(), b.end(), - result.begin()); + Iterator end = thrust::set_union(a.begin(), a.end(), b.begin(), b.end(), result.begin()); - EXPECT_EQ(result.end(), end); - ASSERT_EQ(ref, result); + EXPECT_EQ(result.end(), end); + ASSERT_EQ(ref, result); } - TYPED_TEST(SetUnionKeyValueTests, TestSetUnionKeyValueWithEquivalentElementsSimple) { using Vector = typename TestFixture::input_type; using Iterator = typename Vector::iterator; - Vector a(3), b(5); + Vector a(3), b(5); - a[0] = 0; a[1] = 2; a[2] = 2; - b[0] = 0; b[1] = 2; b[2] = 2; b[3] = 2; b[4] = 3; + a[0] = 0; + a[1] = 2; + a[2] = 2; + b[0] = 0; + b[1] = 2; + b[2] = 2; + b[3] = 2; + b[4] = 3; - Vector ref(5); - ref[0] = 0; ref[1] = 2; ref[2] = 2; ref[3] = 2; ref[4] = 3; + Vector ref(5); + ref[0] = 0; + ref[1] = 2; + ref[2] = 2; + ref[3] = 2; + ref[4] = 3; - Vector result(5); + Vector result(5); - Iterator end = thrust::set_union(a.begin(), a.end(), - b.begin(), b.end(), - result.begin()); + Iterator end = thrust::set_union(a.begin(), a.end(), b.begin(), b.end(), result.begin()); - EXPECT_EQ(result.end(), end); - ASSERT_EQ(ref, result); + EXPECT_EQ(result.end(), end); + ASSERT_EQ(ref, result); } TYPED_TEST(SetUnionKeyValuePrimitiveTests, TestSetUnionKeyValue) @@ -179,49 +243,61 @@ TYPED_TEST(SetUnionKeyValuePrimitiveTests, TestSetUnionKeyValue) for(auto size : sizes) { + SCOPED_TRACE(testing::Message() << "with size= " << size); size_t expanded_sizes[] = {0, 1, size / 2, size, size + 1, 2 * size}; size_t num_expanded_sizes = sizeof(expanded_sizes) / sizeof(size_t); - thrust::host_vector random = get_random_data( - size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), - 0, - 255); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; - thrust::host_vector h_a(random.begin(), random.begin() + size); - thrust::host_vector h_b(random.begin() + size, random.end()); - thrust::stable_sort(h_a.begin(), h_a.end()); - thrust::stable_sort(h_b.begin(), h_b.end()); - - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::host_vector random = get_random_data( + size + *thrust::max_element(expanded_sizes, expanded_sizes + num_expanded_sizes), + 0, + 255, + seed_value); - for (size_t i = 0; i < num_expanded_sizes; i++) - { - size_t expanded_size = expanded_sizes[i]; - - thrust::host_vector h_result(size + expanded_size); - thrust::device_vector d_result(size + expanded_size); + thrust::host_vector h_a(random.begin(), random.begin() + size); + thrust::host_vector h_b(random.begin() + size, random.end()); - typename thrust::host_vector::iterator h_end; - typename thrust::device_vector::iterator d_end; - - h_end = thrust::set_union(h_a.begin(), h_a.end(), - h_b.begin(), h_b.begin() + expanded_size, - h_result.begin()); - h_result.resize(h_end - h_result.begin()); - - d_end = thrust::set_union(d_a.begin(), d_a.end(), - d_b.begin(), d_b.begin() + expanded_size, - d_result.begin()); - d_result.resize(d_end - d_result.begin()); - - ASSERT_EQ(h_result, d_result); + thrust::stable_sort(h_a.begin(), h_a.end()); + thrust::stable_sort(h_b.begin(), h_b.end()); + + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; + + for(size_t i = 0; i < num_expanded_sizes; i++) + { + size_t expanded_size = expanded_sizes[i]; + + thrust::host_vector h_result(size + expanded_size); + thrust::device_vector d_result(size + expanded_size); + + typename thrust::host_vector::iterator h_end; + typename thrust::device_vector::iterator d_end; + + h_end = thrust::set_union(h_a.begin(), + h_a.end(), + h_b.begin(), + h_b.begin() + expanded_size, + h_result.begin()); + h_result.resize(h_end - h_result.begin()); + + d_end = thrust::set_union(d_a.begin(), + d_a.end(), + d_b.begin(), + d_b.begin() + expanded_size, + d_result.begin()); + d_result.resize(d_end - d_result.begin()); + + ASSERT_EQ(h_result, d_result); + } } } } - TYPED_TEST(SetUnionKeyValuePrimitiveTests, TestSetUnionKeyValueToDiscardIterator) { using T = typename TestFixture::input_type; @@ -230,40 +306,43 @@ TYPED_TEST(SetUnionKeyValuePrimitiveTests, TestSetUnionKeyValueToDiscardIterator for(auto size : sizes) { - thrust::host_vector temp = get_random_data( - 2 * size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_a(temp.begin(), temp.begin() + size); - thrust::host_vector h_b(temp.begin() + size, temp.end()); + thrust::host_vector temp = get_random_data( + 2 * size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::sort(h_a.begin(), h_a.end()); - thrust::sort(h_b.begin(), h_b.end()); + thrust::host_vector h_a(temp.begin(), temp.begin() + size); + thrust::host_vector h_b(temp.begin() + size, temp.end()); - thrust::device_vector d_a = h_a; - thrust::device_vector d_b = h_b; + thrust::sort(h_a.begin(), h_a.end()); + thrust::sort(h_b.begin(), h_b.end()); - thrust::discard_iterator<> h_result; - thrust::discard_iterator<> d_result; + thrust::device_vector d_a = h_a; + thrust::device_vector d_b = h_b; - thrust::host_vector h_reference(2 * size); - typename thrust::host_vector::iterator h_end = - thrust::set_union(h_a.begin(), h_a.end(), - h_b.begin(), h_b.end(), - h_reference.begin()); - h_reference.erase(h_end, h_reference.end()); - - h_result = thrust::set_union(h_a.begin(), h_a.end(), - h_b.begin(), h_b.end(), - thrust::make_discard_iterator()); + thrust::discard_iterator<> h_result; + thrust::discard_iterator<> d_result; - d_result = thrust::set_union(d_a.begin(), d_a.end(), - d_b.begin(), d_b.end(), - thrust::make_discard_iterator()); + thrust::host_vector h_reference(2 * size); + typename thrust::host_vector::iterator h_end = thrust::set_union( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), h_reference.begin()); + h_reference.erase(h_end, h_reference.end()); - thrust::discard_iterator<> reference(h_reference.size()); + h_result = thrust::set_union( + h_a.begin(), h_a.end(), h_b.begin(), h_b.end(), thrust::make_discard_iterator()); - EXPECT_EQ(reference, h_result); - EXPECT_EQ(reference, d_result); + d_result = thrust::set_union( + d_a.begin(), d_a.end(), d_b.begin(), d_b.end(), thrust::make_discard_iterator()); + + thrust::discard_iterator<> reference(h_reference.size()); + + EXPECT_EQ(reference, h_result); + EXPECT_EQ(reference, d_result); + } } } - diff --git a/test/test_sort.cpp b/test/test_sort.cpp index 7f3041899..f66ef0e42 100644 --- a/test/test_sort.cpp +++ b/test/test_sort.cpp @@ -65,12 +65,31 @@ TYPED_TEST(SortTests, Sort) thrust::host_vector h_keys; if(std::is_floating_point::value) { - h_keys = get_random_data(size, (key_type)-1000, (key_type) + 1000); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + h_keys = get_random_data( + size, (key_type)-1000, (key_type) + 1000, seed_value); + } } else { - h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + h_keys = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + } } // Calculate expected results on host @@ -105,7 +124,7 @@ TYPED_TEST(SortTests, SortByKey) thrust::host_vector h_keys(size); std::iota(h_keys.begin(), h_keys.end(), 0); std::shuffle( - h_keys.begin(), h_keys.end(), std::default_random_engine(std::random_device {}())); + h_keys.begin(), h_keys.end(), std::default_random_engine(std::random_device{}())); thrust::host_vector h_values(size); std::iota(h_values.begin(), h_values.end(), 0); @@ -144,12 +163,31 @@ TYPED_TEST(SortTests, StableSort) thrust::host_vector h_keys; if(std::is_floating_point::value) { - h_keys = get_random_data(size, (key_type)-1000, (key_type) + 1000); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + h_keys = get_random_data( + size, (key_type)-1000, (key_type) + 1000, seed_value); + } } else { - h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + h_keys = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + } } // Calculate expected results on host @@ -180,12 +218,31 @@ TYPED_TEST(SortTests, StableSortByKey) thrust::host_vector h_keys; if(std::is_floating_point::value) { - h_keys = get_random_data(size, (key_type)-1000, (key_type) + 1000); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + h_keys = get_random_data( + size, (key_type)-1000, (key_type) + 1000, seed_value); + } } else { - h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + h_keys = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + } } thrust::host_vector h_values(size); @@ -289,14 +346,22 @@ TYPED_TEST(SortVectorPrimitives, TestSortAscendingKey) for(auto size : get_sizes()) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::sort(h_data.begin(), h_data.end(), thrust::less()); - thrust::sort(d_data.begin(), d_data.end(), thrust::less()); + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - ASSERT_EQ(h_data, d_data); + thrust::sort(h_data.begin(), h_data.end(), thrust::less()); + thrust::sort(d_data.begin(), d_data.end(), thrust::less()); + + ASSERT_EQ(h_data, d_data); + } } } @@ -304,50 +369,71 @@ TEST(SortTests, TestSortDescendingKey) { const size_t size = 10027; - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::sort(h_data.begin(), h_data.end(), thrust::greater()); - thrust::sort(d_data.begin(), d_data.end(), thrust::greater()); + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - ASSERT_EQ(h_data, d_data); + thrust::sort(h_data.begin(), h_data.end(), thrust::greater()); + thrust::sort(d_data.begin(), d_data.end(), thrust::greater()); + + ASSERT_EQ(h_data, d_data); + } } TEST(SortTests, TestSortBool) { const size_t size = 10027; - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_data = h_data; + thrust::device_vector d_data = h_data; - thrust::sort(h_data.begin(), h_data.end()); - thrust::sort(d_data.begin(), d_data.end()); + thrust::sort(h_data.begin(), h_data.end()); + thrust::sort(d_data.begin(), d_data.end()); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); + } } TEST(SortTests, TestSortBoolDescending) { const size_t size = 10027; - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_data = h_data; + thrust::device_vector d_data = h_data; - thrust::sort(h_data.begin(), h_data.end(), thrust::greater()); - thrust::sort(d_data.begin(), d_data.end(), thrust::greater()); + thrust::sort(h_data.begin(), h_data.end(), thrust::greater()); + thrust::sort(d_data.begin(), d_data.end(), thrust::greater()); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); + } } //TODO: refactor this test into a different set of tests -__global__ void SortKernel(int const N, int * array) +__global__ void SortKernel(int const N, int* array) { - if (threadIdx.x == 0) + if(threadIdx.x == 0) { thrust::device_ptr begin(array); thrust::device_ptr end(array + N); @@ -357,24 +443,31 @@ __global__ void SortKernel(int const N, int * array) TEST(SortTests, TestSortDevice) { - std::vector sizes = { - 0, 1, 2, 4, 6, 12, 16, 24, 32, - 64, 84, 128, 160, 256 - }; + std::vector sizes = {0, 1, 2, 4, 6, 12, 16, 24, 32, 64, 84, 128, 160, 256}; for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, 0, size); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data(size, 0, size, seed_value); - thrust::sort(h_data.begin(), h_data.end()); - hipLaunchKernelGGL( - SortKernel, dim3(1, 1, 1), dim3(128, 1, 1), - 0, 0, size, thrust::raw_pointer_cast(&d_data[0]) - ); + thrust::device_vector d_data = h_data; - ASSERT_EQ(h_data, d_data); + thrust::sort(h_data.begin(), h_data.end()); + hipLaunchKernelGGL(SortKernel, + dim3(1, 1, 1), + dim3(128, 1, 1), + 0, + 0, + size, + thrust::raw_pointer_cast(&d_data[0])); + + ASSERT_EQ(h_data, d_data); + } } } diff --git a/test/test_sort_by_key.cpp b/test/test_sort_by_key.cpp index f6bcc93b2..dfdfd07bd 100644 --- a/test/test_sort_by_key.cpp +++ b/test/test_sort_by_key.cpp @@ -128,20 +128,26 @@ TYPED_TEST(SortByKeyPrimitiveTests, TestSortAscendingKeyValue) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_keys = h_keys; + thrust::device_vector d_keys = h_keys; - thrust::host_vector h_values = h_keys; - thrust::device_vector d_values = d_keys; + thrust::host_vector h_values = h_keys; + thrust::device_vector d_values = d_keys; - thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin(), thrust::less()); - thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin(), thrust::less()); + thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin(), thrust::less()); + thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin(), thrust::less()); - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_values, d_values); + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_values, d_values); + } } } @@ -150,20 +156,28 @@ TEST(SortByKeyTests, TestSortDescendingKeyValue) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_keys = h_keys; + thrust::device_vector d_keys = h_keys; - thrust::host_vector h_values = h_keys; - thrust::device_vector d_values = d_keys; + thrust::host_vector h_values = h_keys; + thrust::device_vector d_values = d_keys; - thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin(), thrust::greater()); - thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin(), thrust::greater()); + thrust::sort_by_key( + h_keys.begin(), h_keys.end(), h_values.begin(), thrust::greater()); + thrust::sort_by_key( + d_keys.begin(), d_keys.end(), d_values.begin(), thrust::greater()); - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_values, d_values); + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_values, d_values); + } } } @@ -171,49 +185,69 @@ TEST(SortByKeyTests, TestSortByKeyBool) { const size_t size = 10027; - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_values = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_values = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_values = h_values; + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_values = h_values; - thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); - thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin()); + thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); + thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin()); - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_values, d_values); + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_values, d_values); + } } TEST(SortByKeyTests, TestSortByKeyBoolDescending) { const size_t size = 10027; - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_values = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_values = h_values; + thrust::host_vector h_values = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin(), thrust::greater()); - thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin(), thrust::greater()); + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_values = h_values; - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_values, d_values); + thrust::sort_by_key( + h_keys.begin(), h_keys.end(), h_values.begin(), thrust::greater()); + thrust::sort_by_key( + d_keys.begin(), d_keys.end(), d_values.begin(), thrust::greater()); + + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_values, d_values); + } } //TODO: refactor this test into a different set of tests -__global__ void SortByKeyKernel(int const N, int * keys, short * values) +__global__ void SortByKeyKernel(int const N, int* keys, short* values) { - if (threadIdx.x == 0) + if(threadIdx.x == 0) { - thrust::device_ptr keys_begin(keys); - thrust::device_ptr keys_end(keys + N); + thrust::device_ptr keys_begin(keys); + thrust::device_ptr keys_end(keys + N); thrust::device_ptr val(values); thrust::sort_by_key(thrust::hip::par, keys_begin, keys_end, val); } @@ -221,31 +255,41 @@ __global__ void SortByKeyKernel(int const N, int * keys, short * values) TEST(SortByKeyTests, TestSortByKeyDevice) { - std::vector sizes = { - 0, 1, 2, 4, 6, 12, 16, 24, 32, - 64, 84, 128, 160, 256 - }; + std::vector sizes = {0, 1, 2, 4, 6, 12, 16, 24, 32, 64, 84, 128, 160, 256}; for(auto size : sizes) { - thrust::host_vector h_keys = get_random_data( - size, 0, size); - - thrust::host_vector h_values = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_values = h_values; - - thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); - hipLaunchKernelGGL( - SortByKeyKernel, dim3(1, 1, 1), dim3(128, 1, 1), - 0, 0, size, thrust::raw_pointer_cast(&d_keys[0]), - thrust::raw_pointer_cast(&d_values[0]) - ); - - ASSERT_EQ(h_keys, d_keys); - // Only keys are compared here, the sequential stable_merge_sort that's used in - // CUDA and HIP don't generate the correct value sorting + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data(size, 0, size, seed_value); + + thrust::host_vector h_values + = get_random_data(size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value); + + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_values = h_values; + + thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); + hipLaunchKernelGGL(SortByKeyKernel, + dim3(1, 1, 1), + dim3(128, 1, 1), + 0, + 0, + size, + thrust::raw_pointer_cast(&d_keys[0]), + thrust::raw_pointer_cast(&d_values[0])); + + ASSERT_EQ(h_keys, d_keys); + // Only keys are compared here, the sequential stable_merge_sort that's used in + // CUDA and HIP don't generate the correct value sorting + } } } diff --git a/test/test_sort_by_key_variable_bits.cpp b/test/test_sort_by_key_variable_bits.cpp index 41aaaf2c0..ac931b80a 100644 --- a/test/test_sort_by_key_variable_bits.cpp +++ b/test/test_sort_by_key_variable_bits.cpp @@ -27,33 +27,42 @@ TYPED_TEST(SortByKeyVariableTests, TestSortVariableBits) for(auto size : get_sizes()) { + SCOPED_TRACE(testing::Message() << "with size= " << size); for(size_t num_bits = 0; num_bits < 8 * sizeof(T); num_bits += 3) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - const T mask = (1 << num_bits) - 1; - for(size_t i = 0; i < size; i++) - h_keys[i] &= mask; + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector reference = h_keys; - thrust::device_vector d_keys = h_keys; + const T mask = (1 << num_bits) - 1; + for(size_t i = 0; i < size; i++) + h_keys[i] &= mask; - thrust::host_vector h_values = h_keys; - thrust::device_vector d_values = d_keys; + thrust::host_vector reference = h_keys; + thrust::device_vector d_keys = h_keys; - std::sort(reference.begin(), reference.end()); + thrust::host_vector h_values = h_keys; + thrust::device_vector d_values = d_keys; - thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); - thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin()); + std::sort(reference.begin(), reference.end()); - ASSERT_EQ(reference, h_keys); - ASSERT_EQ(reference, h_values); + thrust::sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); + thrust::sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin()); - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_values, d_values); + ASSERT_EQ(reference, h_keys); + ASSERT_EQ(reference, h_values); + + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_values, d_values); + } } } } diff --git a/test/test_sort_variables.cpp b/test/test_sort_variables.cpp index e3c145fb9..5695ceca6 100644 --- a/test/test_sort_variables.cpp +++ b/test/test_sort_variables.cpp @@ -31,23 +31,31 @@ TYPED_TEST(SortByKeyVariableTests, TestSortVariableBits) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value = seed_index < random_seeds_count + ? rand() + : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - size_t mask = (1 << num_bits) - 1; - for(size_t i = 0; i < size; i++) - h_keys[i] &= mask; + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector reference = h_keys; - thrust::device_vector d_keys = h_keys; + size_t mask = (1 << num_bits) - 1; + for(size_t i = 0; i < size; i++) + h_keys[i] &= mask; - std::sort(reference.begin(), reference.end()); + thrust::host_vector reference = h_keys; + thrust::device_vector d_keys = h_keys; - thrust::sort(h_keys.begin(), h_keys.end()); - thrust::sort(d_keys.begin(), d_keys.end()); + std::sort(reference.begin(), reference.end()); - ASSERT_EQ(reference, h_keys); - ASSERT_EQ(h_keys, d_keys); + thrust::sort(h_keys.begin(), h_keys.end()); + thrust::sort(d_keys.begin(), d_keys.end()); + + ASSERT_EQ(reference, h_keys); + ASSERT_EQ(h_keys, d_keys); + } } } } diff --git a/test/test_stable_sort.cpp b/test/test_stable_sort.cpp index 33b912cc6..560401878 100644 --- a/test/test_stable_sort.cpp +++ b/test/test_stable_sort.cpp @@ -111,14 +111,22 @@ TYPED_TEST(StableSortTests, TestStableSort) for(auto size : get_sizes()) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; - - thrust::stable_sort(h_data.begin(), h_data.end(), less_div_10()); - thrust::stable_sort(d_data.begin(), d_data.end(), less_div_10()); - - ASSERT_EQ(h_data, d_data); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; + + thrust::stable_sort(h_data.begin(), h_data.end(), less_div_10()); + thrust::stable_sort(d_data.begin(), d_data.end(), less_div_10()); + + ASSERT_EQ(h_data, d_data); + } } } diff --git a/test/test_stable_sort_by_key.cpp b/test/test_stable_sort_by_key.cpp index b87664651..a26181f28 100644 --- a/test/test_stable_sort_by_key.cpp +++ b/test/test_stable_sort_by_key.cpp @@ -146,18 +146,30 @@ TYPED_TEST(StableSortByKeyVectorPrimitiveTests, TestStableSortByKey) for(auto size : get_sizes()) { - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_keys = h_keys; - - thrust::host_vector h_values = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_values = h_values; - - thrust::stable_sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); - thrust::stable_sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin()); - - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_values, d_values); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_keys = h_keys; + + thrust::host_vector h_values = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_values = h_values; + + thrust::stable_sort_by_key(h_keys.begin(), h_keys.end(), h_values.begin()); + thrust::stable_sort_by_key(d_keys.begin(), d_keys.end(), d_values.begin()); + + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_values, d_values); + } } -} \ No newline at end of file +} diff --git a/test/test_swap_ranges.cpp b/test/test_swap_ranges.cpp index 3a656f05e..5ebe24bac 100644 --- a/test/test_swap_ranges.cpp +++ b/test/test_swap_ranges.cpp @@ -33,7 +33,7 @@ TEST(SwapRangesTests, UsingHip) template ForwardIterator2 - swap_ranges(my_system& system, ForwardIterator1, ForwardIterator1, ForwardIterator2 first2) +swap_ranges(my_system& system, ForwardIterator1, ForwardIterator1, ForwardIterator2 first2) { system.validate_dispatch(); return first2; @@ -108,28 +108,44 @@ TYPED_TEST(PrimitiveSwapRangesTests, SwapRanges) T error_margin = T(0.01); for(auto size : sizes) { - thrust::host_vector a1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector a2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h1 = a1; - thrust::host_vector h2 = a2; - thrust::device_vector d1 = a1; - thrust::device_vector d2 = a2; - - thrust::swap_ranges(h1.begin(), h1.end(), h2.begin()); - thrust::swap_ranges(d1.begin(), d1.end(), d2.begin()); - - thrust::host_vector d1_h = d1; - thrust::host_vector d2_h = d2; - - for(size_t i = 0; i < size; i++) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - ASSERT_NEAR(h1[i], a2[i], error_margin); - ASSERT_NEAR(d1_h[i], a2[i], error_margin); - ASSERT_NEAR(h2[i], a1[i], error_margin); - ASSERT_NEAR(d2_h[i], a1[i], error_margin); + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector a1 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + ); + thrust::host_vector a2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h1 = a1; + thrust::host_vector h2 = a2; + thrust::device_vector d1 = a1; + thrust::device_vector d2 = a2; + + thrust::swap_ranges(h1.begin(), h1.end(), h2.begin()); + thrust::swap_ranges(d1.begin(), d1.end(), d2.begin()); + + thrust::host_vector d1_h = d1; + thrust::host_vector d2_h = d2; + + for(size_t i = 0; i < size; i++) + { + ASSERT_NEAR(h1[i], a2[i], error_margin); + ASSERT_NEAR(d1_h[i], a2[i], error_margin); + ASSERT_NEAR(h2[i], a1[i], error_margin); + ASSERT_NEAR(d2_h[i], a1[i], error_margin); + } } } } diff --git a/test/test_tabulate.cpp b/test/test_tabulate.cpp index c5f17973a..a2e6d5cae 100644 --- a/test/test_tabulate.cpp +++ b/test/test_tabulate.cpp @@ -92,7 +92,7 @@ TYPED_TEST(TabulateTests, TestTabulateSimple) ASSERT_EQ(v[4], T(64)); } -template +template struct nonconst_op { THRUST_HIP_FUNCTION @@ -105,7 +105,7 @@ struct nonconst_op TYPED_TEST(TabulateTests, TestTabulateSimpleNonConstOP) { using Vector = typename TestFixture::input_type; - using T = typename Vector::value_type; + using T = typename Vector::value_type; Vector v(5); diff --git a/test/test_transform.cpp b/test/test_transform.cpp index 57454b5de..2d8492681 100644 --- a/test/test_transform.cpp +++ b/test/test_transform.cpp @@ -243,8 +243,8 @@ template -__host__ __device__ ForwardIterator transform_if( - my_tag, InputIterator, InputIterator, ForwardIterator result, UnaryFunction, Predicate) +__host__ __device__ ForwardIterator + transform_if(my_tag, InputIterator, InputIterator, ForwardIterator result, UnaryFunction, Predicate) { *result = 13; return result; @@ -545,18 +545,27 @@ TYPED_TEST(TransformTests, TestTransformUnary) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_input = h_input; + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); - thrust::transform(h_input.begin(), h_input.end(), h_output.begin(), thrust::negate()); - thrust::transform(d_input.begin(), d_input.end(), d_output.begin(), thrust::negate()); + thrust::transform( + h_input.begin(), h_input.end(), h_output.begin(), thrust::negate()); + thrust::transform( + d_input.begin(), d_input.end(), d_output.begin(), thrust::negate()); - ASSERT_EQ(h_output, d_output); + ASSERT_EQ(h_output, d_output); + } } } @@ -567,21 +576,32 @@ TYPED_TEST(TransformTests, TestTransformUnaryToDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_input = h_input; + thrust::device_vector d_input = h_input; - thrust::discard_iterator<> h_result = thrust::transform( - h_input.begin(), h_input.end(), thrust::make_discard_iterator(), thrust::negate()); + thrust::discard_iterator<> h_result = thrust::transform(h_input.begin(), + h_input.end(), + thrust::make_discard_iterator(), + thrust::negate()); - thrust::discard_iterator<> d_result = thrust::transform( - d_input.begin(), d_input.end(), thrust::make_discard_iterator(), thrust::negate()); + thrust::discard_iterator<> d_result = thrust::transform(d_input.begin(), + d_input.end(), + thrust::make_discard_iterator(), + thrust::negate()); - thrust::discard_iterator<> reference(size); + thrust::discard_iterator<> reference(size); - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } @@ -602,36 +622,45 @@ TYPED_TEST(TransformTests, TestTransformUnaryToDiscardIteratorZipped) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_input = h_input; + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); + thrust::device_vector d_input = h_input; - using Iterator1 = typename thrust::host_vector::iterator; - using Iterator2 = typename thrust::device_vector::iterator; + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); - using Tuple1 = thrust::tuple>; - using Tuple2 = thrust::tuple>; + using Iterator1 = typename thrust::host_vector::iterator; + using Iterator2 = typename thrust::device_vector::iterator; - using ZipIterator1 = thrust::zip_iterator; - using ZipIterator2 = thrust::zip_iterator; + using Tuple1 = thrust::tuple>; + using Tuple2 = thrust::tuple>; - ZipIterator1 z1(thrust::make_tuple(h_output.begin(), thrust::make_discard_iterator())); - ZipIterator2 z2(thrust::make_tuple(d_output.begin(), thrust::make_discard_iterator())); + using ZipIterator1 = thrust::zip_iterator; + using ZipIterator2 = thrust::zip_iterator; - ZipIterator1 h_result = thrust::transform(h_input.begin(), h_input.end(), z1, repeat2()); + ZipIterator1 z1(thrust::make_tuple(h_output.begin(), thrust::make_discard_iterator())); + ZipIterator2 z2(thrust::make_tuple(d_output.begin(), thrust::make_discard_iterator())); - ZipIterator2 d_result = thrust::transform(d_input.begin(), d_input.end(), z2, repeat2()); + ZipIterator1 h_result + = thrust::transform(h_input.begin(), h_input.end(), z1, repeat2()); - thrust::discard_iterator<> reference(size); + ZipIterator2 d_result + = thrust::transform(d_input.begin(), d_input.end(), z2, repeat2()); - ASSERT_EQ(h_output, d_output); + thrust::discard_iterator<> reference(size); - ASSERT_EQ_QUIET(reference, thrust::get<1>(h_result.get_iterator_tuple())); - ASSERT_EQ_QUIET(reference, thrust::get<1>(d_result.get_iterator_tuple())); + ASSERT_EQ(h_output, d_output); + + ASSERT_EQ_QUIET(reference, thrust::get<1>(h_result.get_iterator_tuple())); + ASSERT_EQ_QUIET(reference, thrust::get<1>(d_result.get_iterator_tuple())); + } } } @@ -652,22 +681,39 @@ TYPED_TEST(TransformTests, TestTransformIfUnaryNoStencil) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_output = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_input = h_input; - thrust::device_vector d_output = h_output; - - thrust::transform_if( - h_input.begin(), h_input.end(), h_output.begin(), thrust::negate(), is_positive()); - - thrust::transform_if( - d_input.begin(), d_input.end(), d_output.begin(), thrust::negate(), is_positive()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_output = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_input = h_input; + thrust::device_vector d_output = h_output; + + thrust::transform_if(h_input.begin(), + h_input.end(), + h_output.begin(), + thrust::negate(), + is_positive()); + + thrust::transform_if(d_input.begin(), + d_input.end(), + d_output.begin(), + thrust::negate(), + is_positive()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -679,33 +725,48 @@ TYPED_TEST(TransformTests, TestTransformIfUnary) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_output = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_input = h_input; - thrust::device_vector d_stencil = h_stencil; - thrust::device_vector d_output = h_output; - - thrust::transform_if(h_input.begin(), - h_input.end(), - h_stencil.begin(), - h_output.begin(), - thrust::negate(), - is_positive()); - - thrust::transform_if(d_input.begin(), - d_input.end(), - d_stencil.begin(), - d_output.begin(), - thrust::negate(), - is_positive()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_output = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_input = h_input; + thrust::device_vector d_stencil = h_stencil; + thrust::device_vector d_output = h_output; + + thrust::transform_if(h_input.begin(), + h_input.end(), + h_stencil.begin(), + h_output.begin(), + thrust::negate(), + is_positive()); + + thrust::transform_if(d_input.begin(), + d_input.end(), + d_stencil.begin(), + d_output.begin(), + thrust::negate(), + is_positive()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -716,32 +777,45 @@ TYPED_TEST(TransformTests, TestTransformIfUnaryToDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_input = h_input; - thrust::device_vector d_stencil = h_stencil; - - thrust::discard_iterator<> h_result = thrust::transform_if(h_input.begin(), - h_input.end(), - h_stencil.begin(), - thrust::make_discard_iterator(), - thrust::negate(), - is_positive()); - - thrust::discard_iterator<> d_result = thrust::transform_if(d_input.begin(), - d_input.end(), - d_stencil.begin(), - thrust::make_discard_iterator(), - thrust::negate(), - is_positive()); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_input = h_input; + thrust::device_vector d_stencil = h_stencil; + + thrust::discard_iterator<> h_result + = thrust::transform_if(h_input.begin(), + h_input.end(), + h_stencil.begin(), + thrust::make_discard_iterator(), + thrust::negate(), + is_positive()); + + thrust::discard_iterator<> d_result + = thrust::transform_if(d_input.begin(), + d_input.end(), + d_stencil.begin(), + thrust::make_discard_iterator(), + thrust::negate(), + is_positive()); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } @@ -752,42 +826,53 @@ TYPED_TEST(TransformTests, TestTransformBinary) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_input2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_input1 = h_input1; - thrust::device_vector d_input2 = h_input2; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - thrust::transform(h_input1.begin(), - h_input1.end(), - h_input2.begin(), - h_output.begin(), - thrust::minus()); - thrust::transform(d_input1.begin(), - d_input1.end(), - d_input2.begin(), - d_output.begin(), - thrust::minus()); - - ASSERT_EQ(h_output, d_output); - - thrust::transform(h_input1.begin(), - h_input1.end(), - h_input2.begin(), - h_output.begin(), - thrust::multiplies()); - thrust::transform(d_input1.begin(), - d_input1.end(), - d_input2.begin(), - d_output.begin(), - thrust::multiplies()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_input2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_input1 = h_input1; + thrust::device_vector d_input2 = h_input2; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + thrust::transform(h_input1.begin(), + h_input1.end(), + h_input2.begin(), + h_output.begin(), + thrust::minus()); + thrust::transform(d_input1.begin(), + d_input1.end(), + d_input2.begin(), + d_output.begin(), + thrust::minus()); + + ASSERT_EQ(h_output, d_output); + + thrust::transform(h_input1.begin(), + h_input1.end(), + h_input2.begin(), + h_output.begin(), + thrust::multiplies()); + thrust::transform(d_input1.begin(), + d_input1.end(), + d_input2.begin(), + d_output.begin(), + thrust::multiplies()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -798,29 +883,40 @@ TYPED_TEST(TransformTests, TestTransformBinaryToDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_input2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_input1 = h_input1; - thrust::device_vector d_input2 = h_input2; - - thrust::discard_iterator<> h_result = thrust::transform(h_input1.begin(), - h_input1.end(), - h_input2.begin(), - thrust::make_discard_iterator(), - thrust::minus()); - thrust::discard_iterator<> d_result = thrust::transform(d_input1.begin(), - d_input1.end(), - d_input2.begin(), - thrust::make_discard_iterator(), - thrust::minus()); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_input2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_input1 = h_input1; + thrust::device_vector d_input2 = h_input2; + + thrust::discard_iterator<> h_result = thrust::transform(h_input1.begin(), + h_input1.end(), + h_input2.begin(), + thrust::make_discard_iterator(), + thrust::minus()); + thrust::discard_iterator<> d_result = thrust::transform(d_input1.begin(), + d_input1.end(), + d_input2.begin(), + thrust::make_discard_iterator(), + thrust::minus()); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } @@ -831,60 +927,83 @@ TYPED_TEST(TransformTests, TestTransformIfBinary) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_input2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_output = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_input1 = h_input1; - thrust::device_vector d_input2 = h_input2; - thrust::device_vector d_stencil = h_stencil; - thrust::device_vector d_output = h_output; - - thrust::transform_if(h_input1.begin(), - h_input1.end(), - h_input2.begin(), - h_stencil.begin(), - h_output.begin(), - thrust::minus(), - is_positive()); - - thrust::transform_if(d_input1.begin(), - d_input1.end(), - d_input2.begin(), - d_stencil.begin(), - d_output.begin(), - thrust::minus(), - is_positive()); - - ASSERT_EQ(h_output, d_output); - - h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - d_stencil = h_stencil; - - thrust::transform_if(h_input1.begin(), - h_input1.end(), - h_input2.begin(), - h_stencil.begin(), - h_output.begin(), - thrust::multiplies(), - is_positive()); - - thrust::transform_if(d_input1.begin(), - d_input1.end(), - d_input2.begin(), - d_stencil.begin(), - d_output.begin(), - thrust::multiplies(), - is_positive()); - - ASSERT_EQ(h_output, d_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_input2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + thrust::host_vector h_output = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 3 * seed_value_addition + ); + + thrust::device_vector d_input1 = h_input1; + thrust::device_vector d_input2 = h_input2; + thrust::device_vector d_stencil = h_stencil; + thrust::device_vector d_output = h_output; + + thrust::transform_if(h_input1.begin(), + h_input1.end(), + h_input2.begin(), + h_stencil.begin(), + h_output.begin(), + thrust::minus(), + is_positive()); + + thrust::transform_if(d_input1.begin(), + d_input1.end(), + d_input2.begin(), + d_stencil.begin(), + d_output.begin(), + thrust::minus(), + is_positive()); + + ASSERT_EQ(h_output, d_output); + + h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 4 * seed_value_addition + ); + d_stencil = h_stencil; + + thrust::transform_if(h_input1.begin(), + h_input1.end(), + h_input2.begin(), + h_stencil.begin(), + h_output.begin(), + thrust::multiplies(), + is_positive()); + + thrust::transform_if(d_input1.begin(), + d_input1.end(), + d_input2.begin(), + d_stencil.begin(), + d_output.begin(), + thrust::multiplies(), + is_positive()); + + ASSERT_EQ(h_output, d_output); + } } } @@ -895,38 +1014,59 @@ TYPED_TEST(TransformTests, TestTransformIfBinaryToDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_input1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_input2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_stencil = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_input1 = h_input1; - thrust::device_vector d_input2 = h_input2; - thrust::device_vector d_stencil = h_stencil; - - thrust::discard_iterator<> h_result = thrust::transform_if(h_input1.begin(), - h_input1.end(), - h_input2.begin(), - h_stencil.begin(), - thrust::make_discard_iterator(), - thrust::minus(), - is_positive()); - - thrust::discard_iterator<> d_result = thrust::transform_if(d_input1.begin(), - d_input1.end(), - d_input2.begin(), - d_stencil.begin(), - thrust::make_discard_iterator(), - thrust::minus(), - is_positive()); - - thrust::discard_iterator<> reference(size); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input1 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + ); + thrust::host_vector h_input2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::host_vector h_stencil = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + thrust::device_vector d_input1 = h_input1; + thrust::device_vector d_input2 = h_input2; + thrust::device_vector d_stencil = h_stencil; + + thrust::discard_iterator<> h_result + = thrust::transform_if(h_input1.begin(), + h_input1.end(), + h_input2.begin(), + h_stencil.begin(), + thrust::make_discard_iterator(), + thrust::minus(), + is_positive()); + + thrust::discard_iterator<> d_result + = thrust::transform_if(d_input1.begin(), + d_input1.end(), + d_input2.begin(), + d_stencil.begin(), + thrust::make_discard_iterator(), + thrust::minus(), + is_positive()); + + thrust::discard_iterator<> reference(size); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } diff --git a/test/test_transform_iterator.cpp b/test/test_transform_iterator.cpp index 3f1e48858..6d92e568c 100644 --- a/test/test_transform_iterator.cpp +++ b/test/test_transform_iterator.cpp @@ -91,20 +91,28 @@ TYPED_TEST(PrimitiveTransformIteratorTests, TransformIteratorReduce) const std::vector sizes = get_sizes(); for(auto size : sizes) { - T error_margin = (T)0.01 * size; - thrust::host_vector h_data = get_random_data(size, 0, 10); - thrust::device_vector d_data = h_data; - - // run on host - T h_result - = thrust::reduce(thrust::make_transform_iterator(h_data.begin(), thrust::negate()), - thrust::make_transform_iterator(h_data.end(), thrust::negate())); - - // run on device - T d_result - = thrust::reduce(thrust::make_transform_iterator(d_data.begin(), thrust::negate()), - thrust::make_transform_iterator(d_data.end(), thrust::negate())); - - ASSERT_NEAR(h_result, d_result, error_margin); + SCOPED_TRACE(testing::Message() << "with size= " << size); + T error_margin = (T)0.01 * size; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data(size, 0, 10, seed_value); + thrust::device_vector d_data = h_data; + + // run on host + T h_result = thrust::reduce( + thrust::make_transform_iterator(h_data.begin(), thrust::negate()), + thrust::make_transform_iterator(h_data.end(), thrust::negate())); + + // run on device + T d_result = thrust::reduce( + thrust::make_transform_iterator(d_data.begin(), thrust::negate()), + thrust::make_transform_iterator(d_data.end(), thrust::negate())); + + ASSERT_NEAR(h_result, d_result, error_margin); + } } } diff --git a/test/test_transform_reduce.cpp b/test/test_transform_reduce.cpp index e673e893c..fb8bd1acd 100644 --- a/test/test_transform_reduce.cpp +++ b/test/test_transform_reduce.cpp @@ -93,19 +93,27 @@ TYPED_TEST(TransformReduceIntegerPrimitiveTests, TestTransformReduce) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - T init = T(13); + thrust::device_vector d_data = h_data; - T cpu_result = thrust::transform_reduce( - h_data.begin(), h_data.end(), thrust::negate(), init, thrust::plus()); - T gpu_result = thrust::transform_reduce( - d_data.begin(), d_data.end(), thrust::negate(), init, thrust::plus()); + T init = T(13); - ASSERT_EQ(cpu_result, gpu_result); + T cpu_result = thrust::transform_reduce( + h_data.begin(), h_data.end(), thrust::negate(), init, thrust::plus()); + T gpu_result = thrust::transform_reduce( + d_data.begin(), d_data.end(), thrust::negate(), init, thrust::plus()); + + ASSERT_EQ(cpu_result, gpu_result); + } } } @@ -116,19 +124,27 @@ TYPED_TEST(TransformReduceIntegerPrimitiveTests, TestTransformReduceFromConst) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::device_vector d_data = h_data; + thrust::device_vector d_data = h_data; - T init = T(13); + T init = T(13); - T cpu_result = thrust::transform_reduce( - h_data.cbegin(), h_data.cend(), thrust::negate(), init, thrust::plus()); - T gpu_result = thrust::transform_reduce( - d_data.cbegin(), d_data.cend(), thrust::negate(), init, thrust::plus()); + T cpu_result = thrust::transform_reduce( + h_data.cbegin(), h_data.cend(), thrust::negate(), init, thrust::plus()); + T gpu_result = thrust::transform_reduce( + d_data.cbegin(), d_data.cend(), thrust::negate(), init, thrust::plus()); - ASSERT_EQ(cpu_result, gpu_result); + ASSERT_EQ(cpu_result, gpu_result); + } } } diff --git a/test/test_transform_scan.cpp b/test/test_transform_scan.cpp index 286572ddc..291d545c5 100644 --- a/test/test_transform_scan.cpp +++ b/test/test_transform_scan.cpp @@ -222,69 +222,77 @@ TYPED_TEST(TransformScanVariablesTests, TestTransformScan) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); - - thrust::transform_inclusive_scan(h_input.begin(), - h_input.end(), - h_output.begin(), - thrust::negate(), - thrust::plus()); - thrust::transform_inclusive_scan(d_input.begin(), - d_input.end(), - d_output.begin(), - thrust::negate(), - thrust::plus()); - ASSERT_EQ(d_output, h_output); - - thrust::transform_exclusive_scan(h_input.begin(), - h_input.end(), - h_output.begin(), - thrust::negate(), - (T)11, - thrust::plus()); - thrust::transform_exclusive_scan(d_input.begin(), - d_input.end(), - d_output.begin(), - thrust::negate(), - (T)11, - thrust::plus()); - ASSERT_EQ(d_output, h_output); - - // in-place scans - h_output = h_input; - d_output = d_input; - thrust::transform_inclusive_scan(h_output.begin(), - h_output.end(), - h_output.begin(), - thrust::negate(), - thrust::plus()); - thrust::transform_inclusive_scan(d_output.begin(), - d_output.end(), - d_output.begin(), - thrust::negate(), - thrust::plus()); - ASSERT_EQ(d_output, h_output); - - h_output = h_input; - d_output = d_input; - thrust::transform_exclusive_scan(h_output.begin(), - h_output.end(), - h_output.begin(), - thrust::negate(), - (T)11, - thrust::plus()); - thrust::transform_exclusive_scan(d_output.begin(), - d_output.end(), - d_output.begin(), - thrust::negate(), - (T)11, - thrust::plus()); - ASSERT_EQ(d_output, h_output); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); + + thrust::transform_inclusive_scan(h_input.begin(), + h_input.end(), + h_output.begin(), + thrust::negate(), + thrust::plus()); + thrust::transform_inclusive_scan(d_input.begin(), + d_input.end(), + d_output.begin(), + thrust::negate(), + thrust::plus()); + ASSERT_EQ(d_output, h_output); + + thrust::transform_exclusive_scan(h_input.begin(), + h_input.end(), + h_output.begin(), + thrust::negate(), + (T)11, + thrust::plus()); + thrust::transform_exclusive_scan(d_input.begin(), + d_input.end(), + d_output.begin(), + thrust::negate(), + (T)11, + thrust::plus()); + ASSERT_EQ(d_output, h_output); + + // in-place scans + h_output = h_input; + d_output = d_input; + thrust::transform_inclusive_scan(h_output.begin(), + h_output.end(), + h_output.begin(), + thrust::negate(), + thrust::plus()); + thrust::transform_inclusive_scan(d_output.begin(), + d_output.end(), + d_output.begin(), + thrust::negate(), + thrust::plus()); + ASSERT_EQ(d_output, h_output); + + h_output = h_input; + d_output = d_input; + thrust::transform_exclusive_scan(h_output.begin(), + h_output.end(), + h_output.begin(), + thrust::negate(), + (T)11, + thrust::plus()); + thrust::transform_exclusive_scan(d_output.begin(), + d_output.end(), + d_output.begin(), + thrust::negate(), + (T)11, + thrust::plus()); + ASSERT_EQ(d_output, h_output); + } } }; @@ -314,43 +322,51 @@ TYPED_TEST(TransformScanVariablesTests, TestTransformScanToDiscardIterator) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_input = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_input = h_input; - - thrust::discard_iterator<> reference(size); - - thrust::discard_iterator<> h_result - = thrust::transform_inclusive_scan(h_input.begin(), - h_input.end(), - thrust::make_discard_iterator(), - thrust::negate(), - thrust::plus()); - - thrust::discard_iterator<> d_result - = thrust::transform_inclusive_scan(d_input.begin(), - d_input.end(), - thrust::make_discard_iterator(), - thrust::negate(), - thrust::plus()); - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); - - h_result = thrust::transform_exclusive_scan(h_input.begin(), - h_input.end(), - thrust::make_discard_iterator(), - thrust::negate(), - (T)11, - thrust::plus()); - - d_result = thrust::transform_exclusive_scan(d_input.begin(), - d_input.end(), - thrust::make_discard_iterator(), - thrust::negate(), - (T)11, - thrust::plus()); - - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_input = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_input = h_input; + + thrust::discard_iterator<> reference(size); + + thrust::discard_iterator<> h_result + = thrust::transform_inclusive_scan(h_input.begin(), + h_input.end(), + thrust::make_discard_iterator(), + thrust::negate(), + thrust::plus()); + + thrust::discard_iterator<> d_result + = thrust::transform_inclusive_scan(d_input.begin(), + d_input.end(), + thrust::make_discard_iterator(), + thrust::negate(), + thrust::plus()); + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + + h_result = thrust::transform_exclusive_scan(h_input.begin(), + h_input.end(), + thrust::make_discard_iterator(), + thrust::negate(), + (T)11, + thrust::plus()); + + d_result = thrust::transform_exclusive_scan(d_input.begin(), + d_input.end(), + thrust::make_discard_iterator(), + thrust::negate(), + (T)11, + thrust::plus()); + + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } diff --git a/test/test_tuple.cpp b/test/test_tuple.cpp index 829b6e29d..8a5104472 100644 --- a/test/test_tuple.cpp +++ b/test/test_tuple.cpp @@ -28,78 +28,84 @@ TESTS_DEFINE(TupleTests, NumericalTestsParams); TYPED_TEST(TupleTests, TestTupleConstructor) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + + thrust::host_vector data = get_random_data( + 10, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::tuple t1(data[0]); + ASSERT_EQ(data[0], thrust::get<0>(t1)); + + thrust::tuple t2(data[0], data[1]); + ASSERT_EQ(data[0], thrust::get<0>(t2)); + ASSERT_EQ(data[1], thrust::get<1>(t2)); + + thrust::tuple t3(data[0], data[1], data[2]); + ASSERT_EQ(data[0], thrust::get<0>(t3)); + ASSERT_EQ(data[1], thrust::get<1>(t3)); + ASSERT_EQ(data[2], thrust::get<2>(t3)); + + thrust::tuple t4(data[0], data[1], data[2], data[3]); + ASSERT_EQ(data[0], thrust::get<0>(t4)); + ASSERT_EQ(data[1], thrust::get<1>(t4)); + ASSERT_EQ(data[2], thrust::get<2>(t4)); + ASSERT_EQ(data[3], thrust::get<3>(t4)); + + thrust::tuple t5(data[0], data[1], data[2], data[3], data[4]); + ASSERT_EQ(data[0], thrust::get<0>(t5)); + ASSERT_EQ(data[1], thrust::get<1>(t5)); + ASSERT_EQ(data[2], thrust::get<2>(t5)); + ASSERT_EQ(data[3], thrust::get<3>(t5)); + ASSERT_EQ(data[4], thrust::get<4>(t5)); + + thrust::tuple t6(data[0], data[1], data[2], data[3], data[4], data[5]); + ASSERT_EQ(data[0], thrust::get<0>(t6)); + ASSERT_EQ(data[1], thrust::get<1>(t6)); + ASSERT_EQ(data[2], thrust::get<2>(t6)); + ASSERT_EQ(data[3], thrust::get<3>(t6)); + ASSERT_EQ(data[4], thrust::get<4>(t6)); + ASSERT_EQ(data[5], thrust::get<5>(t6)); + + thrust::tuple t7( + data[0], data[1], data[2], data[3], data[4], data[5], data[6]); + ASSERT_EQ(data[0], thrust::get<0>(t7)); + ASSERT_EQ(data[1], thrust::get<1>(t7)); + ASSERT_EQ(data[2], thrust::get<2>(t7)); + ASSERT_EQ(data[3], thrust::get<3>(t7)); + ASSERT_EQ(data[4], thrust::get<4>(t7)); + ASSERT_EQ(data[5], thrust::get<5>(t7)); + ASSERT_EQ(data[6], thrust::get<6>(t7)); + + thrust::tuple t8( + data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); + ASSERT_EQ(data[0], thrust::get<0>(t8)); + ASSERT_EQ(data[1], thrust::get<1>(t8)); + ASSERT_EQ(data[2], thrust::get<2>(t8)); + ASSERT_EQ(data[3], thrust::get<3>(t8)); + ASSERT_EQ(data[4], thrust::get<4>(t8)); + ASSERT_EQ(data[5], thrust::get<5>(t8)); + ASSERT_EQ(data[6], thrust::get<6>(t8)); + ASSERT_EQ(data[7], thrust::get<7>(t8)); + + thrust::tuple t9( + data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]); + ASSERT_EQ(data[0], thrust::get<0>(t9)); + ASSERT_EQ(data[1], thrust::get<1>(t9)); + ASSERT_EQ(data[2], thrust::get<2>(t9)); + ASSERT_EQ(data[3], thrust::get<3>(t9)); + ASSERT_EQ(data[4], thrust::get<4>(t9)); + ASSERT_EQ(data[5], thrust::get<5>(t9)); + ASSERT_EQ(data[6], thrust::get<6>(t9)); + ASSERT_EQ(data[7], thrust::get<7>(t9)); + ASSERT_EQ(data[8], thrust::get<8>(t9)); - thrust::host_vector data - = get_random_data(10, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::tuple t1(data[0]); - ASSERT_EQ(data[0], thrust::get<0>(t1)); - - thrust::tuple t2(data[0], data[1]); - ASSERT_EQ(data[0], thrust::get<0>(t2)); - ASSERT_EQ(data[1], thrust::get<1>(t2)); - - thrust::tuple t3(data[0], data[1], data[2]); - ASSERT_EQ(data[0], thrust::get<0>(t3)); - ASSERT_EQ(data[1], thrust::get<1>(t3)); - ASSERT_EQ(data[2], thrust::get<2>(t3)); - - thrust::tuple t4(data[0], data[1], data[2], data[3]); - ASSERT_EQ(data[0], thrust::get<0>(t4)); - ASSERT_EQ(data[1], thrust::get<1>(t4)); - ASSERT_EQ(data[2], thrust::get<2>(t4)); - ASSERT_EQ(data[3], thrust::get<3>(t4)); - - thrust::tuple t5(data[0], data[1], data[2], data[3], data[4]); - ASSERT_EQ(data[0], thrust::get<0>(t5)); - ASSERT_EQ(data[1], thrust::get<1>(t5)); - ASSERT_EQ(data[2], thrust::get<2>(t5)); - ASSERT_EQ(data[3], thrust::get<3>(t5)); - ASSERT_EQ(data[4], thrust::get<4>(t5)); - - thrust::tuple t6(data[0], data[1], data[2], data[3], data[4], data[5]); - ASSERT_EQ(data[0], thrust::get<0>(t6)); - ASSERT_EQ(data[1], thrust::get<1>(t6)); - ASSERT_EQ(data[2], thrust::get<2>(t6)); - ASSERT_EQ(data[3], thrust::get<3>(t6)); - ASSERT_EQ(data[4], thrust::get<4>(t6)); - ASSERT_EQ(data[5], thrust::get<5>(t6)); - - thrust::tuple t7( - data[0], data[1], data[2], data[3], data[4], data[5], data[6]); - ASSERT_EQ(data[0], thrust::get<0>(t7)); - ASSERT_EQ(data[1], thrust::get<1>(t7)); - ASSERT_EQ(data[2], thrust::get<2>(t7)); - ASSERT_EQ(data[3], thrust::get<3>(t7)); - ASSERT_EQ(data[4], thrust::get<4>(t7)); - ASSERT_EQ(data[5], thrust::get<5>(t7)); - ASSERT_EQ(data[6], thrust::get<6>(t7)); - - thrust::tuple t8( - data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); - ASSERT_EQ(data[0], thrust::get<0>(t8)); - ASSERT_EQ(data[1], thrust::get<1>(t8)); - ASSERT_EQ(data[2], thrust::get<2>(t8)); - ASSERT_EQ(data[3], thrust::get<3>(t8)); - ASSERT_EQ(data[4], thrust::get<4>(t8)); - ASSERT_EQ(data[5], thrust::get<5>(t8)); - ASSERT_EQ(data[6], thrust::get<6>(t8)); - ASSERT_EQ(data[7], thrust::get<7>(t8)); - - thrust::tuple t9( - data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]); - ASSERT_EQ(data[0], thrust::get<0>(t9)); - ASSERT_EQ(data[1], thrust::get<1>(t9)); - ASSERT_EQ(data[2], thrust::get<2>(t9)); - ASSERT_EQ(data[3], thrust::get<3>(t9)); - ASSERT_EQ(data[4], thrust::get<4>(t9)); - ASSERT_EQ(data[5], thrust::get<5>(t9)); - ASSERT_EQ(data[6], thrust::get<6>(t9)); - ASSERT_EQ(data[7], thrust::get<7>(t9)); - ASSERT_EQ(data[8], thrust::get<8>(t9)); - - // TODO: tuple cannot handle 10 element - /*thrust::tuple t10(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + // TODO: tuple cannot handle 10 element + /*thrust::tuple t10(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); ASSERT_EQ(data[0], thrust::get<0>(t10)); ASSERT_EQ(data[1], thrust::get<1>(t10)); ASSERT_EQ(data[2], thrust::get<2>(t10)); @@ -110,85 +116,95 @@ TYPED_TEST(TupleTests, TestTupleConstructor) ASSERT_EQ(data[7], thrust::get<7>(t10)); ASSERT_EQ(data[8], thrust::get<8>(t10)); ASSERT_EQ(data[9], thrust::get<9>(t10));*/ + } } TYPED_TEST(TupleTests, TestMakeTuple) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector data = get_random_data( + 10, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + ); + + thrust::tuple t1 = thrust::make_tuple(data[0]); + ASSERT_EQ(data[0], thrust::get<0>(t1)); + + thrust::tuple t2 = thrust::make_tuple(data[0], data[1]); + ASSERT_EQ(data[0], thrust::get<0>(t2)); + ASSERT_EQ(data[1], thrust::get<1>(t2)); + + thrust::tuple t3 = thrust::make_tuple(data[0], data[1], data[2]); + ASSERT_EQ(data[0], thrust::get<0>(t3)); + ASSERT_EQ(data[1], thrust::get<1>(t3)); + ASSERT_EQ(data[2], thrust::get<2>(t3)); + + thrust::tuple t4 = thrust::make_tuple(data[0], data[1], data[2], data[3]); + ASSERT_EQ(data[0], thrust::get<0>(t4)); + ASSERT_EQ(data[1], thrust::get<1>(t4)); + ASSERT_EQ(data[2], thrust::get<2>(t4)); + ASSERT_EQ(data[3], thrust::get<3>(t4)); + + thrust::tuple t5 + = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4]); + ASSERT_EQ(data[0], thrust::get<0>(t5)); + ASSERT_EQ(data[1], thrust::get<1>(t5)); + ASSERT_EQ(data[2], thrust::get<2>(t5)); + ASSERT_EQ(data[3], thrust::get<3>(t5)); + ASSERT_EQ(data[4], thrust::get<4>(t5)); + + thrust::tuple t6 + = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5]); + ASSERT_EQ(data[0], thrust::get<0>(t6)); + ASSERT_EQ(data[1], thrust::get<1>(t6)); + ASSERT_EQ(data[2], thrust::get<2>(t6)); + ASSERT_EQ(data[3], thrust::get<3>(t6)); + ASSERT_EQ(data[4], thrust::get<4>(t6)); + ASSERT_EQ(data[5], thrust::get<5>(t6)); + + thrust::tuple t7 + = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6]); + ASSERT_EQ(data[0], thrust::get<0>(t7)); + ASSERT_EQ(data[1], thrust::get<1>(t7)); + ASSERT_EQ(data[2], thrust::get<2>(t7)); + ASSERT_EQ(data[3], thrust::get<3>(t7)); + ASSERT_EQ(data[4], thrust::get<4>(t7)); + ASSERT_EQ(data[5], thrust::get<5>(t7)); + ASSERT_EQ(data[6], thrust::get<6>(t7)); + + thrust::tuple t8 = thrust::make_tuple( + data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); + ASSERT_EQ(data[0], thrust::get<0>(t8)); + ASSERT_EQ(data[1], thrust::get<1>(t8)); + ASSERT_EQ(data[2], thrust::get<2>(t8)); + ASSERT_EQ(data[3], thrust::get<3>(t8)); + ASSERT_EQ(data[4], thrust::get<4>(t8)); + ASSERT_EQ(data[5], thrust::get<5>(t8)); + ASSERT_EQ(data[6], thrust::get<6>(t8)); + ASSERT_EQ(data[7], thrust::get<7>(t8)); + + thrust::tuple t9 = thrust::make_tuple( + data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]); + ASSERT_EQ(data[0], thrust::get<0>(t9)); + ASSERT_EQ(data[1], thrust::get<1>(t9)); + ASSERT_EQ(data[2], thrust::get<2>(t9)); + ASSERT_EQ(data[3], thrust::get<3>(t9)); + ASSERT_EQ(data[4], thrust::get<4>(t9)); + ASSERT_EQ(data[5], thrust::get<5>(t9)); + ASSERT_EQ(data[6], thrust::get<6>(t9)); + ASSERT_EQ(data[7], thrust::get<7>(t9)); + ASSERT_EQ(data[8], thrust::get<8>(t9)); - thrust::host_vector data - = get_random_data(10, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::tuple t1 = thrust::make_tuple(data[0]); - ASSERT_EQ(data[0], thrust::get<0>(t1)); - - thrust::tuple t2 = thrust::make_tuple(data[0], data[1]); - ASSERT_EQ(data[0], thrust::get<0>(t2)); - ASSERT_EQ(data[1], thrust::get<1>(t2)); - - thrust::tuple t3 = thrust::make_tuple(data[0], data[1], data[2]); - ASSERT_EQ(data[0], thrust::get<0>(t3)); - ASSERT_EQ(data[1], thrust::get<1>(t3)); - ASSERT_EQ(data[2], thrust::get<2>(t3)); - - thrust::tuple t4 = thrust::make_tuple(data[0], data[1], data[2], data[3]); - ASSERT_EQ(data[0], thrust::get<0>(t4)); - ASSERT_EQ(data[1], thrust::get<1>(t4)); - ASSERT_EQ(data[2], thrust::get<2>(t4)); - ASSERT_EQ(data[3], thrust::get<3>(t4)); - - thrust::tuple t5 - = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4]); - ASSERT_EQ(data[0], thrust::get<0>(t5)); - ASSERT_EQ(data[1], thrust::get<1>(t5)); - ASSERT_EQ(data[2], thrust::get<2>(t5)); - ASSERT_EQ(data[3], thrust::get<3>(t5)); - ASSERT_EQ(data[4], thrust::get<4>(t5)); - - thrust::tuple t6 - = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5]); - ASSERT_EQ(data[0], thrust::get<0>(t6)); - ASSERT_EQ(data[1], thrust::get<1>(t6)); - ASSERT_EQ(data[2], thrust::get<2>(t6)); - ASSERT_EQ(data[3], thrust::get<3>(t6)); - ASSERT_EQ(data[4], thrust::get<4>(t6)); - ASSERT_EQ(data[5], thrust::get<5>(t6)); - - thrust::tuple t7 - = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6]); - ASSERT_EQ(data[0], thrust::get<0>(t7)); - ASSERT_EQ(data[1], thrust::get<1>(t7)); - ASSERT_EQ(data[2], thrust::get<2>(t7)); - ASSERT_EQ(data[3], thrust::get<3>(t7)); - ASSERT_EQ(data[4], thrust::get<4>(t7)); - ASSERT_EQ(data[5], thrust::get<5>(t7)); - ASSERT_EQ(data[6], thrust::get<6>(t7)); - - thrust::tuple t8 = thrust::make_tuple( - data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); - ASSERT_EQ(data[0], thrust::get<0>(t8)); - ASSERT_EQ(data[1], thrust::get<1>(t8)); - ASSERT_EQ(data[2], thrust::get<2>(t8)); - ASSERT_EQ(data[3], thrust::get<3>(t8)); - ASSERT_EQ(data[4], thrust::get<4>(t8)); - ASSERT_EQ(data[5], thrust::get<5>(t8)); - ASSERT_EQ(data[6], thrust::get<6>(t8)); - ASSERT_EQ(data[7], thrust::get<7>(t8)); - - thrust::tuple t9 = thrust::make_tuple( - data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]); - ASSERT_EQ(data[0], thrust::get<0>(t9)); - ASSERT_EQ(data[1], thrust::get<1>(t9)); - ASSERT_EQ(data[2], thrust::get<2>(t9)); - ASSERT_EQ(data[3], thrust::get<3>(t9)); - ASSERT_EQ(data[4], thrust::get<4>(t9)); - ASSERT_EQ(data[5], thrust::get<5>(t9)); - ASSERT_EQ(data[6], thrust::get<6>(t9)); - ASSERT_EQ(data[7], thrust::get<7>(t9)); - ASSERT_EQ(data[8], thrust::get<8>(t9)); - - // TODO: tuple cannot handle 10 element - /*thrust::tuple t10 = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + // TODO: tuple cannot handle 10 element + /*thrust::tuple t10 = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); ASSERT_EQ(data[0], thrust::get<0>(t10)); ASSERT_EQ(data[1], thrust::get<1>(t10)); ASSERT_EQ(data[2], thrust::get<2>(t10)); @@ -199,85 +215,92 @@ TYPED_TEST(TupleTests, TestMakeTuple) ASSERT_EQ(data[7], thrust::get<7>(t10)); ASSERT_EQ(data[8], thrust::get<8>(t10)); ASSERT_EQ(data[9], thrust::get<9>(t10));*/ + } } TYPED_TEST(TupleTests, TestTupleGet) { using T = typename TestFixture::input_type; + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + + thrust::host_vector data = get_random_data( + 10, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::tuple t1(data[0]); + ASSERT_EQ(data[0], thrust::get<0>(t1)); + + thrust::tuple t2(data[0], data[1]); + ASSERT_EQ(data[0], thrust::get<0>(t2)); + ASSERT_EQ(data[1], thrust::get<1>(t2)); + + thrust::tuple t3 = thrust::make_tuple(data[0], data[1], data[2]); + ASSERT_EQ(data[0], thrust::get<0>(t3)); + ASSERT_EQ(data[1], thrust::get<1>(t3)); + ASSERT_EQ(data[2], thrust::get<2>(t3)); + + thrust::tuple t4 = thrust::make_tuple(data[0], data[1], data[2], data[3]); + ASSERT_EQ(data[0], thrust::get<0>(t4)); + ASSERT_EQ(data[1], thrust::get<1>(t4)); + ASSERT_EQ(data[2], thrust::get<2>(t4)); + ASSERT_EQ(data[3], thrust::get<3>(t4)); + + thrust::tuple t5 + = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4]); + ASSERT_EQ(data[0], thrust::get<0>(t5)); + ASSERT_EQ(data[1], thrust::get<1>(t5)); + ASSERT_EQ(data[2], thrust::get<2>(t5)); + ASSERT_EQ(data[3], thrust::get<3>(t5)); + ASSERT_EQ(data[4], thrust::get<4>(t5)); + + thrust::tuple t6 + = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5]); + ASSERT_EQ(data[0], thrust::get<0>(t6)); + ASSERT_EQ(data[1], thrust::get<1>(t6)); + ASSERT_EQ(data[2], thrust::get<2>(t6)); + ASSERT_EQ(data[3], thrust::get<3>(t6)); + ASSERT_EQ(data[4], thrust::get<4>(t6)); + ASSERT_EQ(data[5], thrust::get<5>(t6)); + + thrust::tuple t7 + = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6]); + ASSERT_EQ(data[0], thrust::get<0>(t7)); + ASSERT_EQ(data[1], thrust::get<1>(t7)); + ASSERT_EQ(data[2], thrust::get<2>(t7)); + ASSERT_EQ(data[3], thrust::get<3>(t7)); + ASSERT_EQ(data[4], thrust::get<4>(t7)); + ASSERT_EQ(data[5], thrust::get<5>(t7)); + ASSERT_EQ(data[6], thrust::get<6>(t7)); + + thrust::tuple t8 = thrust::make_tuple( + data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); + ASSERT_EQ(data[0], thrust::get<0>(t8)); + ASSERT_EQ(data[1], thrust::get<1>(t8)); + ASSERT_EQ(data[2], thrust::get<2>(t8)); + ASSERT_EQ(data[3], thrust::get<3>(t8)); + ASSERT_EQ(data[4], thrust::get<4>(t8)); + ASSERT_EQ(data[5], thrust::get<5>(t8)); + ASSERT_EQ(data[6], thrust::get<6>(t8)); + ASSERT_EQ(data[7], thrust::get<7>(t8)); + + thrust::tuple t9 = thrust::make_tuple( + data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]); + ASSERT_EQ(data[0], thrust::get<0>(t9)); + ASSERT_EQ(data[1], thrust::get<1>(t9)); + ASSERT_EQ(data[2], thrust::get<2>(t9)); + ASSERT_EQ(data[3], thrust::get<3>(t9)); + ASSERT_EQ(data[4], thrust::get<4>(t9)); + ASSERT_EQ(data[5], thrust::get<5>(t9)); + ASSERT_EQ(data[6], thrust::get<6>(t9)); + ASSERT_EQ(data[7], thrust::get<7>(t9)); + ASSERT_EQ(data[8], thrust::get<8>(t9)); - thrust::host_vector data - = get_random_data(10, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::tuple t1(data[0]); - ASSERT_EQ(data[0], thrust::get<0>(t1)); - - thrust::tuple t2(data[0], data[1]); - ASSERT_EQ(data[0], thrust::get<0>(t2)); - ASSERT_EQ(data[1], thrust::get<1>(t2)); - - thrust::tuple t3 = thrust::make_tuple(data[0], data[1], data[2]); - ASSERT_EQ(data[0], thrust::get<0>(t3)); - ASSERT_EQ(data[1], thrust::get<1>(t3)); - ASSERT_EQ(data[2], thrust::get<2>(t3)); - - thrust::tuple t4 = thrust::make_tuple(data[0], data[1], data[2], data[3]); - ASSERT_EQ(data[0], thrust::get<0>(t4)); - ASSERT_EQ(data[1], thrust::get<1>(t4)); - ASSERT_EQ(data[2], thrust::get<2>(t4)); - ASSERT_EQ(data[3], thrust::get<3>(t4)); - - thrust::tuple t5 - = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4]); - ASSERT_EQ(data[0], thrust::get<0>(t5)); - ASSERT_EQ(data[1], thrust::get<1>(t5)); - ASSERT_EQ(data[2], thrust::get<2>(t5)); - ASSERT_EQ(data[3], thrust::get<3>(t5)); - ASSERT_EQ(data[4], thrust::get<4>(t5)); - - thrust::tuple t6 - = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5]); - ASSERT_EQ(data[0], thrust::get<0>(t6)); - ASSERT_EQ(data[1], thrust::get<1>(t6)); - ASSERT_EQ(data[2], thrust::get<2>(t6)); - ASSERT_EQ(data[3], thrust::get<3>(t6)); - ASSERT_EQ(data[4], thrust::get<4>(t6)); - ASSERT_EQ(data[5], thrust::get<5>(t6)); - - thrust::tuple t7 - = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6]); - ASSERT_EQ(data[0], thrust::get<0>(t7)); - ASSERT_EQ(data[1], thrust::get<1>(t7)); - ASSERT_EQ(data[2], thrust::get<2>(t7)); - ASSERT_EQ(data[3], thrust::get<3>(t7)); - ASSERT_EQ(data[4], thrust::get<4>(t7)); - ASSERT_EQ(data[5], thrust::get<5>(t7)); - ASSERT_EQ(data[6], thrust::get<6>(t7)); - - thrust::tuple t8 = thrust::make_tuple( - data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); - ASSERT_EQ(data[0], thrust::get<0>(t8)); - ASSERT_EQ(data[1], thrust::get<1>(t8)); - ASSERT_EQ(data[2], thrust::get<2>(t8)); - ASSERT_EQ(data[3], thrust::get<3>(t8)); - ASSERT_EQ(data[4], thrust::get<4>(t8)); - ASSERT_EQ(data[5], thrust::get<5>(t8)); - ASSERT_EQ(data[6], thrust::get<6>(t8)); - ASSERT_EQ(data[7], thrust::get<7>(t8)); - - thrust::tuple t9 = thrust::make_tuple( - data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]); - ASSERT_EQ(data[0], thrust::get<0>(t9)); - ASSERT_EQ(data[1], thrust::get<1>(t9)); - ASSERT_EQ(data[2], thrust::get<2>(t9)); - ASSERT_EQ(data[3], thrust::get<3>(t9)); - ASSERT_EQ(data[4], thrust::get<4>(t9)); - ASSERT_EQ(data[5], thrust::get<5>(t9)); - ASSERT_EQ(data[6], thrust::get<6>(t9)); - ASSERT_EQ(data[7], thrust::get<7>(t9)); - ASSERT_EQ(data[8], thrust::get<8>(t9)); - - // TODO: tuple cannot handle 10 element - /*thrust::tuple t10 = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + // TODO: tuple cannot handle 10 element + /*thrust::tuple t10 = thrust::make_tuple(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); ASSERT_EQ(data[0], thrust::get<0>(t10)); ASSERT_EQ(data[1], thrust::get<1>(t10)); ASSERT_EQ(data[2], thrust::get<2>(t10)); @@ -288,6 +311,7 @@ TYPED_TEST(TupleTests, TestTupleGet) ASSERT_EQ(data[7], thrust::get<7>(t10)); ASSERT_EQ(data[8], thrust::get<8>(t10)); ASSERT_EQ(data[9], thrust::get<9>(t10));*/ + } } TYPED_TEST(TupleTests, TestTupleComparison) diff --git a/test/test_tuple_reduce.cpp b/test/test_tuple_reduce.cpp index c429ff142..b7217a13c 100644 --- a/test/test_tuple_reduce.cpp +++ b/test/test_tuple_reduce.cpp @@ -50,30 +50,42 @@ TYPED_TEST(TupleReduceTests, TestTupleReduce) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_t1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_t2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_t1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - // zip up the data - thrust::host_vector> h_tuples(size); - thrust::transform( - h_t1.begin(), h_t1.end(), h_t2.begin(), h_tuples.begin(), MakeTupleFunctor()); + thrust::host_vector h_t2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - // copy to device - thrust::device_vector> d_tuples = h_tuples; + // zip up the data + thrust::host_vector> h_tuples(size); + thrust::transform( + h_t1.begin(), h_t1.end(), h_t2.begin(), h_tuples.begin(), MakeTupleFunctor()); - thrust::tuple zero(0, 0); + // copy to device + thrust::device_vector> d_tuples = h_tuples; - // sum on host - thrust::tuple h_result - = thrust::reduce(h_tuples.begin(), h_tuples.end(), zero, SumTupleFunctor()); + thrust::tuple zero(0, 0); - // sum on device - thrust::tuple d_result - = thrust::reduce(d_tuples.begin(), d_tuples.end(), zero, SumTupleFunctor()); + // sum on host + thrust::tuple h_result + = thrust::reduce(h_tuples.begin(), h_tuples.end(), zero, SumTupleFunctor()); - ASSERT_EQ_QUIET(h_result, d_result); + // sum on device + thrust::tuple d_result + = thrust::reduce(d_tuples.begin(), d_tuples.end(), zero, SumTupleFunctor()); + + ASSERT_EQ_QUIET(h_result, d_result); + } } } diff --git a/test/test_tuple_sort.cpp b/test/test_tuple_sort.cpp index bd24be8df..ded3d4fcf 100644 --- a/test/test_tuple_sort.cpp +++ b/test/test_tuple_sort.cpp @@ -51,40 +51,55 @@ TYPED_TEST(TupleSortTests, TestTupleStableSort) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_values = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - thrust::host_vector> h_tuples(size); - transform( - h_keys.begin(), h_keys.end(), h_values.begin(), h_tuples.begin(), MakeTupleFunctor()); + thrust::host_vector h_values = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - // copy to device - thrust::device_vector> d_tuples = h_tuples; + thrust::host_vector> h_tuples(size); + transform(h_keys.begin(), + h_keys.end(), + h_values.begin(), + h_tuples.begin(), + MakeTupleFunctor()); - // sort on host - thrust::stable_sort(h_tuples.begin(), h_tuples.end()); + // copy to device + thrust::device_vector> d_tuples = h_tuples; - // sort on device - thrust::stable_sort(d_tuples.begin(), d_tuples.end()); + // sort on host + thrust::stable_sort(h_tuples.begin(), h_tuples.end()); - ASSERT_EQ(true, is_sorted(d_tuples.begin(), d_tuples.end())); + // sort on device + thrust::stable_sort(d_tuples.begin(), d_tuples.end()); - // select keys - thrust::transform(h_tuples.begin(), h_tuples.end(), h_keys.begin(), GetFunctor<0>()); + ASSERT_EQ(true, is_sorted(d_tuples.begin(), d_tuples.end())); - thrust::device_vector d_keys(h_keys.size()); - thrust::transform(d_tuples.begin(), d_tuples.end(), d_keys.begin(), GetFunctor<0>()); + // select keys + thrust::transform(h_tuples.begin(), h_tuples.end(), h_keys.begin(), GetFunctor<0>()); - // select values - thrust::transform(h_tuples.begin(), h_tuples.end(), h_values.begin(), GetFunctor<1>()); + thrust::device_vector d_keys(h_keys.size()); + thrust::transform(d_tuples.begin(), d_tuples.end(), d_keys.begin(), GetFunctor<0>()); - thrust::device_vector d_values(h_values.size()); - thrust::transform(d_tuples.begin(), d_tuples.end(), d_values.begin(), GetFunctor<1>()); + // select values + thrust::transform(h_tuples.begin(), h_tuples.end(), h_values.begin(), GetFunctor<1>()); - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_values, d_values); + thrust::device_vector d_values(h_values.size()); + thrust::transform(d_tuples.begin(), d_tuples.end(), d_values.begin(), GetFunctor<1>()); + + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_values, d_values); + } } } diff --git a/test/test_tuple_transform.cpp b/test/test_tuple_transform.cpp index effeeb40f..89acf557f 100644 --- a/test/test_tuple_transform.cpp +++ b/test/test_tuple_transform.cpp @@ -50,31 +50,43 @@ TYPED_TEST(TupleTransformTests, TestTupleTransform) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_t1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_t2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_t1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - // zip up the data - thrust::host_vector> h_tuples(size); - thrust::transform( - h_t1.begin(), h_t1.end(), h_t2.begin(), h_tuples.begin(), MakeTupleFunctor()); + thrust::host_vector h_t2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - // copy to device - thrust::device_vector> d_tuples = h_tuples; + // zip up the data + thrust::host_vector> h_tuples(size); + thrust::transform( + h_t1.begin(), h_t1.end(), h_t2.begin(), h_tuples.begin(), MakeTupleFunctor()); - thrust::device_vector d_t1(size), d_t2(size); + // copy to device + thrust::device_vector> d_tuples = h_tuples; - // select 0th - thrust::transform(d_tuples.begin(), d_tuples.end(), d_t1.begin(), GetFunctor<0>()); + thrust::device_vector d_t1(size), d_t2(size); - // select 1st - thrust::transform(d_tuples.begin(), d_tuples.end(), d_t2.begin(), GetFunctor<1>()); + // select 0th + thrust::transform(d_tuples.begin(), d_tuples.end(), d_t1.begin(), GetFunctor<0>()); - ASSERT_EQ(h_t1, d_t1); - ASSERT_EQ(h_t2, d_t2); + // select 1st + thrust::transform(d_tuples.begin(), d_tuples.end(), d_t2.begin(), GetFunctor<1>()); - ASSERT_EQ_QUIET(h_tuples, d_tuples); + ASSERT_EQ(h_t1, d_t1); + ASSERT_EQ(h_t2, d_t2); + + ASSERT_EQ_QUIET(h_tuples, d_tuples); + } } } diff --git a/test/test_uninitialized_copy.cpp b/test/test_uninitialized_copy.cpp index 11a5d9edb..71925aaf8 100644 --- a/test/test_uninitialized_copy.cpp +++ b/test/test_uninitialized_copy.cpp @@ -27,7 +27,7 @@ TESTS_DEFINE(UninitializedCopyTests, FullTestsParams); template ForwardIterator - uninitialized_copy(my_system& system, InputIterator, InputIterator, ForwardIterator result) +uninitialized_copy(my_system& system, InputIterator, InputIterator, ForwardIterator result) { system.validate_dispatch(); return result; @@ -141,8 +141,7 @@ TYPED_TEST(UninitializedCopyTests, TestUninitializedCopyNSimplePOD) struct CopyConstructTest { - __host__ __device__ - CopyConstructTest(void) + __host__ __device__ CopyConstructTest(void) : copy_constructed_on_host(false) , copy_constructed_on_device(false) { diff --git a/test/test_unique.cpp b/test/test_unique.cpp index 88987fab5..a810d439f 100644 --- a/test/test_unique.cpp +++ b/test/test_unique.cpp @@ -148,23 +148,29 @@ TYPED_TEST(UniqueIntegralTests, TestUnique) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - typename thrust::host_vector::iterator h_new_last; - typename thrust::device_vector::iterator d_new_last; + typename thrust::host_vector::iterator h_new_last; + typename thrust::device_vector::iterator d_new_last; - h_new_last = thrust::unique(h_data.begin(), h_data.end()); - d_new_last = thrust::unique(d_data.begin(), d_data.end()); + h_new_last = thrust::unique(h_data.begin(), h_data.end()); + d_new_last = thrust::unique(d_data.begin(), d_data.end()); - ASSERT_EQ(h_new_last - h_data.begin(), d_new_last - d_data.begin()); + ASSERT_EQ(h_new_last - h_data.begin(), d_new_last - d_data.begin()); - h_data.resize(h_new_last - h_data.begin()); - d_data.resize(d_new_last - d_data.begin()); + h_data.resize(h_new_last - h_data.begin()); + d_data.resize(d_new_last - d_data.begin()); - ASSERT_EQ(h_data, d_data); + ASSERT_EQ(h_data, d_data); + } } } @@ -216,26 +222,32 @@ TYPED_TEST(UniqueIntegralTests, TestUniqueCopy) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - thrust::host_vector h_output(size); - thrust::device_vector d_output(size); + thrust::host_vector h_output(size); + thrust::device_vector d_output(size); - typename thrust::host_vector::iterator h_new_last; - typename thrust::device_vector::iterator d_new_last; + typename thrust::host_vector::iterator h_new_last; + typename thrust::device_vector::iterator d_new_last; - h_new_last = thrust::unique_copy(h_data.begin(), h_data.end(), h_output.begin()); - d_new_last = thrust::unique_copy(d_data.begin(), d_data.end(), d_output.begin()); + h_new_last = thrust::unique_copy(h_data.begin(), h_data.end(), h_output.begin()); + d_new_last = thrust::unique_copy(d_data.begin(), d_data.end(), d_output.begin()); - ASSERT_EQ(h_new_last - h_output.begin(), d_new_last - d_output.begin()); + ASSERT_EQ(h_new_last - h_output.begin(), d_new_last - d_output.begin()); - h_data.resize(h_new_last - h_output.begin()); - d_data.resize(d_new_last - d_output.begin()); + h_data.resize(h_new_last - h_output.begin()); + d_data.resize(d_new_last - d_output.begin()); - ASSERT_EQ(h_output, d_output); + ASSERT_EQ(h_output, d_output); + } } } @@ -246,26 +258,32 @@ TYPED_TEST(UniqueIntegralTests, TestUniqueCopyToDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_data = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::device_vector d_data = h_data; + thrust::host_vector h_data = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::device_vector d_data = h_data; - thrust::host_vector h_unique = h_data; - h_unique.erase(thrust::unique(h_unique.begin(), h_unique.end()), h_unique.end()); + thrust::host_vector h_unique = h_data; + h_unique.erase(thrust::unique(h_unique.begin(), h_unique.end()), h_unique.end()); - thrust::discard_iterator<> reference(h_unique.size()); + thrust::discard_iterator<> reference(h_unique.size()); - typename thrust::host_vector::iterator h_new_last; - typename thrust::device_vector::iterator d_new_last; + typename thrust::host_vector::iterator h_new_last; + typename thrust::device_vector::iterator d_new_last; - thrust::discard_iterator<> h_result - = thrust::unique_copy(h_data.begin(), h_data.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> h_result = thrust::unique_copy( + h_data.begin(), h_data.end(), thrust::make_discard_iterator()); - thrust::discard_iterator<> d_result - = thrust::unique_copy(d_data.begin(), d_data.end(), thrust::make_discard_iterator()); + thrust::discard_iterator<> d_result = thrust::unique_copy( + d_data.begin(), d_data.end(), thrust::make_discard_iterator()); - ASSERT_EQ_QUIET(reference, h_result); - ASSERT_EQ_QUIET(reference, d_result); + ASSERT_EQ_QUIET(reference, h_result); + ASSERT_EQ_QUIET(reference, d_result); + } } } diff --git a/test/test_unique_by_key.cpp b/test/test_unique_by_key.cpp index b7c1238dd..036dfd54e 100644 --- a/test/test_unique_by_key.cpp +++ b/test/test_unique_by_key.cpp @@ -47,10 +47,8 @@ TEST(UniqueByKeyTests, TestUniqueByKeyDispatchExplicit) } template -thrust::pair unique_by_key(my_tag, - ForwardIterator1 keys_first, - ForwardIterator1, - ForwardIterator2 values_first) +thrust::pair +unique_by_key(my_tag, ForwardIterator1 keys_first, ForwardIterator1, ForwardIterator2 values_first) { *keys_first = 13; return thrust::make_pair(keys_first, values_first); @@ -273,40 +271,50 @@ TYPED_TEST(UniqueByKeyIntegralTests, TestUniqueByKey) { SCOPED_TRACE(testing::Message() << "with size = " << size); - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_vals = h_vals; - - using HostKeyIterator = typename thrust::host_vector::iterator; - using HostValIterator = typename thrust::host_vector::iterator; - using DeviceKeyIterator = typename thrust::device_vector::iterator; - using DeviceValIterator = typename thrust::device_vector::iterator; - - using HostIteratorPair = typename thrust::pair; - using DeviceIteratorPair = typename thrust::pair; - - HostIteratorPair h_last - = thrust::unique_by_key(h_keys.begin(), h_keys.end(), h_vals.begin()); - DeviceIteratorPair d_last - = thrust::unique_by_key(d_keys.begin(), d_keys.end(), d_vals.begin()); - - ASSERT_EQ(h_last.first - h_keys.begin(), d_last.first - d_keys.begin()); - ASSERT_EQ(h_last.second - h_vals.begin(), d_last.second - d_vals.begin()); - - size_t N = h_last.first - h_keys.begin(); - - h_keys.resize(N); - h_vals.resize(N); - d_keys.resize(N); - d_vals.resize(N); - - ASSERT_EQ(h_keys, d_keys); - ASSERT_EQ(h_vals, d_vals); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_vals = h_vals; + + using HostKeyIterator = typename thrust::host_vector::iterator; + using HostValIterator = typename thrust::host_vector::iterator; + using DeviceKeyIterator = typename thrust::device_vector::iterator; + using DeviceValIterator = typename thrust::device_vector::iterator; + + using HostIteratorPair = typename thrust::pair; + using DeviceIteratorPair = typename thrust::pair; + + HostIteratorPair h_last + = thrust::unique_by_key(h_keys.begin(), h_keys.end(), h_vals.begin()); + DeviceIteratorPair d_last + = thrust::unique_by_key(d_keys.begin(), d_keys.end(), d_vals.begin()); + + ASSERT_EQ(h_last.first - h_keys.begin(), d_last.first - d_keys.begin()); + ASSERT_EQ(h_last.second - h_vals.begin(), d_last.second - d_vals.begin()); + + size_t N = h_last.first - h_keys.begin(); + + h_keys.resize(N); + h_vals.resize(N); + d_keys.resize(N); + d_vals.resize(N); + + ASSERT_EQ(h_keys, d_keys); + ASSERT_EQ(h_vals, d_vals); + } } } @@ -318,52 +326,61 @@ TYPED_TEST(UniqueByKeyIntegralTests, TestUniqueCopyByKey) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_keys_output(size); - thrust::host_vector h_vals_output(size); - thrust::device_vector d_keys_output(size); - thrust::device_vector d_vals_output(size); - - using HostKeyIterator = typename thrust::host_vector::iterator; - using HostValIterator = typename thrust::host_vector::iterator; - using DeviceKeyIterator = typename thrust::device_vector::iterator; - using DeviceValIterator = typename thrust::device_vector::iterator; - - using HostIteratorPair = typename thrust::pair; - using DeviceIteratorPair = typename thrust::pair; - - HostIteratorPair h_last = thrust::unique_by_key_copy(h_keys.begin(), - h_keys.end(), - h_vals.begin(), - h_keys_output.begin(), - h_vals_output.begin()); - DeviceIteratorPair d_last = thrust::unique_by_key_copy(d_keys.begin(), - d_keys.end(), - d_vals.begin(), - d_keys_output.begin(), - d_vals_output.begin()); - - ASSERT_EQ(h_last.first - h_keys_output.begin(), d_last.first - d_keys_output.begin()); - ASSERT_EQ(h_last.second - h_vals_output.begin(), d_last.second - d_vals_output.begin()); - - size_t N = h_last.first - h_keys_output.begin(); - - h_keys_output.resize(N); - h_vals_output.resize(N); - d_keys_output.resize(N); - d_vals_output.resize(N); - - ASSERT_EQ(h_keys_output, d_keys_output); - ASSERT_EQ(h_vals_output, d_vals_output); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_keys_output(size); + thrust::host_vector h_vals_output(size); + thrust::device_vector d_keys_output(size); + thrust::device_vector d_vals_output(size); + + using HostKeyIterator = typename thrust::host_vector::iterator; + using HostValIterator = typename thrust::host_vector::iterator; + using DeviceKeyIterator = typename thrust::device_vector::iterator; + using DeviceValIterator = typename thrust::device_vector::iterator; + + using HostIteratorPair = typename thrust::pair; + using DeviceIteratorPair = typename thrust::pair; + + HostIteratorPair h_last = thrust::unique_by_key_copy(h_keys.begin(), + h_keys.end(), + h_vals.begin(), + h_keys_output.begin(), + h_vals_output.begin()); + DeviceIteratorPair d_last = thrust::unique_by_key_copy(d_keys.begin(), + d_keys.end(), + d_vals.begin(), + d_keys_output.begin(), + d_vals_output.begin()); + + ASSERT_EQ(h_last.first - h_keys_output.begin(), d_last.first - d_keys_output.begin()); + ASSERT_EQ(h_last.second - h_vals_output.begin(), d_last.second - d_vals_output.begin()); + + size_t N = h_last.first - h_keys_output.begin(); + + h_keys_output.resize(N); + h_vals_output.resize(N); + d_keys_output.resize(N); + d_vals_output.resize(N); + + ASSERT_EQ(h_keys_output, d_keys_output); + ASSERT_EQ(h_vals_output, d_vals_output); + } } } @@ -375,102 +392,111 @@ TYPED_TEST(UniqueByKeyIntegralTests, TestUniqueCopyByKeyToDiscardIterator) for(auto size : get_sizes()) { SCOPED_TRACE(testing::Message() << "with size = " << size); - - thrust::host_vector h_keys = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_vals = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - ; - thrust::device_vector d_keys = h_keys; - thrust::device_vector d_vals = h_vals; - - thrust::host_vector h_vals_output(size); - thrust::device_vector d_vals_output(size); - - thrust::host_vector h_keys_output(size); - thrust::device_vector d_keys_output(size); - - thrust::host_vector h_unique_keys = h_keys; - h_unique_keys.erase(thrust::unique(h_unique_keys.begin(), h_unique_keys.end()), - h_unique_keys.end()); - - size_t num_unique_keys = h_unique_keys.size(); - - // mask both outputs - thrust::pair, thrust::discard_iterator<>> h_result1 - = thrust::unique_by_key_copy(h_keys.begin(), - h_keys.end(), - h_vals.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator()); - - thrust::pair, thrust::discard_iterator<>> d_result1 - = thrust::unique_by_key_copy(d_keys.begin(), - d_keys.end(), - d_vals.begin(), - thrust::make_discard_iterator(), - thrust::make_discard_iterator()); - - thrust::pair, thrust::discard_iterator<>> reference1 - = thrust::make_pair(thrust::make_discard_iterator(num_unique_keys), - thrust::make_discard_iterator(num_unique_keys)); - - ASSERT_EQ_QUIET(reference1, h_result1); - ASSERT_EQ_QUIET(reference1, d_result1); - - // mask values output - thrust::pair::iterator, thrust::discard_iterator<>> - h_result2 = thrust::unique_by_key_copy(h_keys.begin(), - h_keys.end(), - h_vals.begin(), - h_keys_output.begin(), - thrust::make_discard_iterator()); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_result2 = thrust::unique_by_key_copy(d_keys.begin(), - d_keys.end(), - d_vals.begin(), - d_keys_output.begin(), - thrust::make_discard_iterator()); - - thrust::pair::iterator, thrust::discard_iterator<>> - h_reference2 = thrust::make_pair(h_keys_output.begin() + num_unique_keys, - thrust::make_discard_iterator(num_unique_keys)); - - thrust::pair::iterator, thrust::discard_iterator<>> - d_reference2 = thrust::make_pair(d_keys_output.begin() + num_unique_keys, - thrust::make_discard_iterator(num_unique_keys)); - - ASSERT_EQ(h_keys_output, d_keys_output); - ASSERT_EQ_QUIET(h_reference2, h_result2); - ASSERT_EQ_QUIET(d_reference2, d_result2); - - // mask keys output - thrust::pair, typename thrust::host_vector::iterator> - h_result3 = thrust::unique_by_key_copy(h_keys.begin(), - h_keys.end(), - h_vals.begin(), - thrust::make_discard_iterator(), - h_vals_output.begin()); - - thrust::pair, typename thrust::device_vector::iterator> - d_result3 = thrust::unique_by_key_copy(d_keys.begin(), - d_keys.end(), - d_vals.begin(), - thrust::make_discard_iterator(), - d_vals_output.begin()); - - thrust::pair, typename thrust::host_vector::iterator> - h_reference3 = thrust::make_pair(thrust::make_discard_iterator(num_unique_keys), - h_vals_output.begin() + num_unique_keys); - - thrust::pair, typename thrust::device_vector::iterator> - d_reference3 = thrust::make_pair(thrust::make_discard_iterator(num_unique_keys), - d_vals_output.begin() + num_unique_keys); - - ASSERT_EQ(h_vals_output, d_vals_output); - ASSERT_EQ_QUIET(h_reference3, h_result3); - ASSERT_EQ_QUIET(d_reference3, d_result3); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_keys = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_vals = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::device_vector d_keys = h_keys; + thrust::device_vector d_vals = h_vals; + + thrust::host_vector h_vals_output(size); + thrust::device_vector d_vals_output(size); + + thrust::host_vector h_keys_output(size); + thrust::device_vector d_keys_output(size); + + thrust::host_vector h_unique_keys = h_keys; + h_unique_keys.erase(thrust::unique(h_unique_keys.begin(), h_unique_keys.end()), + h_unique_keys.end()); + + size_t num_unique_keys = h_unique_keys.size(); + + // mask both outputs + thrust::pair, thrust::discard_iterator<>> h_result1 + = thrust::unique_by_key_copy(h_keys.begin(), + h_keys.end(), + h_vals.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator()); + + thrust::pair, thrust::discard_iterator<>> d_result1 + = thrust::unique_by_key_copy(d_keys.begin(), + d_keys.end(), + d_vals.begin(), + thrust::make_discard_iterator(), + thrust::make_discard_iterator()); + + thrust::pair, thrust::discard_iterator<>> reference1 + = thrust::make_pair(thrust::make_discard_iterator(num_unique_keys), + thrust::make_discard_iterator(num_unique_keys)); + + ASSERT_EQ_QUIET(reference1, h_result1); + ASSERT_EQ_QUIET(reference1, d_result1); + + // mask values output + thrust::pair::iterator, thrust::discard_iterator<>> + h_result2 = thrust::unique_by_key_copy(h_keys.begin(), + h_keys.end(), + h_vals.begin(), + h_keys_output.begin(), + thrust::make_discard_iterator()); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_result2 = thrust::unique_by_key_copy(d_keys.begin(), + d_keys.end(), + d_vals.begin(), + d_keys_output.begin(), + thrust::make_discard_iterator()); + + thrust::pair::iterator, thrust::discard_iterator<>> + h_reference2 = thrust::make_pair(h_keys_output.begin() + num_unique_keys, + thrust::make_discard_iterator(num_unique_keys)); + + thrust::pair::iterator, thrust::discard_iterator<>> + d_reference2 = thrust::make_pair(d_keys_output.begin() + num_unique_keys, + thrust::make_discard_iterator(num_unique_keys)); + + ASSERT_EQ(h_keys_output, d_keys_output); + ASSERT_EQ_QUIET(h_reference2, h_result2); + ASSERT_EQ_QUIET(d_reference2, d_result2); + + // mask keys output + thrust::pair, typename thrust::host_vector::iterator> + h_result3 = thrust::unique_by_key_copy(h_keys.begin(), + h_keys.end(), + h_vals.begin(), + thrust::make_discard_iterator(), + h_vals_output.begin()); + + thrust::pair, typename thrust::device_vector::iterator> + d_result3 = thrust::unique_by_key_copy(d_keys.begin(), + d_keys.end(), + d_vals.begin(), + thrust::make_discard_iterator(), + d_vals_output.begin()); + + thrust::pair, typename thrust::host_vector::iterator> + h_reference3 = thrust::make_pair(thrust::make_discard_iterator(num_unique_keys), + h_vals_output.begin() + num_unique_keys); + + thrust::pair, typename thrust::device_vector::iterator> + d_reference3 = thrust::make_pair(thrust::make_discard_iterator(num_unique_keys), + d_vals_output.begin() + num_unique_keys); + + ASSERT_EQ(h_vals_output, d_vals_output); + ASSERT_EQ_QUIET(h_reference3, h_result3); + ASSERT_EQ_QUIET(d_reference3, d_result3); + } } } diff --git a/test/test_utils.hpp b/test/test_utils.hpp index 8f7bacb8e..561859e5d 100644 --- a/test/test_utils.hpp +++ b/test/test_utils.hpp @@ -19,6 +19,7 @@ #include #include +#include "test_seed.hpp" #include #include @@ -37,11 +38,12 @@ std::vector get_sizes() } template -inline auto get_random_data(size_t size, T, T) -> +inline auto get_random_data(size_t size, T, T, int seed_value) -> typename std::enable_if::value, thrust::host_vector>::type { std::random_device rd; std::default_random_engine gen(rd()); + gen.seed(seed_value); std::bernoulli_distribution distribution(0.5); thrust::host_vector data(size); std::generate(data.begin(), data.end(), [&]() { return distribution(gen); }); @@ -49,12 +51,13 @@ inline auto get_random_data(size_t size, T, T) -> } template -inline auto get_random_data(size_t size, T min, T max) -> +inline auto get_random_data(size_t size, T min, T max, int seed_value) -> typename std::enable_if::value && !std::is_same::value, thrust::host_vector>::type { std::random_device rd; std::default_random_engine gen(rd()); + gen.seed(seed_value); std::uniform_int_distribution distribution(min, max); thrust::host_vector data(size); std::generate(data.begin(), data.end(), [&]() { return distribution(gen); }); @@ -62,11 +65,12 @@ inline auto get_random_data(size_t size, T min, T max) -> } template -inline auto get_random_data(size_t size, T min, T max) -> +inline auto get_random_data(size_t size, T min, T max, int seed_value) -> typename std::enable_if::value, thrust::host_vector>::type { std::random_device rd; std::default_random_engine gen(rd()); + gen.seed(seed_value); std::uniform_real_distribution distribution(min, max); thrust::host_vector data(size); std::generate(data.begin(), data.end(), [&]() { return distribution(gen); }); diff --git a/test/test_vector_insert.cpp b/test/test_vector_insert.cpp index a0b6663cb..1ba607768 100644 --- a/test/test_vector_insert.cpp +++ b/test/test_vector_insert.cpp @@ -155,31 +155,42 @@ TYPED_TEST(VectorInsertPrimitiveTests, TestVectorRangeInsert) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_src = get_random_data( - size + 3, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::host_vector h_dst = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - thrust::device_vector d_src = h_src; - thrust::device_vector d_dst = h_dst; - - // choose insertion range at random - size_t begin = size > 0 ? (size_t)h_src[size] % size : 0; - size_t end = size > 0 ? (size_t)h_src[size + 1] % size : 0; - if(end < begin) - thrust::swap(begin, end); - - // choose insertion position at random - size_t position = size > 0 ? (size_t)h_src[size + 2] % size : 0; - - // insert on host - h_dst.insert(h_dst.begin() + position, h_src.begin() + begin, h_src.begin() + end); - - // insert on device - d_dst.insert(d_dst.begin() + position, d_src.begin() + begin, d_src.begin() + end); - - ASSERT_EQ(h_dst, d_dst); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_src = get_random_data( + size + 3, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + thrust::host_vector h_dst = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + + thrust::device_vector d_src = h_src; + thrust::device_vector d_dst = h_dst; + + // choose insertion range at random + size_t begin = size > 0 ? (size_t)h_src[size] % size : 0; + size_t end = size > 0 ? (size_t)h_src[size + 1] % size : 0; + if(end < begin) + thrust::swap(begin, end); + + // choose insertion position at random + size_t position = size > 0 ? (size_t)h_src[size + 2] % size : 0; + + // insert on host + h_dst.insert(h_dst.begin() + position, h_src.begin() + begin, h_src.begin() + end); + + // insert on device + d_dst.insert(d_dst.begin() + position, d_src.begin() + begin, d_src.begin() + end); + + ASSERT_EQ(h_dst, d_dst); + } } } @@ -310,23 +321,31 @@ TYPED_TEST(VectorInsertPrimitiveTests, TestVectorFillInsert) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector h_dst = get_random_data( - size + 2, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::device_vector d_dst = h_dst; + thrust::host_vector h_dst = get_random_data( + size + 2, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); - // choose insertion position at random - size_t position = size > 0 ? (size_t)h_dst[size] % size : 0; + thrust::device_vector d_dst = h_dst; - // choose insertion size at random - size_t insertion_size = size > 0 ? (size_t)h_dst[size] % size : 13; + // choose insertion position at random + size_t position = size > 0 ? (size_t)h_dst[size] % size : 0; - // insert on host - h_dst.insert(h_dst.begin() + position, insertion_size, T(13)); + // choose insertion size at random + size_t insertion_size = size > 0 ? (size_t)h_dst[size] % size : 13; - // insert on device - d_dst.insert(d_dst.begin() + position, insertion_size, T(13)); + // insert on host + h_dst.insert(h_dst.begin() + position, insertion_size, T(13)); - ASSERT_EQ(h_dst, d_dst); + // insert on device + d_dst.insert(d_dst.begin() + position, insertion_size, T(13)); + + ASSERT_EQ(h_dst, d_dst); + } } -} \ No newline at end of file +} diff --git a/test/test_vector_manipulation.cpp b/test/test_vector_manipulation.cpp index 987544187..f9f12e53e 100644 --- a/test/test_vector_manipulation.cpp +++ b/test/test_vector_manipulation.cpp @@ -32,76 +32,84 @@ TYPED_TEST(VectorManipulationTests, TestVectorManipulation) const std::vector sizes = get_sizes(); for(auto size : sizes) { - thrust::host_vector src = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - ASSERT_EQ(src.size(), size); - - // basic initialization - Vector test0(size); - Vector test1(size, T(3)); - ASSERT_EQ(test0.size(), size); - ASSERT_EQ(test1.size(), size); - ASSERT_EQ((test1 == std::vector(size, T(3))), true); - - // initializing from other vector - std::vector stl_vector(src.begin(), src.end()); - Vector cpy0 = src; - Vector cpy1(stl_vector); - Vector cpy2(stl_vector.begin(), stl_vector.end()); - - ASSERT_EQ(cpy0, src); - ASSERT_EQ(cpy1, src); - ASSERT_EQ(cpy2, src); - - // resizing - Vector vec1(src); - vec1.resize(size + 3); - ASSERT_EQ(vec1.size(), size + 3); - vec1.resize(size); - ASSERT_EQ(vec1.size(), size); - ASSERT_EQ(vec1, src); - - vec1.resize(size + 20, T(11)); - Vector tail(vec1.begin() + size, vec1.end()); - ASSERT_EQ((tail == std::vector(20, T(11))), true); - - // shrinking a vector should not invalidate iterators - Iterator first = vec1.begin(); - vec1.resize(10); - ASSERT_EQ(first, vec1.begin()); - - vec1.resize(0); - ASSERT_EQ(vec1.size(), 0); - ASSERT_EQ(vec1.empty(), true); - vec1.resize(10); - ASSERT_EQ(vec1.size(), 10); - vec1.clear(); - ASSERT_EQ(vec1.size(), 0); - vec1.resize(5); - ASSERT_EQ(vec1.size(), 5); - - // push_back - Vector vec2; - for(size_t i = 0; i < 10; ++i) + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - ASSERT_EQ(vec2.size(), i); - vec2.push_back((T)i); - ASSERT_EQ(vec2.size(), i + 1); - for(size_t j = 0; j <= i; j++) - ASSERT_EQ(vec2[j], j); - ASSERT_EQ(vec2.back(), i); - } + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - // pop_back - for(size_t i = 10; i > 0; --i) - { - ASSERT_EQ(vec2.size(), i); - ASSERT_EQ(vec2.back(), i - 1); - vec2.pop_back(); - ASSERT_EQ(vec2.size(), i - 1); - for(size_t j = 0; j < i; j++) - ASSERT_EQ(vec2[j], j); + thrust::host_vector src = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + + ASSERT_EQ(src.size(), size); + + // basic initialization + Vector test0(size); + Vector test1(size, T(3)); + ASSERT_EQ(test0.size(), size); + ASSERT_EQ(test1.size(), size); + ASSERT_EQ((test1 == std::vector(size, T(3))), true); + + // initializing from other vector + std::vector stl_vector(src.begin(), src.end()); + Vector cpy0 = src; + Vector cpy1(stl_vector); + Vector cpy2(stl_vector.begin(), stl_vector.end()); + + ASSERT_EQ(cpy0, src); + ASSERT_EQ(cpy1, src); + ASSERT_EQ(cpy2, src); + + // resizing + Vector vec1(src); + vec1.resize(size + 3); + ASSERT_EQ(vec1.size(), size + 3); + vec1.resize(size); + ASSERT_EQ(vec1.size(), size); + ASSERT_EQ(vec1, src); + + vec1.resize(size + 20, T(11)); + Vector tail(vec1.begin() + size, vec1.end()); + ASSERT_EQ((tail == std::vector(20, T(11))), true); + + // shrinking a vector should not invalidate iterators + Iterator first = vec1.begin(); + vec1.resize(10); + ASSERT_EQ(first, vec1.begin()); + + vec1.resize(0); + ASSERT_EQ(vec1.size(), 0); + ASSERT_EQ(vec1.empty(), true); + vec1.resize(10); + ASSERT_EQ(vec1.size(), 10); + vec1.clear(); + ASSERT_EQ(vec1.size(), 0); + vec1.resize(5); + ASSERT_EQ(vec1.size(), 5); + + // push_back + Vector vec2; + for(size_t i = 0; i < 10; ++i) + { + ASSERT_EQ(vec2.size(), i); + vec2.push_back((T)i); + ASSERT_EQ(vec2.size(), i + 1); + for(size_t j = 0; j <= i; j++) + ASSERT_EQ(vec2[j], j); + ASSERT_EQ(vec2.back(), i); + } + + // pop_back + for(size_t i = 10; i > 0; --i) + { + ASSERT_EQ(vec2.size(), i); + ASSERT_EQ(vec2.back(), i - 1); + vec2.pop_back(); + ASSERT_EQ(vec2.size(), i - 1); + for(size_t j = 0; j < i; j++) + ASSERT_EQ(vec2[j], j); + } } } } diff --git a/test/test_zip_iterator.cpp b/test/test_zip_iterator.cpp index 13e162257..b11dc9e21 100644 --- a/test/test_zip_iterator.cpp +++ b/test/test_zip_iterator.cpp @@ -297,7 +297,7 @@ struct SumTwoTuple template __host__ __device__ typename thrust::detail::remove_reference< typename thrust::tuple_element<0, Tuple>::type>::type - operator()(Tuple x) const + operator()(Tuple x) const { return thrust::get<0>(x) + thrust::get<1>(x); } @@ -308,7 +308,7 @@ struct SumThreeTuple template __host__ __device__ typename thrust::detail::remove_reference< typename thrust::tuple_element<0, Tuple>::type>::type - operator()(Tuple x) const + operator()(Tuple x) const { return thrust::get<0>(x) + thrust::get<1>(x) + thrust::get<2>(x); } @@ -322,39 +322,58 @@ TYPED_TEST(ZipIterator32BitTests, TestZipIteratorTransform) for(auto size : sizes) { using namespace thrust; - - host_vector h_data0 = get_random_data(size, 0, 10); - host_vector h_data1 = get_random_data(size, 0, 10); - host_vector h_data2 = get_random_data(size, 0, 10); - - device_vector d_data0 = h_data0; - device_vector d_data1 = h_data1; - device_vector d_data2 = h_data2; - - host_vector h_result(size); - device_vector d_result(size); - - // Tuples with 2 elements - transform(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), - h_result.begin(), - SumTwoTuple()); - transform(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), - d_result.begin(), - SumTwoTuple()); - ASSERT_EQ_QUIET(h_result, d_result); - - // Tuples with 3 elements - transform(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin(), h_data2.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data1.end(), h_data2.end())), - h_result.begin(), - SumThreeTuple()); - transform(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin(), d_data2.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data1.end(), d_data2.end())), - d_result.begin(), - SumThreeTuple()); - ASSERT_EQ_QUIET(h_result, d_result); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + host_vector h_data0 = get_random_data(size, 0, 10, seed_value); + host_vector h_data1 = get_random_data( + size, + 0, + 10, + seed_value + seed_value_addition + ); + host_vector h_data2 = get_random_data( + size, + 0, + 10, + seed_value + 2 * seed_value_addition + ); + + device_vector d_data0 = h_data0; + device_vector d_data1 = h_data1; + device_vector d_data2 = h_data2; + + host_vector h_result(size); + device_vector d_result(size); + + // Tuples with 2 elements + transform(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), + h_result.begin(), + SumTwoTuple()); + transform(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), + d_result.begin(), + SumTwoTuple()); + ASSERT_EQ_QUIET(h_result, d_result); + + // Tuples with 3 elements + transform( + make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin(), h_data2.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data1.end(), h_data2.end())), + h_result.begin(), + SumThreeTuple()); + transform( + make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin(), d_data2.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data1.end(), d_data2.end())), + d_result.begin(), + SumThreeTuple()); + ASSERT_EQ_QUIET(h_result, d_result); + } } } diff --git a/test/test_zip_iterator_reduce.cpp b/test/test_zip_iterator_reduce.cpp index f31e38f31..37e10bc8a 100644 --- a/test/test_zip_iterator_reduce.cpp +++ b/test/test_zip_iterator_reduce.cpp @@ -41,30 +41,41 @@ TYPED_TEST(ZipIteratorReduceTests, TestZipIteratorReduce) for(auto size : sizes) { using namespace thrust; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_data0 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_data1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_data0 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_data1 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - device_vector d_data0 = h_data0; - device_vector d_data1 = h_data1; + device_vector d_data0 = h_data0; + device_vector d_data1 = h_data1; - using Tuple = tuple; + using Tuple = tuple; - // run on host - Tuple h_result = reduce(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), - make_tuple(0, 0), - TuplePlus()); + // run on host + Tuple h_result = reduce(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), + make_tuple(0, 0), + TuplePlus()); - // run on device - Tuple d_result = reduce(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), - make_tuple(0, 0), - TuplePlus()); + // run on device + Tuple d_result = reduce(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), + make_tuple(0, 0), + TuplePlus()); - ASSERT_EQ(get<0>(h_result), get<0>(d_result)); - ASSERT_EQ(get<1>(h_result), get<1>(d_result)); + ASSERT_EQ(get<0>(h_result), get<0>(d_result)); + ASSERT_EQ(get<1>(h_result), get<1>(d_result)); + } } } diff --git a/test/test_zip_iterator_reduce_by_key.cpp b/test/test_zip_iterator_reduce_by_key.cpp index ad9f6dd0e..d6f185c83 100644 --- a/test/test_zip_iterator_reduce_by_key.cpp +++ b/test/test_zip_iterator_reduce_by_key.cpp @@ -51,98 +51,113 @@ TYPED_TEST(ZipIteratorReduceByKeyTests, TestZipIteratorReduceByKey) for(auto size : sizes) { using namespace thrust; - - thrust::host_vector h_data0 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_data1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_data2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - - device_vector d_data0 = h_data0; - device_vector d_data1 = h_data1; - device_vector d_data2 = h_data2; - - typedef tuple Tuple; - - // integer key, tuple value + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) { - host_vector h_data3(size, 0); - host_vector h_data4(size, 0); - host_vector h_data5(size, 0); - device_vector d_data3(size, 0); - device_vector d_data4(size, 0); - device_vector d_data5(size, 0); - - // run on host - reduce_by_key(h_data0.begin(), - h_data0.end(), - make_zip_iterator(make_tuple(h_data1.begin(), h_data2.begin())), - h_data3.begin(), - make_zip_iterator(make_tuple(h_data4.begin(), h_data5.begin())), - equal_to(), - TuplePlus()); - - // run on device - reduce_by_key(d_data0.begin(), - d_data0.end(), - make_zip_iterator(make_tuple(d_data1.begin(), d_data2.begin())), - d_data3.begin(), - make_zip_iterator(make_tuple(d_data4.begin(), d_data5.begin())), - equal_to(), - TuplePlus()); - - ASSERT_EQ(h_data3, d_data3); - ASSERT_EQ(h_data4, d_data4); - ASSERT_EQ(h_data5, d_data5); - } - // The tests below get miscompiled on Tesla hw for 8b types + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); + + thrust::host_vector h_data0 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_data1 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h_data2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + + device_vector d_data0 = h_data0; + device_vector d_data1 = h_data1; + device_vector d_data2 = h_data2; + + typedef tuple Tuple; + + // integer key, tuple value + { + host_vector h_data3(size, 0); + host_vector h_data4(size, 0); + host_vector h_data5(size, 0); + device_vector d_data3(size, 0); + device_vector d_data4(size, 0); + device_vector d_data5(size, 0); + + // run on host + reduce_by_key(h_data0.begin(), + h_data0.end(), + make_zip_iterator(make_tuple(h_data1.begin(), h_data2.begin())), + h_data3.begin(), + make_zip_iterator(make_tuple(h_data4.begin(), h_data5.begin())), + equal_to(), + TuplePlus()); + + // run on device + reduce_by_key(d_data0.begin(), + d_data0.end(), + make_zip_iterator(make_tuple(d_data1.begin(), d_data2.begin())), + d_data3.begin(), + make_zip_iterator(make_tuple(d_data4.begin(), d_data5.begin())), + equal_to(), + TuplePlus()); + + ASSERT_EQ(h_data3, d_data3); + ASSERT_EQ(h_data4, d_data4); + ASSERT_EQ(h_data5, d_data5); + } + // The tests below get miscompiled on Tesla hw for 8b types #if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA - if(const CUDATestDriver* driver - = dynamic_cast(&UnitTestDriver::s_driver())) - { - if(typeid(T) == typeid(unittest::uint8_t) - && driver->current_device_architecture() < 200) + if(const CUDATestDriver* driver + = dynamic_cast(&UnitTestDriver::s_driver())) { - KNOWN_FAILURE; + if(typeid(T) == typeid(unittest::uint8_t) + && driver->current_device_architecture() < 200) + { + KNOWN_FAILURE; + } // end if } // end if - } // end if #endif - // tuple key, tuple value - { - host_vector h_data3(size, 0); - host_vector h_data4(size, 0); - host_vector h_data5(size, 0); - host_vector h_data6(size, 0); - device_vector d_data3(size, 0); - device_vector d_data4(size, 0); - device_vector d_data5(size, 0); - device_vector d_data6(size, 0); - - // run on host - reduce_by_key(make_zip_iterator(make_tuple(h_data0.begin(), h_data0.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data0.end())), - make_zip_iterator(make_tuple(h_data1.begin(), h_data2.begin())), - make_zip_iterator(make_tuple(h_data3.begin(), h_data4.begin())), - make_zip_iterator(make_tuple(h_data5.begin(), h_data6.begin())), - equal_to(), - TuplePlus()); - - // run on device - reduce_by_key(make_zip_iterator(make_tuple(d_data0.begin(), d_data0.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data0.end())), - make_zip_iterator(make_tuple(d_data1.begin(), d_data2.begin())), - make_zip_iterator(make_tuple(d_data3.begin(), d_data4.begin())), - make_zip_iterator(make_tuple(d_data5.begin(), d_data6.begin())), - equal_to(), - TuplePlus()); - - ASSERT_EQ(h_data3, d_data3); - ASSERT_EQ(h_data4, d_data4); - ASSERT_EQ(h_data5, d_data5); - ASSERT_EQ(h_data6, d_data6); + // tuple key, tuple value + { + host_vector h_data3(size, 0); + host_vector h_data4(size, 0); + host_vector h_data5(size, 0); + host_vector h_data6(size, 0); + device_vector d_data3(size, 0); + device_vector d_data4(size, 0); + device_vector d_data5(size, 0); + device_vector d_data6(size, 0); + + // run on host + reduce_by_key(make_zip_iterator(make_tuple(h_data0.begin(), h_data0.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data0.end())), + make_zip_iterator(make_tuple(h_data1.begin(), h_data2.begin())), + make_zip_iterator(make_tuple(h_data3.begin(), h_data4.begin())), + make_zip_iterator(make_tuple(h_data5.begin(), h_data6.begin())), + equal_to(), + TuplePlus()); + + // run on device + reduce_by_key(make_zip_iterator(make_tuple(d_data0.begin(), d_data0.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data0.end())), + make_zip_iterator(make_tuple(d_data1.begin(), d_data2.begin())), + make_zip_iterator(make_tuple(d_data3.begin(), d_data4.begin())), + make_zip_iterator(make_tuple(d_data5.begin(), d_data6.begin())), + equal_to(), + TuplePlus()); + + ASSERT_EQ(h_data3, d_data3); + ASSERT_EQ(h_data4, d_data4); + ASSERT_EQ(h_data5, d_data5); + ASSERT_EQ(h_data6, d_data6); + } } } } diff --git a/test/test_zip_iterator_scan.cpp b/test/test_zip_iterator_scan.cpp index 8cab83e04..bd36a1ee3 100644 --- a/test/test_zip_iterator_scan.cpp +++ b/test/test_zip_iterator_scan.cpp @@ -40,73 +40,84 @@ TYPED_TEST(ZipIteratorScanVariablesTests, TestZipIteratorScan) for(auto size : sizes) { using namespace thrust; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h_data0 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h_data1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h_data0 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h_data1 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - device_vector d_data0 = h_data0; - device_vector d_data1 = h_data1; + device_vector d_data0 = h_data0; + device_vector d_data1 = h_data1; - typedef tuple Tuple; + typedef tuple Tuple; - host_vector h_result(size); - device_vector d_result(size); + host_vector h_result(size); + device_vector d_result(size); - // inclusive_scan (tuple output) - inclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), - h_result.begin(), - TuplePlus()); - inclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), - d_result.begin(), - TuplePlus()); - ASSERT_EQ_QUIET(h_result, d_result); + // inclusive_scan (tuple output) + inclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), + h_result.begin(), + TuplePlus()); + inclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), + d_result.begin(), + TuplePlus()); + ASSERT_EQ_QUIET(h_result, d_result); - // exclusive_scan (tuple output) - exclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), - h_result.begin(), - make_tuple(0, 0), - TuplePlus()); - exclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), - d_result.begin(), - make_tuple(0, 0), - TuplePlus()); - ASSERT_EQ_QUIET(h_result, d_result); + // exclusive_scan (tuple output) + exclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), + h_result.begin(), + make_tuple(0, 0), + TuplePlus()); + exclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), + d_result.begin(), + make_tuple(0, 0), + TuplePlus()); + ASSERT_EQ_QUIET(h_result, d_result); - host_vector h_result0(size); - host_vector h_result1(size); - device_vector d_result0(size); - device_vector d_result1(size); + host_vector h_result0(size); + host_vector h_result1(size); + device_vector d_result0(size); + device_vector d_result1(size); - // inclusive_scan (zip_iterator output) - inclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), - make_zip_iterator(make_tuple(h_result0.begin(), h_result1.begin())), - TuplePlus()); - inclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), - make_zip_iterator(make_tuple(d_result0.begin(), d_result1.begin())), - TuplePlus()); - ASSERT_EQ_QUIET(h_result0, d_result0); - ASSERT_EQ_QUIET(h_result1, d_result1); + // inclusive_scan (zip_iterator output) + inclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), + make_zip_iterator(make_tuple(h_result0.begin(), h_result1.begin())), + TuplePlus()); + inclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), + make_zip_iterator(make_tuple(d_result0.begin(), d_result1.begin())), + TuplePlus()); + ASSERT_EQ_QUIET(h_result0, d_result0); + ASSERT_EQ_QUIET(h_result1, d_result1); - // exclusive_scan (zip_iterator output) - exclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), - make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), - make_zip_iterator(make_tuple(h_result0.begin(), h_result1.begin())), - make_tuple(0, 0), - TuplePlus()); - exclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), - make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), - make_zip_iterator(make_tuple(d_result0.begin(), d_result1.begin())), - make_tuple(0, 0), - TuplePlus()); - ASSERT_EQ_QUIET(h_result0, d_result0); - ASSERT_EQ_QUIET(h_result1, d_result1); + // exclusive_scan (zip_iterator output) + exclusive_scan(make_zip_iterator(make_tuple(h_data0.begin(), h_data1.begin())), + make_zip_iterator(make_tuple(h_data0.end(), h_data1.end())), + make_zip_iterator(make_tuple(h_result0.begin(), h_result1.begin())), + make_tuple(0, 0), + TuplePlus()); + exclusive_scan(make_zip_iterator(make_tuple(d_data0.begin(), d_data1.begin())), + make_zip_iterator(make_tuple(d_data0.end(), d_data1.end())), + make_zip_iterator(make_tuple(d_result0.begin(), d_result1.begin())), + make_tuple(0, 0), + TuplePlus()); + ASSERT_EQ_QUIET(h_result0, d_result0); + ASSERT_EQ_QUIET(h_result1, d_result1); + } } } diff --git a/test/test_zip_iterator_sort.cpp b/test/test_zip_iterator_sort.cpp index 2f470f1fd..0ad952626 100644 --- a/test/test_zip_iterator_sort.cpp +++ b/test/test_zip_iterator_sort.cpp @@ -31,23 +31,35 @@ TYPED_TEST(ZipIteratorStableSortTests, TestZipIteratorStableSort) for(auto size : sizes) { - thrust::host_vector h1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - device_vector d1 = h1; - device_vector d2 = h2; + thrust::host_vector h1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); - // sort on host - stable_sort(make_zip_iterator(make_tuple(h1.begin(), h2.begin())), - make_zip_iterator(make_tuple(h1.end(), h2.end()))); + device_vector d1 = h1; + device_vector d2 = h2; - // sort on device - stable_sort(make_zip_iterator(make_tuple(d1.begin(), d2.begin())), - make_zip_iterator(make_tuple(d1.end(), d2.end()))); + // sort on host + stable_sort(make_zip_iterator(make_tuple(h1.begin(), h2.begin())), + make_zip_iterator(make_tuple(h1.end(), h2.end()))); - ASSERT_EQ_QUIET(h1, d1); - ASSERT_EQ_QUIET(h2, d2); + // sort on device + stable_sort(make_zip_iterator(make_tuple(d1.begin(), d2.begin())), + make_zip_iterator(make_tuple(d1.end(), d2.end()))); + + ASSERT_EQ_QUIET(h1, d1); + ASSERT_EQ_QUIET(h2, d2); + } } } diff --git a/test/test_zip_iterator_sort_by_key.cpp b/test/test_zip_iterator_sort_by_key.cpp index 58b5c897d..ea8bdfda8 100644 --- a/test/test_zip_iterator_sort_by_key.cpp +++ b/test/test_zip_iterator_sort_by_key.cpp @@ -33,51 +33,70 @@ TYPED_TEST(ZipIteratorStableSortByKeyTests, TestZipIteratorStableSort) for(auto size : sizes) { using namespace thrust; + SCOPED_TRACE(testing::Message() << "with size= " << size); + for(size_t seed_index = 0; seed_index < random_seeds_count + seed_size; seed_index++) + { + unsigned int seed_value + = seed_index < random_seeds_count ? rand() : seeds[seed_index - random_seeds_count]; + SCOPED_TRACE(testing::Message() << "with seed= " << seed_value); - thrust::host_vector h1 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h2 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h3 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); - thrust::host_vector h4 = get_random_data( - size, std::numeric_limits::min(), std::numeric_limits::max()); + thrust::host_vector h1 = get_random_data( + size, std::numeric_limits::min(), std::numeric_limits::max(), seed_value); + thrust::host_vector h2 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + seed_value_addition + ); + thrust::host_vector h3 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 2 * seed_value_addition + ); + thrust::host_vector h4 = get_random_data( + size, + std::numeric_limits::min(), + std::numeric_limits::max(), + seed_value + 3 * + seed_value_addition + ); - device_vector d1 = h1; - device_vector d2 = h2; - device_vector d3 = h3; - device_vector d4 = h4; + device_vector d1 = h1; + device_vector d2 = h2; + device_vector d3 = h3; + device_vector d4 = h4; - // sort with (tuple, scalar) - stable_sort_by_key(make_zip_iterator(make_tuple(h1.begin(), h2.begin())), - make_zip_iterator(make_tuple(h1.end(), h2.end())), - h3.begin()); - stable_sort_by_key(make_zip_iterator(make_tuple(d1.begin(), d2.begin())), - make_zip_iterator(make_tuple(d1.end(), d2.end())), - d3.begin()); + // sort with (tuple, scalar) + stable_sort_by_key(make_zip_iterator(make_tuple(h1.begin(), h2.begin())), + make_zip_iterator(make_tuple(h1.end(), h2.end())), + h3.begin()); + stable_sort_by_key(make_zip_iterator(make_tuple(d1.begin(), d2.begin())), + make_zip_iterator(make_tuple(d1.end(), d2.end())), + d3.begin()); - ASSERT_EQ_QUIET(h1, d1); - ASSERT_EQ_QUIET(h2, d2); - ASSERT_EQ_QUIET(h3, d3); - ASSERT_EQ_QUIET(h4, d4); + ASSERT_EQ_QUIET(h1, d1); + ASSERT_EQ_QUIET(h2, d2); + ASSERT_EQ_QUIET(h3, d3); + ASSERT_EQ_QUIET(h4, d4); - // sort with (scalar, tuple) - stable_sort_by_key( - h1.begin(), h1.end(), make_zip_iterator(make_tuple(h3.begin(), h4.begin()))); - stable_sort_by_key( - d1.begin(), d1.end(), make_zip_iterator(make_tuple(d3.begin(), d4.begin()))); + // sort with (scalar, tuple) + stable_sort_by_key( + h1.begin(), h1.end(), make_zip_iterator(make_tuple(h3.begin(), h4.begin()))); + stable_sort_by_key( + d1.begin(), d1.end(), make_zip_iterator(make_tuple(d3.begin(), d4.begin()))); - // sort with (tuple, tuple) - stable_sort_by_key(make_zip_iterator(make_tuple(h1.begin(), h2.begin())), - make_zip_iterator(make_tuple(h1.end(), h2.end())), - make_zip_iterator(make_tuple(h3.begin(), h4.begin()))); - stable_sort_by_key(make_zip_iterator(make_tuple(d1.begin(), d2.begin())), - make_zip_iterator(make_tuple(d1.end(), d2.end())), - make_zip_iterator(make_tuple(d3.begin(), d4.begin()))); + // sort with (tuple, tuple) + stable_sort_by_key(make_zip_iterator(make_tuple(h1.begin(), h2.begin())), + make_zip_iterator(make_tuple(h1.end(), h2.end())), + make_zip_iterator(make_tuple(h3.begin(), h4.begin()))); + stable_sort_by_key(make_zip_iterator(make_tuple(d1.begin(), d2.begin())), + make_zip_iterator(make_tuple(d1.end(), d2.end())), + make_zip_iterator(make_tuple(d3.begin(), d4.begin()))); - ASSERT_EQ_QUIET(h1, d1); - ASSERT_EQ_QUIET(h2, d2); - ASSERT_EQ_QUIET(h3, d3); - ASSERT_EQ_QUIET(h4, d4); + ASSERT_EQ_QUIET(h1, d1); + ASSERT_EQ_QUIET(h2, d2); + ASSERT_EQ_QUIET(h3, d3); + ASSERT_EQ_QUIET(h4, d4); + } } } From c60688fb213fb9cc6b09c65b69569bf92f1e38f5 Mon Sep 17 00:00:00 2001 From: Istvan Kiss Date: Wed, 26 Feb 2020 10:24:16 +0100 Subject: [PATCH 2/2] Update readme --- README.md | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/README.md b/README.md index ce25574ec..5583e3b9f 100644 --- a/README.md +++ b/README.md @@ -90,6 +90,30 @@ ctest ./test/ ``` +## Using custom seeds for the tests + +Go to the `rocPRIM/test/rocprim/test_seed.hpp` file. +```cpp +//(1) +static constexpr int random_seeds_count = 10; + +//(2) +static constexpr unsigned int seeds [] = {0, 2, 10, 1000}; + +//(3) +static constexpr size_t seed_size = sizeof(seeds) / sizeof(seeds[0]); +``` + +(1) defines a constant that sets how many passes over the tests will be done with runtime-generated seeds. Modify at will. + +(2) defines the user generated seeds. Each of the elements of the array will be used as seed for all tests. Modify at will. If no static seeds are desired, the array should be left empty. + +```cpp +static constexpr unsigned int seeds [] = {}; +``` + +(3) this line should never be modified. + ## Documentation Documentation is available [here](https://rocthrust.readthedocs.io/en/latest/).