mirror of
https://gitlab.com/libeigen/eigen.git
synced 2026-04-10 11:34:33 +08:00
Remove legacy block evaluation support
This commit is contained in:
Eugene Zhulenev
@@ -46,22 +46,6 @@ static DSizes<Index, NumDims> RandomDims() {
|
||||
return DSizes<Index, NumDims>(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 <typename T>
|
||||
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<int>(1, 100));
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
template <int NumDims>
|
||||
static void Debug(DSizes<Index, NumDims> 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 <typename T, int NumDims, int Layout>
|
||||
static void test_slice_block_mapper_maps_every_element() {
|
||||
typedef internal::TensorBlock<T, Index, NumDims, Layout> TensorBlock;
|
||||
typedef internal::TensorSliceBlockMapper<T, Index, NumDims, Layout> TensorSliceBlockMapper;
|
||||
|
||||
DSizes<Index, NumDims> tensor_dims = RandomDims<NumDims>();
|
||||
DSizes<Index, NumDims> tensor_slice_offsets = RandomDims<NumDims>();
|
||||
DSizes<Index, NumDims> tensor_slice_extents = RandomDims<NumDims>();
|
||||
|
||||
// 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<Index> coeff_set;
|
||||
|
||||
int total_coeffs = static_cast<int>(tensor_slice_extents.TotalSize());
|
||||
|
||||
// Pick a random dimension sizes for the tensor blocks.
|
||||
DSizes<Index, NumDims> block_sizes;
|
||||
for (int i = 0; i < NumDims; ++i) {
|
||||
block_sizes[i] = internal::random<Index>(1, tensor_slice_extents[i]);
|
||||
}
|
||||
|
||||
TensorSliceBlockMapper block_mapper(tensor_dims, tensor_slice_offsets,
|
||||
tensor_slice_extents, block_sizes,
|
||||
DimensionList<Index, NumDims>());
|
||||
|
||||
for (int i = 0; i < block_mapper.total_block_count(); ++i) {
|
||||
TensorBlock block = block_mapper.GetBlockForIndex(i, NULL);
|
||||
UpdateCoeffSet<T, Layout, NumDims>(block, block.first_coeff_index(),
|
||||
choose(Layout, NumDims - 1, 0),
|
||||
&coeff_set);
|
||||
}
|
||||
|
||||
VERIFY_IS_EQUAL(Index(coeff_set.size()), total_coeffs);
|
||||
}
|
||||
|
||||
template <typename T, int NumDims, int Layout>
|
||||
static void test_block_io_copy_data_from_source_to_target() {
|
||||
typedef internal::TensorBlock<T, Index, NumDims, Layout> TensorBlock;
|
||||
typedef internal::TensorBlockMapper<T, Index, NumDims, Layout>
|
||||
TensorBlockMapper;
|
||||
|
||||
typedef internal::TensorBlockReader<T, Index, NumDims, Layout>
|
||||
TensorBlockReader;
|
||||
typedef internal::TensorBlockWriter<T, Index, NumDims, Layout>
|
||||
TensorBlockWriter;
|
||||
|
||||
DSizes<Index, NumDims> input_tensor_dims = RandomDims<NumDims>();
|
||||
const Index input_tensor_size = input_tensor_dims.TotalSize();
|
||||
|
||||
T* input_data = GenerateRandomData<T>(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 <int Layout, int NumDims>
|
||||
static Index GetInputIndex(Index output_index,
|
||||
const array<Index, NumDims>& output_to_input_dim_map,
|
||||
@@ -304,179 +201,6 @@ static array<Index, NumDims> ComputeStrides(
|
||||
return strides;
|
||||
}
|
||||
|
||||
template <typename T, int NumDims, int Layout>
|
||||
static void test_block_io_copy_using_reordered_dimensions() {
|
||||
typedef internal::TensorBlock<T, Index, NumDims, Layout> TensorBlock;
|
||||
typedef internal::TensorBlockMapper<T, Index, NumDims, Layout>
|
||||
TensorBlockMapper;
|
||||
|
||||
typedef internal::TensorBlockReader<T, Index, NumDims, Layout>
|
||||
TensorBlockReader;
|
||||
typedef internal::TensorBlockWriter<T, Index, NumDims, Layout>
|
||||
TensorBlockWriter;
|
||||
|
||||
DSizes<Index, NumDims> input_tensor_dims = RandomDims<NumDims>();
|
||||
const Index input_tensor_size = input_tensor_dims.TotalSize();
|
||||
|
||||
// Create a random input tensor.
|
||||
T* input_data = GenerateRandomData<T>(input_tensor_size);
|
||||
|
||||
// Create a random dimension re-ordering/shuffle.
|
||||
std::vector<Index> shuffle;
|
||||
for (int i = 0; i < NumDims; ++i) shuffle.push_back(i);
|
||||
std::random_shuffle(shuffle.begin(), shuffle.end());
|
||||
|
||||
DSizes<Index, NumDims> output_tensor_dims;
|
||||
array<Index, NumDims> input_to_output_dim_map;
|
||||
array<Index, NumDims> 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<Index, NumDims> input_tensor_strides =
|
||||
ComputeStrides<Layout, NumDims>(input_tensor_dims);
|
||||
array<Index, NumDims> output_tensor_strides =
|
||||
ComputeStrides<Layout, NumDims>(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<Layout, NumDims>(
|
||||
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 <int Layout>
|
||||
static void test_block_io_copy_using_reordered_dimensions_do_not_squeeze()
|
||||
{
|
||||
typedef internal::TensorBlock<float, Index, 3, Layout> TensorBlock;
|
||||
typedef internal::TensorBlockReader<float, Index, 3, Layout>
|
||||
TensorBlockReader;
|
||||
|
||||
DSizes<Index, 3> tensor_dims;
|
||||
tensor_dims[0] = 7;
|
||||
tensor_dims[1] = 9;
|
||||
tensor_dims[2] = 7;
|
||||
|
||||
DSizes<Index, 3> block_dims = tensor_dims;
|
||||
|
||||
DSizes<Index, 3> 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<Index, 3> tensor_strides(ComputeStrides<Layout, 3>(tensor_dims));
|
||||
DSizes<Index, 3> block_strides(ComputeStrides<Layout, 3>(block_dims));
|
||||
|
||||
const Index tensor_size = tensor_dims.TotalSize();
|
||||
float* tensor_data = GenerateRandomData<float>(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<Tensor<float, 3, Layout> > block_tensor(block_data, block_dims);
|
||||
TensorMap<Tensor<float, 3, Layout> > 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 <int Layout>
|
||||
static void test_block_io_copy_using_reordered_dimensions_squeeze()
|
||||
{
|
||||
typedef internal::TensorBlock<float, Index, 4, Layout> TensorBlock;
|
||||
typedef internal::TensorBlockReader<float, Index, 4, Layout>
|
||||
TensorBlockReader;
|
||||
|
||||
DSizes<Index, 4> tensor_dims;
|
||||
tensor_dims[0] = 7;
|
||||
tensor_dims[1] = 5;
|
||||
tensor_dims[2] = 9;
|
||||
tensor_dims[3] = 9;
|
||||
|
||||
DSizes<Index, 4> block_dims = tensor_dims;
|
||||
|
||||
DSizes<Index, 4> 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<Index, 4> tensor_strides(ComputeStrides<Layout, 4>(tensor_dims));
|
||||
DSizes<Index, 4> block_strides(ComputeStrides<Layout, 4>(block_dims));
|
||||
|
||||
const Index tensor_size = tensor_dims.TotalSize();
|
||||
float* tensor_data = GenerateRandomData<float>(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<Tensor<float, 4, Layout> > block_tensor(block_data, block_dims);
|
||||
TensorMap<Tensor<float, 4, Layout> > 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<typename Scalar, typename StorageIndex, int Dim>
|
||||
class EqualityChecker
|
||||
{
|
||||
@@ -510,365 +234,6 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
template <int Layout>
|
||||
static void test_block_io_zero_stride()
|
||||
{
|
||||
typedef internal::TensorBlock<float, Index, 5, Layout> TensorBlock;
|
||||
typedef internal::TensorBlockReader<float, Index, 5, Layout>
|
||||
TensorBlockReader;
|
||||
typedef internal::TensorBlockWriter<float, Index, 5, Layout>
|
||||
TensorBlockWriter;
|
||||
|
||||
DSizes<Index, 5> rnd_dims = RandomDims<5>();
|
||||
|
||||
DSizes<Index, 5> 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<float>(input_tensor_size);
|
||||
|
||||
DSizes<Index, 5> output_tensor_dims = rnd_dims;
|
||||
|
||||
DSizes<Index, 5> input_tensor_strides(
|
||||
ComputeStrides<Layout, 5>(input_tensor_dims));
|
||||
DSizes<Index, 5> output_tensor_strides(
|
||||
ComputeStrides<Layout, 5>(output_tensor_dims));
|
||||
|
||||
DSizes<Index, 5> 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<float, Index, 5> 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 <int Layout>
|
||||
static void test_block_io_squeeze_ones() {
|
||||
typedef internal::TensorBlock<float, Index, 5, Layout> TensorBlock;
|
||||
typedef internal::TensorBlockReader<float, Index, 5, Layout>
|
||||
TensorBlockReader;
|
||||
typedef internal::TensorBlockWriter<float, Index, 5, Layout>
|
||||
TensorBlockWriter;
|
||||
|
||||
// Total size > 1.
|
||||
{
|
||||
DSizes<Index, 5> block_sizes(1, 2, 1, 2, 1);
|
||||
const Index total_size = block_sizes.TotalSize();
|
||||
|
||||
// Create a random input tensor.
|
||||
float* input_data = GenerateRandomData<float>(total_size);
|
||||
DSizes<Index, 5> strides(ComputeStrides<Layout, 5>(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<Index, 5> block_sizes(1, 1, 1, 1, 1);
|
||||
const Index total_size = block_sizes.TotalSize();
|
||||
|
||||
// Create a random input tensor.
|
||||
float* input_data = GenerateRandomData<float>(total_size);
|
||||
DSizes<Index, 5> strides(ComputeStrides<Layout, 5>(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 <typename T, int NumDims, int Layout>
|
||||
static void test_block_cwise_unary_io_basic() {
|
||||
typedef internal::scalar_square_op<T> UnaryFunctor;
|
||||
typedef internal::TensorBlockCwiseUnaryIO<UnaryFunctor, Index, T, NumDims,
|
||||
Layout>
|
||||
TensorBlockCwiseUnaryIO;
|
||||
|
||||
DSizes<Index, NumDims> block_sizes = RandomDims<NumDims>();
|
||||
DSizes<Index, NumDims> strides(ComputeStrides<Layout, NumDims>(block_sizes));
|
||||
|
||||
const Index total_size = block_sizes.TotalSize();
|
||||
|
||||
// Create a random input tensors.
|
||||
T* input_data = GenerateRandomData<T>(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 <int Layout>
|
||||
static void test_block_cwise_unary_io_squeeze_ones() {
|
||||
typedef internal::scalar_square_op<float> UnaryFunctor;
|
||||
typedef internal::TensorBlockCwiseUnaryIO<UnaryFunctor, Index, float, 5,
|
||||
Layout>
|
||||
TensorBlockCwiseUnaryIO;
|
||||
|
||||
DSizes<Index, 5> block_sizes(1, 2, 1, 3, 1);
|
||||
DSizes<Index, 5> strides(ComputeStrides<Layout, 5>(block_sizes));
|
||||
|
||||
const Index total_size = block_sizes.TotalSize();
|
||||
|
||||
// Create a random input tensors.
|
||||
float* input_data = GenerateRandomData<float>(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 <int Layout>
|
||||
static void test_block_cwise_unary_io_zero_strides() {
|
||||
typedef internal::scalar_square_op<float> UnaryFunctor;
|
||||
typedef internal::TensorBlockCwiseUnaryIO<UnaryFunctor, Index, float, 5,
|
||||
Layout>
|
||||
TensorBlockCwiseUnaryIO;
|
||||
|
||||
DSizes<Index, 5> rnd_dims = RandomDims<5>();
|
||||
|
||||
DSizes<Index, 5> input_sizes = rnd_dims;
|
||||
input_sizes[0] = 1;
|
||||
input_sizes[2] = 1;
|
||||
input_sizes[4] = 1;
|
||||
|
||||
DSizes<Index, 5> input_strides(ComputeStrides<Layout, 5>(input_sizes));
|
||||
input_strides[0] = 0;
|
||||
input_strides[2] = 0;
|
||||
input_strides[4] = 0;
|
||||
|
||||
// Generate random data.
|
||||
float* input_data = GenerateRandomData<float>(input_sizes.TotalSize());
|
||||
|
||||
DSizes<Index, 5> output_sizes = rnd_dims;
|
||||
DSizes<Index, 5> output_strides(ComputeStrides<Layout, 5>(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 <typename T, int NumDims, int Layout>
|
||||
static void test_block_cwise_binary_io_basic() {
|
||||
typedef internal::scalar_sum_op<T> BinaryFunctor;
|
||||
typedef internal::TensorBlockCwiseBinaryIO<BinaryFunctor, Index, T, NumDims,
|
||||
Layout>
|
||||
TensorBlockCwiseBinaryIO;
|
||||
|
||||
DSizes<Index, NumDims> block_sizes = RandomDims<NumDims>();
|
||||
DSizes<Index, NumDims> strides(ComputeStrides<Layout, NumDims>(block_sizes));
|
||||
|
||||
const Index total_size = block_sizes.TotalSize();
|
||||
|
||||
// Create a random input tensors.
|
||||
T* left_data = GenerateRandomData<T>(total_size);
|
||||
T* right_data = GenerateRandomData<T>(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 <int Layout>
|
||||
static void test_block_cwise_binary_io_squeeze_ones() {
|
||||
typedef internal::scalar_sum_op<float> BinaryFunctor;
|
||||
typedef internal::TensorBlockCwiseBinaryIO<BinaryFunctor, Index, float, 5,
|
||||
Layout>
|
||||
TensorBlockCwiseBinaryIO;
|
||||
|
||||
DSizes<Index, 5> block_sizes(1, 2, 1, 3, 1);
|
||||
DSizes<Index, 5> strides(ComputeStrides<Layout, 5>(block_sizes));
|
||||
|
||||
const Index total_size = block_sizes.TotalSize();
|
||||
|
||||
// Create a random input tensors.
|
||||
float* left_data = GenerateRandomData<float>(total_size);
|
||||
float* right_data = GenerateRandomData<float>(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 <int Layout>
|
||||
static void test_block_cwise_binary_io_zero_strides() {
|
||||
typedef internal::scalar_sum_op<float> BinaryFunctor;
|
||||
typedef internal::TensorBlockCwiseBinaryIO<BinaryFunctor, Index, float, 5,
|
||||
Layout>
|
||||
TensorBlockCwiseBinaryIO;
|
||||
|
||||
DSizes<Index, 5> rnd_dims = RandomDims<5>();
|
||||
|
||||
DSizes<Index, 5> left_sizes = rnd_dims;
|
||||
left_sizes[0] = 1;
|
||||
left_sizes[2] = 1;
|
||||
left_sizes[4] = 1;
|
||||
|
||||
DSizes<Index, 5> left_strides(ComputeStrides<Layout, 5>(left_sizes));
|
||||
left_strides[0] = 0;
|
||||
left_strides[2] = 0;
|
||||
left_strides[4] = 0;
|
||||
|
||||
DSizes<Index, 5> right_sizes = rnd_dims;
|
||||
right_sizes[1] = 1;
|
||||
right_sizes[3] = 1;
|
||||
|
||||
DSizes<Index, 5> right_strides(ComputeStrides<Layout, 5>(right_sizes));
|
||||
right_strides[1] = 0;
|
||||
right_strides[3] = 0;
|
||||
|
||||
// Generate random data.
|
||||
float* left_data = GenerateRandomData<float>(left_sizes.TotalSize());
|
||||
float* right_data = GenerateRandomData<float>(right_sizes.TotalSize());
|
||||
|
||||
DSizes<Index, 5> output_sizes = rnd_dims;
|
||||
DSizes<Index, 5> output_strides(ComputeStrides<Layout, 5>(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 <int Layout>
|
||||
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);
|
||||
|
||||
Reference in New Issue
Block a user