Remove legacy block evaluation support

2 files changed, 71 insertions, 791 deletions

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<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
 {
@@ -511,365 +235,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()
 {
   typedef internal::TensorBlock<int, Index, 5, Layout> TensorBlock;
@@ -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
@@ -311,48 +311,6 @@ static void test_execute_shuffle_lvalue(Device d)
 }
 
 template <typename T, int NumDims, typename Device, bool Vectorizable,
-          TiledEvaluation Tiling, int Layout>
-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<NumDims>(5, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  // Pick two random and unique reduction dimensions.
-  int reduction0 = internal::random<int>(0, NumDims - 1);
-  int reduction1 = internal::random<int>(0, NumDims - 1);
-  while (reduction0 == reduction1) {
-    reduction1 = internal::random<int>(0, NumDims - 1);
-  }
-
-  DSizes<Index, 2> reduction_axis;
-  reduction_axis[0] = reduction0;
-  reduction_axis[1] = reduction1;
-
-  Tensor<T, ReducedDims, Options, Index> golden = src.sum(reduction_axis);
-
-  // Now do the reduction using configured tensor executor.
-  Tensor<T, ReducedDims, Options, Index> dst(golden.dimensions());
-
-  auto expr = src.sum(reduction_axis);
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor =
-      internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  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 <typename T, int NumDims, typename Device, bool Vectorizable,
     TiledEvaluation Tiling, int Layout>
 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<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Off,     ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Legacy,  ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Off,     ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Legacy,  ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Off,     RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Legacy,  RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Off,     RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Legacy,  RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Off,     ColMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Legacy,  ColMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Off,     ColMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Legacy,  ColMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Off,     RowMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Legacy,  RowMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Off,     RowMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Legacy,  RowMajor>(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<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Off,     ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Legacy,  ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::On,      ColMajor>(default_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::On,  ColMajor>(default_device)));     \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Off,     ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Legacy,  ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::On,      ColMajor>(default_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::On,  ColMajor>(default_device)));     \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Off,     RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::Legacy,  RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::On,      RowMajor>(default_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    false,               TiledEvaluation::On,  RowMajor>(default_device)));     \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Off,     RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::Legacy,  RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::On,      RowMajor>(default_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice,    VECTORIZABLE(true),  TiledEvaluation::On,  RowMajor>(default_device)));     \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Off,     ColMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Legacy,  ColMajor>(tp_device)));      \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::On,  ColMajor>(tp_device)));          \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Off,     ColMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Legacy,  ColMajor>(tp_device)));      \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::On,  ColMajor>(tp_device)));          \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Off,     RowMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Legacy,  RowMajor>(tp_device)));      \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::On,  RowMajor>(tp_device)));          \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Off,     RowMajor>(tp_device)));      \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Legacy,  RowMajor>(tp_device)))
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::On,  RowMajor>(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<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Off,     ColMajor>(tp_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Legacy,  ColMajor>(tp_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::On,  ColMajor>(tp_device)));     \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Off,     ColMajor>(tp_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Legacy,  ColMajor>(tp_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::On,  ColMajor>(tp_device)));     \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Off,     RowMajor>(tp_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::Legacy,  RowMajor>(tp_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false,               TiledEvaluation::On,  RowMajor>(tp_device)));     \
   CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Off,     RowMajor>(tp_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::Legacy,  RowMajor>(tp_device)))
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(true),  TiledEvaluation::On,  RowMajor>(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);