From 13c3327f5cf829fd9d04a2ab46861e722cd74ca0 Mon Sep 17 00:00:00 2001 From: Eugene Zhulenev Date: Tue, 12 Nov 2019 10:12:28 -0800 Subject: Remove legacy block evaluation support --- unsupported/test/cxx11_tensor_block_access.cpp | 650 ------------------------- unsupported/test/cxx11_tensor_executor.cpp | 212 +++----- 2 files changed, 71 insertions(+), 791 deletions(-) (limited to 'unsupported/test') diff --git a/unsupported/test/cxx11_tensor_block_access.cpp b/unsupported/test/cxx11_tensor_block_access.cpp index 0fb189e09..8d3ca84c8 100644 --- a/unsupported/test/cxx11_tensor_block_access.cpp +++ b/unsupported/test/cxx11_tensor_block_access.cpp @@ -46,22 +46,6 @@ static DSizes RandomDims() { return DSizes(dims); } -/** Dummy data type to test TensorBlock copy ops. */ -struct Data { - Data() : value(0) {} - explicit Data(int v) : value(v) { } - int value; -}; - -bool operator==(const Data& lhs, const Data& rhs) { - return lhs.value == rhs.value; -} - -std::ostream& operator<<(std::ostream& os, const Data& d) { - os << "Data: value=" << d.value; - return os; -} - template static T* GenerateRandomData(const Index& size) { T* data = new T[size]; @@ -71,15 +55,6 @@ static T* GenerateRandomData(const Index& size) { return data; } -template <> -Data* GenerateRandomData(const Index& size) { - Data* data = new Data[size]; - for (int i = 0; i < size; ++i) { - data[i] = Data(internal::random(1, 100)); - } - return data; -} - template static void Debug(DSizes dims) { for (int i = 0; i < NumDims; ++i) { @@ -183,84 +158,6 @@ static void test_block_mapper_maps_every_element() { VERIFY_IS_EQUAL(*coeff_set.rbegin(), total_coeffs - 1); } -template -static void test_slice_block_mapper_maps_every_element() { - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorSliceBlockMapper TensorSliceBlockMapper; - - DSizes tensor_dims = RandomDims(); - DSizes tensor_slice_offsets = RandomDims(); - DSizes tensor_slice_extents = RandomDims(); - - // Make sure that tensor offsets + extents do not overflow. - for (int i = 0; i < NumDims; ++i) { - tensor_slice_offsets[i] = - numext::mini(tensor_dims[i] - 1, tensor_slice_offsets[i]); - tensor_slice_extents[i] = numext::mini( - tensor_slice_extents[i], tensor_dims[i] - tensor_slice_offsets[i]); - } - - // Keep track of elements indices available via block access. - std::set coeff_set; - - int total_coeffs = static_cast(tensor_slice_extents.TotalSize()); - - // Pick a random dimension sizes for the tensor blocks. - DSizes block_sizes; - for (int i = 0; i < NumDims; ++i) { - block_sizes[i] = internal::random(1, tensor_slice_extents[i]); - } - - TensorSliceBlockMapper block_mapper(tensor_dims, tensor_slice_offsets, - tensor_slice_extents, block_sizes, - DimensionList()); - - for (int i = 0; i < block_mapper.total_block_count(); ++i) { - TensorBlock block = block_mapper.GetBlockForIndex(i, NULL); - UpdateCoeffSet(block, block.first_coeff_index(), - choose(Layout, NumDims - 1, 0), - &coeff_set); - } - - VERIFY_IS_EQUAL(Index(coeff_set.size()), total_coeffs); -} - -template -static void test_block_io_copy_data_from_source_to_target() { - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockMapper - TensorBlockMapper; - - typedef internal::TensorBlockReader - TensorBlockReader; - typedef internal::TensorBlockWriter - TensorBlockWriter; - - DSizes input_tensor_dims = RandomDims(); - const Index input_tensor_size = input_tensor_dims.TotalSize(); - - T* input_data = GenerateRandomData(input_tensor_size); - T* output_data = new T[input_tensor_size]; - - TensorBlockMapper block_mapper(input_tensor_dims, RandomShape(), - RandomTargetSize(input_tensor_dims)); - T* block_data = new T[block_mapper.block_dims_total_size()]; - - for (int i = 0; i < block_mapper.total_block_count(); ++i) { - TensorBlock block = block_mapper.GetBlockForIndex(i, block_data); - TensorBlockReader::Run(&block, input_data); - TensorBlockWriter::Run(block, output_data); - } - - for (int i = 0; i < input_tensor_size; ++i) { - VERIFY_IS_EQUAL(input_data[i], output_data[i]); - } - - delete[] input_data; - delete[] output_data; - delete[] block_data; -} - template static Index GetInputIndex(Index output_index, const array& output_to_input_dim_map, @@ -304,179 +201,6 @@ static array ComputeStrides( return strides; } -template -static void test_block_io_copy_using_reordered_dimensions() { - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockMapper - TensorBlockMapper; - - typedef internal::TensorBlockReader - TensorBlockReader; - typedef internal::TensorBlockWriter - TensorBlockWriter; - - DSizes input_tensor_dims = RandomDims(); - const Index input_tensor_size = input_tensor_dims.TotalSize(); - - // Create a random input tensor. - T* input_data = GenerateRandomData(input_tensor_size); - - // Create a random dimension re-ordering/shuffle. - std::vector shuffle; - for (int i = 0; i < NumDims; ++i) shuffle.push_back(i); - std::random_shuffle(shuffle.begin(), shuffle.end()); - - DSizes output_tensor_dims; - array input_to_output_dim_map; - array output_to_input_dim_map; - for (Index i = 0; i < NumDims; ++i) { - output_tensor_dims[shuffle[i]] = input_tensor_dims[i]; - input_to_output_dim_map[i] = shuffle[i]; - output_to_input_dim_map[shuffle[i]] = i; - } - - // Random block shape and size. - TensorBlockMapper block_mapper(output_tensor_dims, RandomShape(), - RandomTargetSize(input_tensor_dims)); - - T* block_data = new T[block_mapper.block_dims_total_size()]; - T* output_data = new T[input_tensor_size]; - - array input_tensor_strides = - ComputeStrides(input_tensor_dims); - array output_tensor_strides = - ComputeStrides(output_tensor_dims); - - for (Index i = 0; i < block_mapper.total_block_count(); ++i) { - TensorBlock block = block_mapper.GetBlockForIndex(i, block_data); - const Index first_coeff_index = GetInputIndex( - block.first_coeff_index(), output_to_input_dim_map, - input_tensor_strides, output_tensor_strides); - TensorBlockReader::Run(&block, first_coeff_index, input_to_output_dim_map, - input_tensor_strides, input_data); - TensorBlockWriter::Run(block, first_coeff_index, input_to_output_dim_map, - input_tensor_strides, output_data); - } - - for (int i = 0; i < input_tensor_size; ++i) { - VERIFY_IS_EQUAL(input_data[i], output_data[i]); - } - - delete[] input_data; - delete[] block_data; - delete[] output_data; -} - -// This is the special case for reading data with reordering, when dimensions -// before/after reordering are the same. Squeezing reads along inner dimensions -// in this case is illegal, because we reorder innermost dimension. -template -static void test_block_io_copy_using_reordered_dimensions_do_not_squeeze() -{ - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockReader - TensorBlockReader; - - DSizes tensor_dims; - tensor_dims[0] = 7; - tensor_dims[1] = 9; - tensor_dims[2] = 7; - - DSizes block_dims = tensor_dims; - - DSizes tensor_to_block_dim_map; - tensor_to_block_dim_map[0] = 2; - tensor_to_block_dim_map[1] = 1; - tensor_to_block_dim_map[2] = 0; - - DSizes tensor_strides(ComputeStrides(tensor_dims)); - DSizes block_strides(ComputeStrides(block_dims)); - - const Index tensor_size = tensor_dims.TotalSize(); - float* tensor_data = GenerateRandomData(tensor_size); - float* block_data = new float[tensor_size]; - - TensorBlock block(0, block_dims, block_strides, tensor_strides, block_data); - TensorBlockReader::Run(&block, - 0, - tensor_to_block_dim_map, - tensor_strides, - tensor_data); - - TensorMap > block_tensor(block_data, block_dims); - TensorMap > tensor_tensor(tensor_data, tensor_dims); - - for (Index d0 = 0; d0 < tensor_dims[0]; ++d0) { - for (Index d1 = 0; d1 < tensor_dims[1]; ++d1) { - for (Index d2 = 0; d2 < tensor_dims[2]; ++d2) { - float block_value = block_tensor(d2, d1, d0); - float tensor_value = tensor_tensor(d0, d1, d2); - VERIFY_IS_EQUAL(block_value, tensor_value); - } - } - } - - delete[] block_data; - delete[] tensor_data; -} - -// This is the special case for reading data with reordering, when dimensions -// before/after reordering are the same. Squeezing reads in this case is allowed -// because we reorder outer dimensions. -template -static void test_block_io_copy_using_reordered_dimensions_squeeze() -{ - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockReader - TensorBlockReader; - - DSizes tensor_dims; - tensor_dims[0] = 7; - tensor_dims[1] = 5; - tensor_dims[2] = 9; - tensor_dims[3] = 9; - - DSizes block_dims = tensor_dims; - - DSizes tensor_to_block_dim_map; - tensor_to_block_dim_map[0] = 0; - tensor_to_block_dim_map[1] = 1; - tensor_to_block_dim_map[2] = 3; - tensor_to_block_dim_map[3] = 2; - - DSizes tensor_strides(ComputeStrides(tensor_dims)); - DSizes block_strides(ComputeStrides(block_dims)); - - const Index tensor_size = tensor_dims.TotalSize(); - float* tensor_data = GenerateRandomData(tensor_size); - float* block_data = new float[tensor_size]; - - TensorBlock block(0, block_dims, block_strides, tensor_strides, block_data); - TensorBlockReader::Run(&block, - 0, - tensor_to_block_dim_map, - tensor_strides, - tensor_data); - - TensorMap > block_tensor(block_data, block_dims); - TensorMap > tensor_tensor(tensor_data, tensor_dims); - - for (Index d0 = 0; d0 < tensor_dims[0]; ++d0) { - for (Index d1 = 0; d1 < tensor_dims[1]; ++d1) { - for (Index d2 = 0; d2 < tensor_dims[2]; ++d2) { - for (Index d3 = 0; d3 < tensor_dims[3]; ++d3) { - float block_value = block_tensor(d0, d1, d3, d2); - float tensor_value = tensor_tensor(d0, d1, d2, d3); - VERIFY_IS_EQUAL(block_value, tensor_value); - } - } - } - } - - delete[] block_data; - delete[] tensor_data; -} - template class EqualityChecker { @@ -510,365 +234,6 @@ public: } }; -template -static void test_block_io_zero_stride() -{ - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockReader - TensorBlockReader; - typedef internal::TensorBlockWriter - TensorBlockWriter; - - DSizes rnd_dims = RandomDims<5>(); - - DSizes input_tensor_dims = rnd_dims; - input_tensor_dims[0] = 1; - input_tensor_dims[2] = 1; - input_tensor_dims[4] = 1; - const Index input_tensor_size = input_tensor_dims.TotalSize(); - float* input_data = GenerateRandomData(input_tensor_size); - - DSizes output_tensor_dims = rnd_dims; - - DSizes input_tensor_strides( - ComputeStrides(input_tensor_dims)); - DSizes output_tensor_strides( - ComputeStrides(output_tensor_dims)); - - DSizes input_tensor_strides_with_zeros(input_tensor_strides); - input_tensor_strides_with_zeros[0] = 0; - input_tensor_strides_with_zeros[2] = 0; - input_tensor_strides_with_zeros[4] = 0; - - // Verify that data was correctly read/written from/into the block. - const EqualityChecker verify_is_equal(input_data, input_tensor_dims, input_tensor_strides, output_tensor_dims, output_tensor_strides); - - { - float* output_data = new float[output_tensor_dims.TotalSize()]; - TensorBlock read_block(0, output_tensor_dims, output_tensor_strides, - input_tensor_strides_with_zeros, output_data); - TensorBlockReader::Run(&read_block, input_data); - verify_is_equal(output_data); - delete[] output_data; - } - - { - float* output_data = new float[output_tensor_dims.TotalSize()]; - TensorBlock write_block(0, output_tensor_dims, - input_tensor_strides_with_zeros, - output_tensor_strides, input_data); - TensorBlockWriter::Run(write_block, output_data); - verify_is_equal(output_data); - delete[] output_data; - } - - delete[] input_data; -} - -template -static void test_block_io_squeeze_ones() { - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockReader - TensorBlockReader; - typedef internal::TensorBlockWriter - TensorBlockWriter; - - // Total size > 1. - { - DSizes block_sizes(1, 2, 1, 2, 1); - const Index total_size = block_sizes.TotalSize(); - - // Create a random input tensor. - float* input_data = GenerateRandomData(total_size); - DSizes strides(ComputeStrides(block_sizes)); - - { - float* output_data = new float[block_sizes.TotalSize()]; - TensorBlock read_block(0, block_sizes, strides, strides, output_data); - TensorBlockReader::Run(&read_block, input_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], input_data[i]); - } - delete[] output_data; - } - - { - float* output_data = new float[block_sizes.TotalSize()]; - TensorBlock write_block(0, block_sizes, strides, strides, input_data); - TensorBlockWriter::Run(write_block, output_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], input_data[i]); - } - delete[] output_data; - } - } - - // Total size == 1. - { - DSizes block_sizes(1, 1, 1, 1, 1); - const Index total_size = block_sizes.TotalSize(); - - // Create a random input tensor. - float* input_data = GenerateRandomData(total_size); - DSizes strides(ComputeStrides(block_sizes)); - - { - float* output_data = new float[block_sizes.TotalSize()]; - TensorBlock read_block(0, block_sizes, strides, strides, output_data); - TensorBlockReader::Run(&read_block, input_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], input_data[i]); - } - delete[] output_data; - } - - { - float* output_data = new float[block_sizes.TotalSize()]; - TensorBlock write_block(0, block_sizes, strides, strides, input_data); - TensorBlockWriter::Run(write_block, output_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], input_data[i]); - } - delete[] output_data; - } - } -} - -template -static void test_block_cwise_unary_io_basic() { - typedef internal::scalar_square_op UnaryFunctor; - typedef internal::TensorBlockCwiseUnaryIO - TensorBlockCwiseUnaryIO; - - DSizes block_sizes = RandomDims(); - DSizes strides(ComputeStrides(block_sizes)); - - const Index total_size = block_sizes.TotalSize(); - - // Create a random input tensors. - T* input_data = GenerateRandomData(total_size); - - T* output_data = new T[total_size]; - UnaryFunctor functor; - TensorBlockCwiseUnaryIO::Run(functor, block_sizes, strides, output_data, - strides, input_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], functor(input_data[i])); - } - - delete[] input_data; - delete[] output_data; -} - -template -static void test_block_cwise_unary_io_squeeze_ones() { - typedef internal::scalar_square_op UnaryFunctor; - typedef internal::TensorBlockCwiseUnaryIO - TensorBlockCwiseUnaryIO; - - DSizes block_sizes(1, 2, 1, 3, 1); - DSizes strides(ComputeStrides(block_sizes)); - - const Index total_size = block_sizes.TotalSize(); - - // Create a random input tensors. - float* input_data = GenerateRandomData(total_size); - - float* output_data = new float[total_size]; - UnaryFunctor functor; - TensorBlockCwiseUnaryIO::Run(functor, block_sizes, strides, output_data, - strides, input_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], functor(input_data[i])); - } - - delete[] input_data; - delete[] output_data; -} - -template -static void test_block_cwise_unary_io_zero_strides() { - typedef internal::scalar_square_op UnaryFunctor; - typedef internal::TensorBlockCwiseUnaryIO - TensorBlockCwiseUnaryIO; - - DSizes rnd_dims = RandomDims<5>(); - - DSizes input_sizes = rnd_dims; - input_sizes[0] = 1; - input_sizes[2] = 1; - input_sizes[4] = 1; - - DSizes input_strides(ComputeStrides(input_sizes)); - input_strides[0] = 0; - input_strides[2] = 0; - input_strides[4] = 0; - - // Generate random data. - float* input_data = GenerateRandomData(input_sizes.TotalSize()); - - DSizes output_sizes = rnd_dims; - DSizes output_strides(ComputeStrides(output_sizes)); - - const Index output_total_size = output_sizes.TotalSize(); - float* output_data = new float[output_total_size]; - - UnaryFunctor functor; - TensorBlockCwiseUnaryIO::Run(functor, output_sizes, output_strides, - output_data, input_strides, input_data); - for (int i = 0; i < rnd_dims[0]; ++i) { - for (int j = 0; j < rnd_dims[1]; ++j) { - for (int k = 0; k < rnd_dims[2]; ++k) { - for (int l = 0; l < rnd_dims[3]; ++l) { - for (int m = 0; m < rnd_dims[4]; ++m) { - Index output_index = i * output_strides[0] + j * output_strides[1] + - k * output_strides[2] + l * output_strides[3] + - m * output_strides[4]; - Index input_index = i * input_strides[0] + j * input_strides[1] + - k * input_strides[2] + l * input_strides[3] + - m * input_strides[4]; - VERIFY_IS_EQUAL(output_data[output_index], - functor(input_data[input_index])); - } - } - } - } - } - - delete[] input_data; - delete[] output_data; -} - -template -static void test_block_cwise_binary_io_basic() { - typedef internal::scalar_sum_op BinaryFunctor; - typedef internal::TensorBlockCwiseBinaryIO - TensorBlockCwiseBinaryIO; - - DSizes block_sizes = RandomDims(); - DSizes strides(ComputeStrides(block_sizes)); - - const Index total_size = block_sizes.TotalSize(); - - // Create a random input tensors. - T* left_data = GenerateRandomData(total_size); - T* right_data = GenerateRandomData(total_size); - - T* output_data = new T[total_size]; - BinaryFunctor functor; - TensorBlockCwiseBinaryIO::Run(functor, block_sizes, strides, output_data, - strides, left_data, strides, right_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], functor(left_data[i], right_data[i])); - } - - delete[] left_data; - delete[] right_data; - delete[] output_data; -} - -template -static void test_block_cwise_binary_io_squeeze_ones() { - typedef internal::scalar_sum_op BinaryFunctor; - typedef internal::TensorBlockCwiseBinaryIO - TensorBlockCwiseBinaryIO; - - DSizes block_sizes(1, 2, 1, 3, 1); - DSizes strides(ComputeStrides(block_sizes)); - - const Index total_size = block_sizes.TotalSize(); - - // Create a random input tensors. - float* left_data = GenerateRandomData(total_size); - float* right_data = GenerateRandomData(total_size); - - float* output_data = new float[total_size]; - BinaryFunctor functor; - TensorBlockCwiseBinaryIO::Run(functor, block_sizes, strides, output_data, - strides, left_data, strides, right_data); - for (int i = 0; i < total_size; ++i) { - VERIFY_IS_EQUAL(output_data[i], functor(left_data[i], right_data[i])); - } - - delete[] left_data; - delete[] right_data; - delete[] output_data; -} - -template -static void test_block_cwise_binary_io_zero_strides() { - typedef internal::scalar_sum_op BinaryFunctor; - typedef internal::TensorBlockCwiseBinaryIO - TensorBlockCwiseBinaryIO; - - DSizes rnd_dims = RandomDims<5>(); - - DSizes left_sizes = rnd_dims; - left_sizes[0] = 1; - left_sizes[2] = 1; - left_sizes[4] = 1; - - DSizes left_strides(ComputeStrides(left_sizes)); - left_strides[0] = 0; - left_strides[2] = 0; - left_strides[4] = 0; - - DSizes right_sizes = rnd_dims; - right_sizes[1] = 1; - right_sizes[3] = 1; - - DSizes right_strides(ComputeStrides(right_sizes)); - right_strides[1] = 0; - right_strides[3] = 0; - - // Generate random data. - float* left_data = GenerateRandomData(left_sizes.TotalSize()); - float* right_data = GenerateRandomData(right_sizes.TotalSize()); - - DSizes output_sizes = rnd_dims; - DSizes output_strides(ComputeStrides(output_sizes)); - - const Index output_total_size = output_sizes.TotalSize(); - float* output_data = new float[output_total_size]; - - BinaryFunctor functor; - TensorBlockCwiseBinaryIO::Run(functor, output_sizes, output_strides, - output_data, left_strides, left_data, - right_strides, right_data); - for (int i = 0; i < rnd_dims[0]; ++i) { - for (int j = 0; j < rnd_dims[1]; ++j) { - for (int k = 0; k < rnd_dims[2]; ++k) { - for (int l = 0; l < rnd_dims[3]; ++l) { - for (int m = 0; m < rnd_dims[4]; ++m) { - Index output_index = i * output_strides[0] + j * output_strides[1] + - k * output_strides[2] + l * output_strides[3] + - m * output_strides[4]; - Index left_index = i * left_strides[0] + j * left_strides[1] + - k * left_strides[2] + l * left_strides[3] + - m * left_strides[4]; - Index right_index = i * right_strides[0] + j * right_strides[1] + - k * right_strides[2] + l * right_strides[3] + - m * right_strides[4]; - VERIFY_IS_EQUAL( - output_data[output_index], - functor(left_data[left_index], right_data[right_index])); - } - } - } - } - } - - delete[] left_data; - delete[] right_data; - delete[] output_data; -} - template static void test_uniform_block_shape() { @@ -1196,21 +561,6 @@ static void test_empty_dims(const internal::TensorBlockShapeType block_shape) EIGEN_DECLARE_TEST(cxx11_tensor_block_access) { TEST_LAYOUTS(test_block_mapper_sanity); TEST_LAYOUTS_AND_DIMS(float, test_block_mapper_maps_every_element); - TEST_LAYOUTS_AND_DIMS(float, test_slice_block_mapper_maps_every_element); - TEST_LAYOUTS_AND_DIMS(float, test_block_io_copy_data_from_source_to_target); - TEST_LAYOUTS_AND_DIMS(Data, test_block_io_copy_data_from_source_to_target); - TEST_LAYOUTS_AND_DIMS(float, test_block_io_copy_using_reordered_dimensions); - TEST_LAYOUTS_AND_DIMS(Data, test_block_io_copy_using_reordered_dimensions); - TEST_LAYOUTS(test_block_io_copy_using_reordered_dimensions_do_not_squeeze); - TEST_LAYOUTS(test_block_io_copy_using_reordered_dimensions_squeeze); - TEST_LAYOUTS(test_block_io_zero_stride); - TEST_LAYOUTS(test_block_io_squeeze_ones); - TEST_LAYOUTS_AND_DIMS(float, test_block_cwise_unary_io_basic); - TEST_LAYOUTS(test_block_cwise_unary_io_squeeze_ones); - TEST_LAYOUTS(test_block_cwise_unary_io_zero_strides); - TEST_LAYOUTS_AND_DIMS(float, test_block_cwise_binary_io_basic); - TEST_LAYOUTS(test_block_cwise_binary_io_squeeze_ones); - TEST_LAYOUTS(test_block_cwise_binary_io_zero_strides); TEST_LAYOUTS(test_uniform_block_shape); TEST_LAYOUTS(test_skewed_inner_dim_block_shape); TEST_LAYOUTS_WITH_ARG(test_empty_dims, internal::kUniformAllDims); diff --git a/unsupported/test/cxx11_tensor_executor.cpp b/unsupported/test/cxx11_tensor_executor.cpp index 0e70e1770..66b06e8ee 100644 --- a/unsupported/test/cxx11_tensor_executor.cpp +++ b/unsupported/test/cxx11_tensor_executor.cpp @@ -310,48 +310,6 @@ static void test_execute_shuffle_lvalue(Device d) } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims)); } -template -static void test_execute_reduction(Device d) -{ - static_assert(NumDims >= 2, "NumDims must be greater or equal than 2"); - - static constexpr int ReducedDims = NumDims - 2; - static constexpr int Options = 0 | Layout; - - auto dims = RandomDims(5, 10); - Tensor src(dims); - src.setRandom(); - - // Pick two random and unique reduction dimensions. - int reduction0 = internal::random(0, NumDims - 1); - int reduction1 = internal::random(0, NumDims - 1); - while (reduction0 == reduction1) { - reduction1 = internal::random(0, NumDims - 1); - } - - DSizes reduction_axis; - reduction_axis[0] = reduction0; - reduction_axis[1] = reduction1; - - Tensor golden = src.sum(reduction_axis); - - // Now do the reduction using configured tensor executor. - Tensor dst(golden.dimensions()); - - auto expr = src.sum(reduction_axis); - - using Assign = TensorAssignOp; - using Executor = - internal::TensorExecutor; - - Executor::run(Assign(dst, expr), d); - - for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) { - VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i)); - } -} - template static void test_execute_reshape(Device d) @@ -663,57 +621,34 @@ static void test_async_execute_binary_expr(Device d) #define CALL_SUBTEST_PART(PART) \ CALL_SUBTEST_##PART -#define CALL_SUBTEST_COMBINATIONS_V1(PART, NAME, T, NUM_DIMS) \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))) - - // NOTE: Tiling V2 currently implemented for a limited types of expression, and only with default device. -#define CALL_SUBTEST_COMBINATIONS_V2(PART, NAME, T, NUM_DIMS) \ +#define CALL_SUBTEST_COMBINATIONS(PART, NAME, T, NUM_DIMS) \ CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ + CALL_SUBTEST_PART(PART)((NAME(default_device))); \ CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ + CALL_SUBTEST_PART(PART)((NAME(default_device))); \ CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ + CALL_SUBTEST_PART(PART)((NAME(default_device))); \ CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ - CALL_SUBTEST_PART(PART)((NAME(default_device))); \ + CALL_SUBTEST_PART(PART)((NAME(default_device))); \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ + CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ + CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ + CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))) + CALL_SUBTEST_PART(PART)((NAME(tp_device))) // NOTE: Currently only ThreadPoolDevice supports async expression evaluation. #define CALL_ASYNC_SUBTEST_COMBINATIONS(PART, NAME, T, NUM_DIMS) \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ + CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ + CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ + CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ CALL_SUBTEST_PART(PART)((NAME(tp_device))); \ - CALL_SUBTEST_PART(PART)((NAME(tp_device))) + CALL_SUBTEST_PART(PART)((NAME(tp_device))) EIGEN_DECLARE_TEST(cxx11_tensor_executor) { Eigen::DefaultDevice default_device; @@ -724,69 +659,64 @@ EIGEN_DECLARE_TEST(cxx11_tensor_executor) { Eigen::ThreadPool tp(num_threads); Eigen::ThreadPoolDevice tp_device(&tp, num_threads); - CALL_SUBTEST_COMBINATIONS_V2(1, test_execute_unary_expr, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(1, test_execute_unary_expr, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(1, test_execute_unary_expr, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(2, test_execute_binary_expr, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(2, test_execute_binary_expr, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(2, test_execute_binary_expr, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(3, test_execute_broadcasting, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(3, test_execute_broadcasting, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(3, test_execute_broadcasting, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(4, test_execute_chipping_rvalue, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(4, test_execute_chipping_rvalue, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(4, test_execute_chipping_rvalue, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(5, test_execute_chipping_lvalue, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(5, test_execute_chipping_lvalue, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(5, test_execute_chipping_lvalue, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(6, test_execute_shuffle_rvalue, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(6, test_execute_shuffle_rvalue, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(6, test_execute_shuffle_rvalue, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(7, test_execute_shuffle_lvalue, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(7, test_execute_shuffle_lvalue, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(7, test_execute_shuffle_lvalue, float, 5); - - CALL_SUBTEST_COMBINATIONS_V1(8, test_execute_reduction, float, 2); - CALL_SUBTEST_COMBINATIONS_V1(8, test_execute_reduction, float, 3); - CALL_SUBTEST_COMBINATIONS_V1(8, test_execute_reduction, float, 4); - CALL_SUBTEST_COMBINATIONS_V1(8, test_execute_reduction, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(9, test_execute_reshape, float, 2); - CALL_SUBTEST_COMBINATIONS_V2(9, test_execute_reshape, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(9, test_execute_reshape, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(9, test_execute_reshape, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(10, test_execute_slice_rvalue, float, 2); - CALL_SUBTEST_COMBINATIONS_V2(10, test_execute_slice_rvalue, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(10, test_execute_slice_rvalue, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(10, test_execute_slice_rvalue, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(11, test_execute_slice_lvalue, float, 2); - CALL_SUBTEST_COMBINATIONS_V2(11, test_execute_slice_lvalue, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(11, test_execute_slice_lvalue, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(11, test_execute_slice_lvalue, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(12, test_execute_broadcasting_of_forced_eval, float, 2); - CALL_SUBTEST_COMBINATIONS_V2(12, test_execute_broadcasting_of_forced_eval, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(12, test_execute_broadcasting_of_forced_eval, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(12, test_execute_broadcasting_of_forced_eval, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(13, test_execute_generator_op, float, 2); - CALL_SUBTEST_COMBINATIONS_V2(13, test_execute_generator_op, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(13, test_execute_generator_op, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(13, test_execute_generator_op, float, 5); - - CALL_SUBTEST_COMBINATIONS_V2(14, test_execute_reverse_rvalue, float, 1); - CALL_SUBTEST_COMBINATIONS_V2(14, test_execute_reverse_rvalue, float, 2); - CALL_SUBTEST_COMBINATIONS_V2(14, test_execute_reverse_rvalue, float, 3); - CALL_SUBTEST_COMBINATIONS_V2(14, test_execute_reverse_rvalue, float, 4); - CALL_SUBTEST_COMBINATIONS_V2(14, test_execute_reverse_rvalue, float, 5); + CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 3); + CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 4); + CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 5); + + CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 3); + CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 4); + CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 5); + + CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 3); + CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 4); + CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 5); + + CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 3); + CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 4); + CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 5); + + CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 3); + CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 4); + CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 5); + + CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 3); + CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 4); + CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 5); + + CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 3); + CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 4); + CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 5); + + CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 2); + CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 3); + CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 4); + CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 5); + + CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 2); + CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 3); + CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 4); + CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 5); + + CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 2); + CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 3); + CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 4); + CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 5); + + CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 2); + CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 3); + CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 4); + CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 5); + + CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 2); + CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 3); + CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 4); + CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 5); + + CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 1); + CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 2); + CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 3); + CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 4); + CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 5); CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 3); CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 4); -- cgit v1.2.3