/***************************************************************************
tnl-benchmarks.h - description
-------------------
begin : Jan 27, 2010
copyright : (C) 2010 by Tomas Oberhuber
email : tomas.oberhuber@fjfi.cvut.cz
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef TNLBENCHMARKS_H_
#define TNLBENCHMARKS_H_
#include <core/mfuncs.h>
#include <core/tnlTimerCPU.h>
#include <../tests/unit-tests/core/tnl-cuda-kernels.h>
#include <core/low-level/cuda-long-vector-kernels.h>
template< class T >
bool transferBenchmark( const int size,
double& host_to_host_band_width,
double& host_to_device_band_width,
double& device_to_host_band_width,
double& device_to_device_band_width )
{
tnlVector< T > host_vector( "transferBenchmark:host-vector", size );
tnlVector< T > host_vector2( "transferBenchmark:host-vector-2", size );
tnlVector< T, tnlCuda > device_vector( "transferBenchmark:device-vector", size );
tnlVector< T, tnlCuda > device_vector2( "transferBenchmark:device-vector-2", size );
for( int i = 0; i < size; i ++ )
host_vector[ i ] = i + 1;
const long int cycles = 100;
long int bytes = cycles * size * sizeof( int );
long int mega_byte = 1 << 20;
tnlTimerCPU timer;
timer. Reset();
for( int i = 0; i < cycles; i ++ )
host_vector2 = host_vector;
double time = timer. getTime();
double giga_byte = ( double ) ( 1 << 30 );
host_to_host_band_width = bytes / giga_byte / time;
cout << "Transfering " << bytes / mega_byte << " MB from HOST to HOST took " << time << " seconds. Bandwidth is " << host_to_host_band_width << " GB/s." << endl;
timer. Reset();
for( int i = 0; i < cycles; i ++ )
device_vector = host_vector;
time = timer. getTime();
host_to_device_band_width = bytes / giga_byte / time;
cout << "Transfering " << bytes / mega_byte << " MB from HOST to DEVICE took " << time << " seconds. Bandwidth is " << host_to_device_band_width << " GB/s." << endl;
timer. Reset();
for( int i = 0; i < cycles; i ++ )
host_vector2 = device_vector;
time = timer. getTime();
device_to_host_band_width = bytes / giga_byte / time;
cout << "Transfering " << bytes / mega_byte << " MB from DEVICE to HOST took " << time << " seconds. Bandwidth is " << device_to_host_band_width << " GB/s." << endl;
timer. Reset();
for( int i = 0; i < cycles; i ++ )
device_vector2 = device_vector;
time = timer. getTime();
// Since we read and write tha data back we process twice as many bytes.
bytes *= 2;
device_to_device_band_width = bytes / giga_byte / time;
cout << "Transfering " << bytes / mega_byte << " MB from DEVICE to DEVICE took " << time << " seconds. Bandwidth is " << device_to_device_band_width << " GB/s." << endl;
}
template< class T >
void tnlCPUReductionSum( const tnlVector< T >& host_vector,
T& sum )
{
const T* data = host_vector. getData();
const int size = host_vector. getSize();
sum = 0.0;
for( int i = 0; i < size; i ++ )
sum += data[ i ];
};
template< class T >
void tnlCPUReductionMin( const tnlVector< T >& host_vector,
T& min )
{
const T* data = host_vector. getData();
const int size = host_vector. getSize();
//tnlAssert( data );
min = data[ 0 ];
for( int i = 1; i < size; i ++ )
min = :: Min( min, data[ i ] );
};
template< class T >
void tnlCPUReductionMax( const tnlVector< T >& host_vector,
T& max )
{
const T* data = host_vector. getData();
const int size = host_vector. getSize();
//tnlAssert( data );
max = data[ 0 ];
for( int i = 1; i < size; i ++ )
max = :: Max( max, data[ i ] );
};
template< class T >
void reductionBenchmark( const int size,
const int algorithm )
{
tnlVector< T > host_vector( "reductionBenchmark:host-vector", size );
tnlVector< T, tnlCuda > device_vector( "reductionBenchmark:device-vector", size );
tnlVector< T, tnlCuda > device_aux( "reductionBenchmark:device-aux", size / 2 );
for( int i = 0; i < size; i ++ )
host_vector[ i ] = i + 1;
device_vector = host_vector;
T sum, min, max;
const long int reducing_cycles( 1 );
tnlTimerCPU timer;
timer. Reset();
for( int i = 0; i < reducing_cycles; i ++ )
{
switch( algorithm )
{
case 0: // reduction on CPU
tnlCPUReductionSum( host_vector, sum );
tnlCPUReductionMin( host_vector, sum );
tnlCPUReductionMax( host_vector, sum );
#ifdef HAVE_CUDA
case 1:
tnlCUDASimpleReduction1< T, tnlParallelReductionSum >( size,
device_vector. getData(),
sum,
device_aux. getData() );
tnlCUDASimpleReduction1< T, tnlParallelReductionMin >( size,
device_vector. getData(),
min,
device_aux. getData() );
tnlCUDASimpleReduction1< T, tnlParallelReductionMax >( size,
device_vector. getData(),
max,
device_aux. getData() );
break;
case 2:
tnlCUDASimpleReduction2< T, tnlParallelReductionSum >( size,
device_vector. getData(),
sum,
device_aux. getData() );
tnlCUDASimpleReduction2< T, tnlParallelReductionMin >( size,
device_vector. getData(),
min,
device_aux. getData() );
tnlCUDASimpleReduction2< T, tnlParallelReductionMax >( size,
device_vector. getData(),
max,
device_aux. getData() );
break;
case 3:
tnlCUDASimpleReduction3< T, tnlParallelReductionSum >( size,
device_vector. getData(),
sum,
device_aux. getData() );
tnlCUDASimpleReduction3< T, tnlParallelReductionMin >( size,
device_vector. getData(),
min,
device_aux. getData() );
tnlCUDASimpleReduction3< T, tnlParallelReductionMax >( size,
device_vector. getData(),
max,
device_aux. getData() );
break;
case 4:
tnlCUDASimpleReduction4< T, tnlParallelReductionSum >( size,
device_vector. getData(),
sum,
device_aux. getData() );
tnlCUDASimpleReduction4< T, tnlParallelReductionMin >( size,
device_vector. getData(),
min,
device_aux. getData() );
tnlCUDASimpleReduction4< T, tnlParallelReductionMax >( size,
device_vector. getData(),
max,
device_aux. getData() );
break;
case 5:
tnlCUDASimpleReduction5< T, tnlParallelReductionSum >( size,
device_vector. getData(),
sum,
device_aux. getData() );
tnlCUDASimpleReduction5< T, tnlParallelReductionMin >( size,
device_vector. getData(),
min,
device_aux. getData() );
tnlCUDASimpleReduction5< T, tnlParallelReductionMax >( size,
device_vector. getData(),
max,
device_aux. getData() );
break;
default:
reductionOnCudaDevice< T, T, int, tnlParallelReductionSum >( size,
device_vector. getData(),
NULL,
sum,
0.0,
device_aux. getData() );
reductionOnCudaDevice< T, T, int, tnlParallelReductionMin >( size,
device_vector. getData(),
NULL,
min,
0.0,
device_aux. getData() );
reductionOnCudaDevice< T, T, int, tnlParallelReductionMax >( size,
device_vector. getData(),
NULL,
max,
0.0,
device_aux. getData() );
#endif
}
}
const double time = timer. getTime();
double giga_byte = ( double ) ( 1 << 30 );
long int mega_byte = 1 << 20;
long int bytes_reduced = size * sizeof( T ) * reducing_cycles * 3;
const double reduction_band_width = bytes_reduced / giga_byte / time;
cout << "Reducing " << bytes_reduced / mega_byte
<< " MB on DEVICE using algorithm " << algorithm
<< " took " << time
<< " seconds. Bandwidth is " << reduction_band_width
<< " GB/s." << endl;
}
#endif /* TNLBENCHMARKS_H_ */