benchmark_t Struct Reference

Public Member Functions
	benchmark_t ()
	benchmark_t (size_t pk, size_t pm, size_t pn, size_t bk, size_t bm, size_t bn)
	benchmark_t (size_t pk, size_t pm, size_t pn)
void	run ()

Public Attributes
uint16_t	compact_product_size
uint16_t	compact_block_size
bool	use_default_block_size
float	gflops

Constructor & Destructor Documentation

benchmark_t() [1/3]

benchmark_t::benchmark_t ( )

inline

: compact_product_size(0), compact_block_size(0), use_default_block_size(false), gflops(0) {}

benchmark_t() [2/3]

benchmark_t::benchmark_t ( size_t  pk, size_t  pm, size_t  pn, size_t  bk, size_t  bm, size_t  bn  )

inline

      : compact_product_size(compact_size_triple(pk, pm, pn)),
        compact_block_size(compact_size_triple(bk, bm, bn)),
        use_default_block_size(false),
        gflops(0) {}

benchmark_t() [3/3]

benchmark_t::benchmark_t ( size_t  pk, size_t  pm, size_t  pn  )

inline

      : compact_product_size(compact_size_triple(pk, pm, pn)),
        compact_block_size(0),
        use_default_block_size(true),
        gflops(0) {}

Member Function Documentation

run()

void benchmark_t::run

(

)

                      {
  size_triple_t productsizes(compact_product_size);
 
  if (use_default_block_size) {
    eigen_use_specific_block_size = false;
  } else {
    // feed eigen with our custom blocking params
    eigen_use_specific_block_size = true;
    size_triple_t blocksizes(compact_block_size);
    eigen_block_size_k = blocksizes.k;
    eigen_block_size_m = blocksizes.m;
    eigen_block_size_n = blocksizes.n;
  }
 
  // set up the matrix pool
 
  const size_t combined_three_matrices_sizes =
      sizeof(Scalar) *
      (productsizes.k * productsizes.m + productsizes.k * productsizes.n + productsizes.m * productsizes.n);
 
  // 64 M is large enough that nobody has a cache bigger than that,
  // while still being small enough that everybody has this much RAM,
  // so conveniently we don't need to special-case platforms here.
  const size_t unlikely_large_cache_size = 64 << 20;
 
  const size_t working_set_size = min_working_set_size ? min_working_set_size : unlikely_large_cache_size;
 
  const size_t matrix_pool_size = 1 + working_set_size / combined_three_matrices_sizes;
 
  MatrixType* lhs = new MatrixType[matrix_pool_size];
  MatrixType* rhs = new MatrixType[matrix_pool_size];
  MatrixType* dst = new MatrixType[matrix_pool_size];
 
  for (size_t i = 0; i < matrix_pool_size; i++) {
    lhs[i] = MatrixType::Zero(productsizes.m, productsizes.k);
    rhs[i] = MatrixType::Zero(productsizes.k, productsizes.n);
    dst[i] = MatrixType::Zero(productsizes.m, productsizes.n);
  }
 
  // main benchmark loop
 
  int iters_at_a_time = 1;
  float time_per_iter = 0.0f;
  size_t matrix_index = 0;
  while (true) {
    double starttime = timer.getCpuTime();
    for (int i = 0; i < iters_at_a_time; i++) {
      dst[matrix_index].noalias() = lhs[matrix_index] * rhs[matrix_index];
      matrix_index++;
      if (matrix_index == matrix_pool_size) {
        matrix_index = 0;
      }
    }
    double endtime = timer.getCpuTime();
 
    const float timing = float(endtime - starttime);
 
    if (timing >= min_accurate_time) {
      time_per_iter = timing / iters_at_a_time;
      break;
    }
 
    iters_at_a_time *= 2;
  }
 
  delete[] lhs;
  delete[] rhs;
  delete[] dst;
 
  gflops = 2e-9 * productsizes.k * productsizes.m * productsizes.n / time_per_iter;
}

References e(), eigen_block_size_k, eigen_block_size_m, eigen_block_size_n, eigen_use_specific_block_size, i, size_triple_t::k, size_triple_t::m, min_accurate_time, min_working_set_size, size_triple_t::n, and oomph::PseudoSolidHelper::Zero.

Member Data Documentation

compact_block_size

uint16_t benchmark_t::compact_block_size

Referenced by operator<().

compact_product_size

uint16_t benchmark_t::compact_product_size

Referenced by operator<().

gflops

float benchmark_t::gflops

Referenced by operator<().

use_default_block_size

bool benchmark_t::use_default_block_size

---

The documentation for this struct was generated from the following file:

• benchmark-blocking-sizes.cpp