From 966c2a7bb62a8b5b9ecd349730ffcd3b5719837d Mon Sep 17 00:00:00 2001 From: Eugene Zhulenev Date: Fri, 27 Jul 2018 12:45:17 -0700 Subject: Rename Index to StorageIndex + use Eigen::Array and Eigen::Map when possible --- unsupported/test/cxx11_tensor_block_access.cpp | 292 +++++++++++++++---------- 1 file changed, 182 insertions(+), 110 deletions(-) (limited to 'unsupported/test/cxx11_tensor_block_access.cpp') diff --git a/unsupported/test/cxx11_tensor_block_access.cpp b/unsupported/test/cxx11_tensor_block_access.cpp index 416b686e4..6feeff231 100644 --- a/unsupported/test/cxx11_tensor_block_access.cpp +++ b/unsupported/test/cxx11_tensor_block_access.cpp @@ -37,6 +37,31 @@ static std::size_t RandomTargetSize(const DSizes& dims) { return internal::random(1, dims.TotalSize()); } +template +static DSizes RandomDims() { + array dims; + for (int i = 0; i < NumDims; ++i) { + dims[i] = internal::random(1, 20); + } + return DSizes(dims); +}; + +/** Dummy data type to test TensorBlock copy ops. */ +struct Data { + Data() : Data(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]; @@ -46,6 +71,23 @@ 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) { + std::cout << dims[i] << "; "; + } + std::cout << std::endl; +} + template static void test_block_mapper_sanity() { @@ -96,7 +138,7 @@ static void test_block_mapper_sanity() // index in the visited set. Verify that every coeff accessed only once. template static void UpdateCoeffSet( - const internal::TensorBlock& block, + const internal::TensorBlock& block, Index first_coeff_index, int dim_index, std::set* visited_coeffs) { const DSizes block_sizes = block.block_sizes(); const DSizes tensor_strides = block.tensor_strides(); @@ -114,14 +156,13 @@ static void UpdateCoeffSet( } } -template -static void test_block_mapper_maps_every_element() -{ - using T = int; - using TensorBlock = internal::TensorBlock; - using TensorBlockMapper = internal::TensorBlockMapper; +template +static void test_block_mapper_maps_every_element() { + using TensorBlock = internal::TensorBlock; + using TensorBlockMapper = + internal::TensorBlockMapper; - DSizes dims(5, 7, 11, 17); + DSizes dims = RandomDims(); // Keep track of elements indices available via block access. std::set coeff_set; @@ -131,29 +172,36 @@ static void test_block_mapper_maps_every_element() for (int i = 0; i < block_mapper.total_block_count(); ++i) { TensorBlock block = block_mapper.GetBlockForIndex(i, nullptr); - UpdateCoeffSet(block, block.first_coeff_index(), - choose(Layout, 3, 0), &coeff_set); + UpdateCoeffSet(block, block.first_coeff_index(), + choose(Layout, NumDims - 1, 0), + &coeff_set); } // Verify that every coefficient in the original Tensor is accessible through // TensorBlock only once. - auto total_coeffs = static_cast(dims.TotalSize()); + Index total_coeffs = dims.TotalSize(); VERIFY_IS_EQUAL(coeff_set.size(), total_coeffs); - VERIFY_IS_EQUAL(*coeff_set.begin(), static_cast(0)); - VERIFY_IS_EQUAL(*coeff_set.rbegin(), static_cast(total_coeffs - 1)); + VERIFY_IS_EQUAL(*coeff_set.begin(), 0); + VERIFY_IS_EQUAL(*coeff_set.rbegin(), total_coeffs - 1); } -template -static void test_slice_block_mapper_maps_every_element() -{ - using T = int; - using TensorBlock = internal::TensorBlock; +template +static void test_slice_block_mapper_maps_every_element() { + using TensorBlock = internal::TensorBlock; using TensorSliceBlockMapper = - internal::TensorSliceBlockMapper; + internal::TensorSliceBlockMapper; - DSizes tensor_dims(5,7,11,17); - DSizes tensor_slice_offsets(1,3,5,7); - DSizes tensor_slice_extents(3,2,4,5); + 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; @@ -161,61 +209,59 @@ static void test_slice_block_mapper_maps_every_element() auto 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 < 4; ++i) { + 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()); + DimensionList()); for (int i = 0; i < block_mapper.total_block_count(); ++i) { TensorBlock block = block_mapper.GetBlockForIndex(i, nullptr); - UpdateCoeffSet(block, block.first_coeff_index(), - choose(Layout, 3, 0), &coeff_set); + UpdateCoeffSet(block, block.first_coeff_index(), + choose(Layout, NumDims - 1, 0), + &coeff_set); } VERIFY_IS_EQUAL(coeff_set.size(), total_coeffs); } -template -static void test_block_io_copy_data_from_source_to_target() -{ - using T = float; - - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockMapper TensorBlockMapper; +template +static void test_block_io_copy_data_from_source_to_target() { + typedef internal::TensorBlock TensorBlock; + typedef internal::TensorBlockMapper + TensorBlockMapper; - typedef internal::TensorBlockReader + typedef internal::TensorBlockReader TensorBlockReader; - typedef internal::TensorBlockWriter + typedef internal::TensorBlockWriter TensorBlockWriter; - typedef std::vector> DataVector; - - DSizes input_tensor_dims(5, 7, 11, 17, 3); + DSizes input_tensor_dims = RandomDims(); const auto input_tensor_size = input_tensor_dims.TotalSize(); - DataVector input_data(input_tensor_size, 0); - for (int i = 0; i < input_tensor_size; ++i) { - input_data[i] = internal::random(); - } - DataVector output_data(input_tensor_size, 0); + 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()]; - DataVector block_data(block_mapper.block_dims_total_size(), 0); for (int i = 0; i < block_mapper.total_block_count(); ++i) { - TensorBlock block = block_mapper.GetBlockForIndex(i, block_data.data()); - TensorBlockReader::Run(&block, input_data.data()); - TensorBlockWriter::Run(block, output_data.data()); + 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 @@ -261,31 +307,32 @@ static array ComputeStrides( return strides; } -template +template static void test_block_io_copy_using_reordered_dimensions() { - typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockMapper + typedef internal::TensorBlock TensorBlock; + typedef internal::TensorBlockMapper TensorBlockMapper; - typedef internal::TensorBlockReader + typedef internal::TensorBlockReader TensorBlockReader; - typedef internal::TensorBlockWriter + typedef internal::TensorBlockWriter TensorBlockWriter; - DSizes input_tensor_dims(5, 7, 11, 17, 3); + DSizes input_tensor_dims = RandomDims(); const auto input_tensor_size = input_tensor_dims.TotalSize(); // Create a random input tensor. - auto* input_data = GenerateRandomData(input_tensor_size); + T* input_data = GenerateRandomData(input_tensor_size); // Create a random dimension re-ordering/shuffle. - std::vector shuffle = {0, 1, 2, 3, 4}; + std::vector shuffle; + for (int i = 0; i < NumDims; ++i) shuffle.push_back(i); std::shuffle(shuffle.begin(), shuffle.end(), std::mt19937()); - DSizes output_tensor_dims; - array input_to_output_dim_map; - array output_to_input_dim_map; - for (Index i = 0; i < 5; ++i) { + 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; @@ -295,17 +342,17 @@ static void test_block_io_copy_using_reordered_dimensions() { TensorBlockMapper block_mapper(output_tensor_dims, RandomShape(), RandomTargetSize(input_tensor_dims)); - auto* block_data = new float[block_mapper.block_dims_total_size()]; - auto* output_data = new float[input_tensor_size]; + auto* block_data = new T[block_mapper.block_dims_total_size()]; + auto* output_data = new T[input_tensor_size]; - array input_tensor_strides = - ComputeStrides(input_tensor_dims); - array output_tensor_strides = - ComputeStrides(output_tensor_dims); + 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( + 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, @@ -327,18 +374,21 @@ template static void test_block_io_zero_stride() { typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockReader + typedef internal::TensorBlockReader TensorBlockReader; - typedef internal::TensorBlockWriter + typedef internal::TensorBlockWriter TensorBlockWriter; - DSizes input_tensor_dims(1, 2, 1, 3, 1); - const auto input_tensor_size = input_tensor_dims.TotalSize(); + DSizes rnd_dims = RandomDims<5>(); - // Create a random input tensor. + DSizes input_tensor_dims = rnd_dims; + input_tensor_dims[0] = 1; + input_tensor_dims[2] = 1; + input_tensor_dims[4] = 1; + const auto input_tensor_size = input_tensor_dims.TotalSize(); auto* input_data = GenerateRandomData(input_tensor_size); - DSizes output_tensor_dims(3, 2, 3, 3, 2); + DSizes output_tensor_dims = rnd_dims; DSizes input_tensor_strides( ComputeStrides(input_tensor_dims)); @@ -401,9 +451,9 @@ static void test_block_io_zero_stride() template static void test_block_io_squeeze_ones() { typedef internal::TensorBlock TensorBlock; - typedef internal::TensorBlockReader + typedef internal::TensorBlockReader TensorBlockReader; - typedef internal::TensorBlockWriter + typedef internal::TensorBlockWriter TensorBlockWriter; // Total size > 1. @@ -467,23 +517,23 @@ static void test_block_io_squeeze_ones() { } } -template +template static void test_block_cwise_binary_io_basic() { - typedef internal::scalar_sum_op BinaryFunctor; - typedef internal::TensorBlockCwiseBinaryIO BinaryFunctor; + typedef internal::TensorBlockCwiseBinaryIO TensorBlockCwiseBinaryIO; - DSizes block_sizes(2, 3, 5, 7, 11); - DSizes strides(ComputeStrides(block_sizes)); + DSizes block_sizes = RandomDims(); + DSizes strides(ComputeStrides(block_sizes)); const auto total_size = block_sizes.TotalSize(); // Create a random input tensors. - auto* left_data = GenerateRandomData(total_size); - auto* right_data = GenerateRandomData(total_size); + T* left_data = GenerateRandomData(total_size); + T* right_data = GenerateRandomData(total_size); - auto* output_data = new float[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); @@ -532,13 +582,22 @@ static void test_block_cwise_binary_io_zero_strides() { Layout> TensorBlockCwiseBinaryIO; - DSizes left_sizes(1, 3, 1, 7, 1); + 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(2, 1, 5, 1, 11); + DSizes right_sizes = rnd_dims; + right_sizes[1] = 0; + right_sizes[3] = 0; + DSizes right_strides(ComputeStrides(right_sizes)); right_strides[1] = 0; right_strides[3] = 0; @@ -547,7 +606,7 @@ static void test_block_cwise_binary_io_zero_strides() { auto* left_data = GenerateRandomData(left_sizes.TotalSize()); auto* right_data = GenerateRandomData(right_sizes.TotalSize()); - DSizes output_sizes(2, 3, 5, 7, 11); + DSizes output_sizes = rnd_dims; DSizes output_strides(ComputeStrides(output_sizes)); const auto output_total_size = output_sizes.TotalSize(); @@ -557,11 +616,11 @@ static void test_block_cwise_binary_io_zero_strides() { TensorBlockCwiseBinaryIO::Run(functor, output_sizes, output_strides, output_data, left_strides, left_data, right_strides, right_data); - for (int i = 0; i < 2; ++i) { - for (int j = 0; j < 3; ++j) { - for (int k = 0; k < 5; ++k) { - for (int l = 0; l < 7; ++l) { - for (int m = 0; m < 11; ++m) { + 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]; @@ -893,31 +952,44 @@ static void test_empty_dims(const internal::TensorBlockShapeType block_shape) } } -#define CALL_SUBTEST_LAYOUTS(NAME) \ +#define TEST_LAYOUTS(NAME) \ CALL_SUBTEST(NAME()); \ CALL_SUBTEST(NAME()) -#define CALL_SUBTEST_LAYOUTS_WITH_ARG(NAME, ARG) \ +#define TEST_LAYOUTS_AND_DIMS(TYPE, NAME) \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())); \ + CALL_SUBTEST((NAME())) + +#define TEST_LAYOUTS_WITH_ARG(NAME, ARG) \ CALL_SUBTEST(NAME(ARG)); \ CALL_SUBTEST(NAME(ARG)) EIGEN_DECLARE_TEST(cxx11_tensor_block_access) { - CALL_SUBTEST_LAYOUTS(test_block_mapper_sanity); - CALL_SUBTEST_LAYOUTS(test_block_mapper_maps_every_element); - CALL_SUBTEST_LAYOUTS(test_slice_block_mapper_maps_every_element); - CALL_SUBTEST_LAYOUTS(test_block_io_copy_data_from_source_to_target); - CALL_SUBTEST_LAYOUTS(test_block_io_copy_using_reordered_dimensions); - CALL_SUBTEST_LAYOUTS(test_block_io_zero_stride); - CALL_SUBTEST_LAYOUTS(test_block_io_squeeze_ones); - CALL_SUBTEST_LAYOUTS(test_block_cwise_binary_io_basic); - CALL_SUBTEST_LAYOUTS(test_block_cwise_binary_io_squeeze_ones); - CALL_SUBTEST_LAYOUTS(test_block_cwise_binary_io_zero_strides); - CALL_SUBTEST_LAYOUTS(test_uniform_block_shape); - CALL_SUBTEST_LAYOUTS(test_skewed_inner_dim_block_shape); - - CALL_SUBTEST_LAYOUTS_WITH_ARG(test_empty_dims, TensorBlockShapeType::kUniformAllDims); - CALL_SUBTEST_LAYOUTS_WITH_ARG(test_empty_dims, TensorBlockShapeType::kSkewedInnerDims); + 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_zero_stride); + TEST_LAYOUTS(test_block_io_squeeze_ones); + 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, TensorBlockShapeType::kUniformAllDims); + TEST_LAYOUTS_WITH_ARG(test_empty_dims, TensorBlockShapeType::kSkewedInnerDims); } -#undef CALL_SUBTEST_LAYOUTS -#undef CALL_SUBTEST_LAYOUTS_WITH_ARG \ No newline at end of file +#undef TEST_LAYOUTS +#undef TEST_LAYOUTS_WITH_ARG \ No newline at end of file -- cgit v1.2.3