/*!\brief Estimating the necessary number of steps for each benchmark.
//
// \param run The parameters for the benchmark run.
// \return void
//
// This function estimates the necessary number of steps for the given benchmark based on the
// performance of the Blaze library.
*/
void estimateSteps( Run& run )
{
using blazemark::element_t;
using blaze::rowMajor;
::blaze::setSeed( ::blazemark::seed );
const size_t N( run.getSize() );
blaze::DynamicMatrix<element_t,rowMajor> A( N, N ), B( N, N );
blaze::timing::WcTimer timer;
double wct( 0.0 );
size_t steps( 1UL );
blazemark::blaze::init( A );
while( true ) {
timer.start();
for( size_t i=0UL; i<steps; ++i ) {
B = A * element_t(3);
}
timer.end();
wct = timer.last();
if( wct >= 0.2 ) break;
steps *= 2UL;
}
if( B.rows() != N )
std::cerr << " Line " << __LINE__ << ": ERROR detected!!!\n";
run.setSteps( blaze::max( 1UL, ( blazemark::runtime * steps ) / timer.last() ) );
}
/*!\brief Estimating the necessary number of steps for each benchmark.
//
// \param run The parameters for the benchmark run.
// \return void
//
// This function estimates the necessary number of steps for the given benchmark based on the
// performance of the Blaze library.
*/
void estimateSteps( Run& run )
{
using blazemark::element_t;
using blaze::columnVector;
::blaze::setSeed( ::blazemark::seed );
const size_t N( run.getSize() );
blaze::DynamicVector<element_t,columnVector> a( N );
element_t scalar( 0 );
blaze::timing::WcTimer timer;
double wct( 0.0 );
size_t steps( 1UL );
blazemark::blaze::init( a );
while( true ) {
timer.start();
for( size_t i=0UL; i<steps; ++i ) {
scalar += trans( a ) * a;
}
timer.end();
wct = timer.last();
if( wct >= 0.2 ) break;
steps *= 2UL;
}
if( scalar < element_t(0) )
std::cerr << " Line " << __LINE__ << ": ERROR detected!!!\n";
run.setSteps( blaze::max( 1UL, ( blazemark::runtime * steps ) / timer.last() ) );
}
/*!\brief Estimating the necessary number of steps for each benchmark.
//
// \param run The parameters for the benchmark run.
// \return void
//
// This function estimates the necessary number of steps for the given benchmark based on the
// performance of the Blaze library.
*/
void estimateSteps( Run& run )
{
using blazemark::element_t;
using blaze::rowMajor;
using blaze::columnMajor;
typedef blaze::StaticMatrix<element_t,6UL,6UL,rowMajor> RowMajorMatrixType;
typedef blaze::StaticMatrix<element_t,6UL,6UL,columnMajor> ColumnMajorMatrixType;
typedef blaze::AlignedAllocator<RowMajorMatrixType> RowMajorAllocatorType;
typedef blaze::AlignedAllocator<ColumnMajorMatrixType> ColumnMajorAllocatorType;
blaze::setSeed( blazemark::seed );
const size_t N( run.getNumber() );
std::vector< RowMajorMatrixType, RowMajorAllocatorType > A( N ), C( N );
std::vector< ColumnMajorMatrixType, ColumnMajorAllocatorType > B( N );
blaze::timing::WcTimer timer;
double wct( 0.0 );
size_t steps( 1UL );
blazemark::blaze::init( A );
blazemark::blaze::init( B );
while( true ) {
timer.start();
for( size_t step=0UL, i=0UL; step<steps; ++step, ++i ) {
if( i == N ) i = 0UL;
C[i] = A[i] * B[i];
}
timer.end();
wct = timer.last();
if( wct >= 0.2 ) break;
steps *= 2UL;
}
for( size_t i=0UL; i<N; ++i )
if( C[i](0,0) < element_t(0) )
std::cerr << " Line " << __LINE__ << ": ERROR detected!!!\n";
run.setSteps( blaze::max( 1UL, ( blazemark::runtime * steps ) / timer.last() ) );
}
/*!\brief Estimating the necessary number of steps for each benchmark.
//
// \param run The parameters for the benchmark run.
// \return void
//
// This function estimates the necessary number of steps for the given benchmark based on the
// performance of the Blaze library.
*/
void estimateSteps( Run& run )
{
using blazemark::element_t;
using blaze::rowVector;
using blaze::rowMajor;
typedef blaze::StaticVector<element_t,3UL,rowVector> VectorType;
typedef blaze::StaticMatrix<element_t,3UL,3UL,rowMajor> MatrixType;
typedef blaze::AlignedAllocator<VectorType> VectorAllocatorType;
typedef blaze::AlignedAllocator<MatrixType> MatrixAllocatorType;
blaze::setSeed( blazemark::seed );
const size_t N( run.getNumber() );
std::vector< VectorType, VectorAllocatorType > a( N ), b( N );
std::vector< MatrixType, MatrixAllocatorType > A( N );
blaze::timing::WcTimer timer;
double wct( 0.0 );
size_t steps( 1UL );
blazemark::blaze::init( a );
blazemark::blaze::init( A );
while( true ) {
timer.start();
for( size_t step=0UL, i=0UL; step<steps; ++step, ++i ) {
if( i == N ) i = 0UL;
b[i] = a[i] * A[i];
}
timer.end();
wct = timer.last();
if( wct >= 0.2 ) break;
steps *= 2UL;
}
for( size_t i=0UL; i<N; ++i )
if( b[i][0] < element_t(0) )
std::cerr << " Line " << __LINE__ << ": ERROR detected!!!\n";
run.setSteps( blaze::max( 1UL, ( blazemark::runtime * steps ) / timer.last() ) );
}