From f442a5a5b34ede4ab4e8fe36d1c8237315ad3f04 Mon Sep 17 00:00:00 2001 From: Benoit Steiner Date: Tue, 23 Feb 2016 04:15:48 +0000 Subject: Updated the tensor benchmarking code to work with compilers that don't support cxx11. --- bench/tensors/tensor_benchmarks.h | 128 ++++++++++++++++++++++++++++---------- 1 file changed, 94 insertions(+), 34 deletions(-) (limited to 'bench/tensors') diff --git a/bench/tensors/tensor_benchmarks.h b/bench/tensors/tensor_benchmarks.h index f3ec70a9e..688f558d0 100644 --- a/bench/tensors/tensor_benchmarks.h +++ b/bench/tensors/tensor_benchmarks.h @@ -45,7 +45,9 @@ template class BenchmarkSuite { void typeCasting(int num_iters) { eigen_assert(m_ == n_); - const Eigen::array sizes = {{m_, k_}}; + Eigen::array sizes; + sizes[0] = m_; + sizes[1] = k_; const TensorMap, Eigen::Aligned> A(a_, sizes); TensorMap, Eigen::Aligned> B((int*)b_, sizes); @@ -59,7 +61,9 @@ template class BenchmarkSuite { void random(int num_iters) { eigen_assert(m_ == k_ && k_ == n_); - const Eigen::array sizes = {{m_, m_}}; + Eigen::array sizes; + sizes[0] = m_; + sizes[1] = m_; TensorMap, Eigen::Aligned> C(c_, sizes); StartBenchmarkTiming(); @@ -72,7 +76,9 @@ template class BenchmarkSuite { void slicing(int num_iters) { eigen_assert(m_ == k_ && k_ == n_); - const Eigen::array sizes = {{m_, m_}}; + Eigen::array sizes; + sizes[0] = m_; + sizes[1] = m_; const TensorMap, Eigen::Aligned> A(a_, sizes); const TensorMap, Eigen::Aligned> B(b_, sizes); TensorMap, Eigen::Aligned> C(c_, sizes); @@ -100,9 +106,12 @@ template class BenchmarkSuite { } void rowChip(int num_iters) { - const Eigen::array input_size = {{k_, n_}}; + Eigen::array input_size; + input_size[0] = k_; + input_size[1] = n_; const TensorMap, Eigen::Aligned> B(b_, input_size); - const Eigen::array output_size = {{n_}}; + Eigen::array output_size; + output_size[0] = n_; TensorMap, Eigen::Aligned> C(c_, output_size); StartBenchmarkTiming(); @@ -114,9 +123,12 @@ template class BenchmarkSuite { } void colChip(int num_iters) { - const Eigen::array input_size= {{k_, n_}}; + Eigen::array input_size; + input_size[0] = k_; + input_size[1] = n_; const TensorMap, Eigen::Aligned> B(b_, input_size); - const Eigen::array output_size = {{n_}}; + Eigen::array output_size; + output_size[0] = n_; TensorMap, Eigen::Aligned> C(c_, output_size); StartBenchmarkTiming(); @@ -129,12 +141,18 @@ template class BenchmarkSuite { void shuffling(int num_iters) { eigen_assert(m_ == n_); - const Eigen::array size_a = {{m_, k_}}; + Eigen::array size_a; + size_a[0] = m_; + size_a[1] = k_; const TensorMap, Eigen::Aligned> A(a_, size_a); - const Eigen::array size_b = {{k_, m_}}; + Eigen::array size_b; + size_b[0] = k_; + size_b[1] = m_; TensorMap, Eigen::Aligned> B(b_, size_b); - const Eigen::array shuffle = {{1, 0}}; + Eigen::array shuffle; + shuffle[0] = 1; + shuffle[1] = 0; StartBenchmarkTiming(); for (int iter = 0; iter < num_iters; ++iter) { @@ -146,9 +164,13 @@ template class BenchmarkSuite { void padding(int num_iters) { eigen_assert(m_ == k_); - const Eigen::array size_a = {{m_, k_-3}}; + Eigen::array size_a; + size_a[0] = m_; + size_a[1] = k_-3; const TensorMap, Eigen::Aligned> A(a_, size_a); - const Eigen::array size_b = {{k_, m_}}; + Eigen::array size_b; + size_b[0] = k_; + size_b[1] = m_; TensorMap, Eigen::Aligned> B(b_, size_b); Eigen::array, 2> paddings; @@ -165,12 +187,18 @@ template class BenchmarkSuite { void striding(int num_iters) { eigen_assert(m_ == k_); - const Eigen::array size_a = {{m_, k_}}; + Eigen::array size_a; + size_a[0] = m_; + size_a[1] = k_; const TensorMap, Eigen::Aligned> A(a_, size_a); - const Eigen::array size_b = {{m_, k_ / 2}}; + Eigen::array size_b; + size_b[0] = m_; + size_b[1] = k_/2; TensorMap, Eigen::Aligned> B(b_, size_b); - const Eigen::array strides = {{1, 2}}; + Eigen::array strides; + strides[0] = 1; + strides[1] = 2; StartBenchmarkTiming(); for (int iter = 0; iter < num_iters; ++iter) { @@ -181,13 +209,19 @@ template class BenchmarkSuite { } void broadcasting(int num_iters) { - const Eigen::array size_a = {{m_, 1}}; + Eigen::array size_a; + size_a[0] = m_; + size_a[1] = 1; const TensorMap, Eigen::Aligned> A(a_, size_a); - const Eigen::array size_c = {{m_, n_}}; + Eigen::array size_c; + size_c[0] = m_; + size_c[1] = n_; TensorMap, Eigen::Aligned> C(c_, size_c); #ifndef EIGEN_HAS_INDEX_LIST - const Eigen::array broadcast = {{1, n_}}; + Eigen::array broadcast; + broadcast[0] = 1; + broadcast[1] = n_; #else // Take advantage of cxx11 to give the compiler information it can use to // optimize the code. @@ -205,7 +239,9 @@ template class BenchmarkSuite { void coeffWiseOp(int num_iters) { eigen_assert(m_ == k_ && k_ == n_); - const Eigen::array sizes = {{m_, m_}}; + Eigen::array sizes; + sizes[0] = m_; + sizes[1] = m_; const TensorMap, Eigen::Aligned> A(a_, sizes); const TensorMap, Eigen::Aligned> B(b_, sizes); TensorMap, Eigen::Aligned> C(c_, sizes); @@ -221,7 +257,9 @@ template class BenchmarkSuite { void algebraicFunc(int num_iters) { eigen_assert(m_ == k_ && k_ == n_); - const Eigen::array sizes = {{m_, m_}}; + Eigen::array sizes; + sizes[0] = m_; + sizes[1] = m_; const TensorMap, Eigen::Aligned> A(a_, sizes); const TensorMap, Eigen::Aligned> B(b_, sizes); TensorMap, Eigen::Aligned> C(c_, sizes); @@ -237,7 +275,9 @@ template class BenchmarkSuite { void transcendentalFunc(int num_iters) { eigen_assert(m_ == k_ && k_ == n_); - const Eigen::array sizes = {{m_, m_}}; + Eigen::array sizes; + sizes[0] = m_; + sizes[1] = m_; const TensorMap, Eigen::Aligned> A(a_, sizes); const TensorMap, Eigen::Aligned> B(b_, sizes); TensorMap, Eigen::Aligned> C(c_, sizes); @@ -253,13 +293,16 @@ template class BenchmarkSuite { // Row reduction void rowReduction(int num_iters) { - const Eigen::array input_size = {{k_, n_}}; + Eigen::array input_size; + input_size[0] = k_; + input_size[1] = n_; const TensorMap, Eigen::Aligned> B(b_, input_size); const Eigen::array output_size = {{n_}}; TensorMap, Eigen::Aligned> C(c_, output_size); #ifndef EIGEN_HAS_INDEX_LIST - const Eigen::array sum_along_dim = {{0}}; + Eigen::array sum_along_dim; + sum_along_dim[0] = 0; #else // Take advantage of cxx11 to give the compiler information it can use to // optimize the code. @@ -277,7 +320,9 @@ template class BenchmarkSuite { // Column reduction void colReduction(int num_iters) { - const Eigen::array input_size = {{k_, n_}}; + Eigen::array input_size; + input_size[0] = k_; + input_size[1] = n_; const TensorMap, Eigen::Aligned> B( b_, input_size); const Eigen::array output_size = {{k_}}; @@ -285,7 +330,8 @@ template class BenchmarkSuite { c_, output_size); #ifndef EIGEN_HAS_INDEX_LIST - const Eigen::array sum_along_dim = {{1}}; + Eigen::array sum_along_dim; + sum_along_dim = 1; #else // Take advantage of cxx11 to give the compiler information it can use to // optimize the code. @@ -303,16 +349,23 @@ template class BenchmarkSuite { // do a contraction which is equivalent to a matrix multiplication void contraction(int num_iters) { - const Eigen::array sizeA = {{m_, k_}}; - const Eigen::array sizeB = {{k_, n_}}; - const Eigen::array sizeC = {{m_, n_}}; + Eigen::array sizeA; + sizeA[0] = m_; + sizeA[1] = k_; + Eigen::array sizeB; + sizeB[0] = k_; + sizeB[1] = n_; + Eigen::array sizeC; + sizeC[0] = m_; + sizeC[1] = n_; const TensorMap, Eigen::Aligned> A(a_, sizeA); const TensorMap, Eigen::Aligned> B(b_, sizeB); TensorMap, Eigen::Aligned> C(c_, sizeC); typedef typename Tensor::DimensionPair DimPair; - const Eigen::array dims = {{DimPair(1, 0)}}; + Eigen::array dims; + dims[0] = DimPair(1, 0); StartBenchmarkTiming(); for (int iter = 0; iter < num_iters; ++iter) { @@ -324,14 +377,21 @@ template class BenchmarkSuite { } void convolution(int num_iters, int kernel_x, int kernel_y) { - const Eigen::array input_sizes = {{m_, n_}}; + Eigen::array input_sizes; + input_sizes[0] = m_; + input_sizes[1] = n_; TensorMap, Eigen::Aligned> A(a_, input_sizes); - const Eigen::array kernel_sizes = {{kernel_x, kernel_y}}; + Eigen::array kernel_sizes; + kernel_sizes[0] = kernel_x; + kernel_sizes[1] = kernel_y; TensorMap, Eigen::Aligned> B(b_, kernel_sizes); - const Eigen::array result_sizes = - {{m_ - kernel_x + 1, n_ - kernel_y + 1}}; + Eigen::array result_sizes; + result_sizes[0] = m_ - kernel_x + 1; + result_sizes[1] = n_ - kernel_y + 1; TensorMap, Eigen::Aligned> C(c_, result_sizes); - Eigen::array::Index, 2> dims = {{0, 1}}; + Eigen::array::Index, 2> dims; + dims[0] = 0; + dims[1] = 1; StartBenchmarkTiming(); for (int iter = 0; iter < num_iters; ++iter) { -- cgit v1.2.3