Fixed some bugs in the benchmarks.

Author: corbett5

benchmarks/benchmarkMatrixMatrix.cpp

@@ -117,20 +117,20 @@ void pointerRAJA( benchmark::State & state )
   kernels.pointer();
 }
 
-INDEX_TYPE const SERIAL_N = (2 << 7) + 73;
-INDEX_TYPE const SERIAL_L = (2 << 7) - 71;
-INDEX_TYPE const SERIAL_M = (2 << 7) - 3;
+INDEX_TYPE const SERIAL_N = (2 << 8) + 73;
+INDEX_TYPE const SERIAL_L = (2 << 8) - 71;
+INDEX_TYPE const SERIAL_M = (2 << 8) - 3;
 
 #if defined(LVARRAY_USE_OPENMP)
-INDEX_TYPE const OMP_N = SERIAL_N;
-INDEX_TYPE const OMP_L = SERIAL_L;
-INDEX_TYPE const OMP_M = SERIAL_M;
+INDEX_TYPE const OMP_N = 4 * SERIAL_N;
+INDEX_TYPE const OMP_L = 4 * SERIAL_L;
+INDEX_TYPE const OMP_M = 4 * SERIAL_M;
 #endif
 
 #if defined(LVARRAY_USE_CUDA) && defined(LVARRAY_USE_CHAI)
-INDEX_TYPE const CUDA_N = SERIAL_N;
-INDEX_TYPE const CUDA_L = SERIAL_L;
-INDEX_TYPE const CUDA_M = SERIAL_M;
+INDEX_TYPE const CUDA_N = 16 * SERIAL_N;
+INDEX_TYPE const CUDA_L = 16 * SERIAL_L;
+INDEX_TYPE const CUDA_M = 16 * SERIAL_M;
 #endif
 
 void registerBenchmarks()
@@ -170,12 +170,12 @@ void registerBenchmarks()
                                 std::make_tuple( SERIAL_N, SERIAL_L, SERIAL_M, RAJA::PERM_IJ {}, serialPolicy {} )
                                 , std::make_tuple( SERIAL_N, SERIAL_L, SERIAL_M, RAJA::PERM_JI {}, serialPolicy {} )
   #if defined(LVARRAY_USE_OPENMP)
-                                , std::make_tuple( OMP_N, SERIAL_L, OMP_M, RAJA::PERM_IJ {}, parallelHostPolicy {} )
-                                , std::make_tuple( OMP_N, SERIAL_L, OMP_M, RAJA::PERM_JI {}, parallelHostPolicy {} )
+                                , std::make_tuple( OMP_N, OMP_L, OMP_M, RAJA::PERM_IJ {}, parallelHostPolicy {} )
+                                , std::make_tuple( OMP_N, OMP_L, OMP_M, RAJA::PERM_JI {}, parallelHostPolicy {} )
   #endif
   #if defined(LVARRAY_USE_CUDA) && defined(LVARRAY_USE_CHAI)
-                                , std::make_tuple( CUDA_N, SERIAL_L, CUDA_M, RAJA::PERM_IJ {}, parallelDevicePolicy< THREADS_PER_BLOCK > {} )
-                                , std::make_tuple( CUDA_N, SERIAL_L, CUDA_M, RAJA::PERM_JI {}, parallelDevicePolicy< THREADS_PER_BLOCK > {} )
+                                , std::make_tuple( CUDA_N, CUDA_L, CUDA_M, RAJA::PERM_IJ {}, parallelDevicePolicy< THREADS_PER_BLOCK > {} )
+                                , std::make_tuple( CUDA_N, CUDA_L, CUDA_M, RAJA::PERM_JI {}, parallelDevicePolicy< THREADS_PER_BLOCK > {} )
   #endif
                                 );
 }

benchmarks/benchmarkMatrixMatrixKernels.hpp

@@ -52,7 +52,7 @@ class MatrixMatrixNative
   {
     VALUE_TYPE const result = reduce( m_c ) / INDEX_TYPE( m_state.iterations() );
     registerResult( m_results, { m_a.size( 0 ), m_a.size( 1 ), m_b.size( 1 ) }, result, m_callingFunction );
-    m_state.counters[ "OPS "] = ::benchmark::Counter( 2 * m_a.size() * m_b.size(
+    m_state.counters[ "OPS" ] = ::benchmark::Counter( 2 * m_a.size() * m_b.size(
                                                         1 ), ::benchmark::Counter::kIsIterationInvariantRate, ::benchmark::Counter::OneK::kIs1000 );
   }
 
@@ -170,7 +170,7 @@ class MatrixMatrixRAJA : public MatrixMatrixNative< PERMUTATION >
   }
 
   ~MatrixMatrixRAJA()
-  { this->m_c.move( RAJAHelper< POLICY >::space, false ); }
+  { this->m_c.move( MemorySpace::CPU, false ); }
 
   void fortranView() const
   {

benchmarks/compare.py

@@ -170,10 +170,12 @@ def aggregateAndPrint( results ):
                     resultNames.append( name )
 
                 value = group[ name ] / group[ "baseline" ]
-                if value > 1:
+                if value > 1.05:
                     colors[ groupName ][ name ] = style.GREEN
-                else:
+                elif value < 0.95:
                     colors[ groupName ][ name ] = style.RED
+                else:
+                    colors[ groupName ][ name ] = style.RESET
 
                 group[ name ] = "{:.4}x".format( value )