dcddaae8d2
Make number of trials in benchmarks (how many times algorithm is run) configurable from command line.
110 lines
2.4 KiB
C++
110 lines
2.4 KiB
C++
//---------------------------------------------------------------------------//
|
|
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0
|
|
// See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt
|
|
//
|
|
// See http://boostorg.github.com/compute for more information.
|
|
//---------------------------------------------------------------------------//
|
|
|
|
#ifndef PERF_HPP
|
|
#define PERF_HPP
|
|
|
|
// this header contains general purpose functions and variables used by
|
|
// the boost.compute performance benchmarks.
|
|
|
|
#include <vector>
|
|
#include <cstdlib>
|
|
#include <algorithm>
|
|
|
|
#include <boost/lexical_cast.hpp>
|
|
#include <boost/timer/timer.hpp>
|
|
|
|
static size_t PERF_N = 1024;
|
|
static size_t PERF_TRIALS = 3;
|
|
|
|
// parses command line arguments and sets the corresponding perf variables
|
|
inline void perf_parse_args(int argc, char *argv[])
|
|
{
|
|
if(argc >= 2){
|
|
PERF_N = boost::lexical_cast<size_t>(argv[1]);
|
|
}
|
|
|
|
if(argc >= 3){
|
|
PERF_TRIALS = boost::lexical_cast<size_t>(argv[2]);
|
|
}
|
|
}
|
|
|
|
// generates a vector of random numbers
|
|
template<class T>
|
|
std::vector<T> generate_random_vector(const size_t size)
|
|
{
|
|
std::vector<T> vector(size);
|
|
std::generate(vector.begin(), vector.end(), rand);
|
|
return vector;
|
|
}
|
|
|
|
// a simple timer wrapper which records multiple time entries
|
|
class perf_timer
|
|
{
|
|
public:
|
|
typedef boost::timer::nanosecond_type nanosecond_type;
|
|
|
|
perf_timer()
|
|
{
|
|
timer.stop();
|
|
}
|
|
|
|
void start()
|
|
{
|
|
timer.start();
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
timer.stop();
|
|
times.push_back(timer.elapsed().wall);
|
|
}
|
|
|
|
size_t trials() const
|
|
{
|
|
return times.size();
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
times.clear();
|
|
}
|
|
|
|
nanosecond_type last_time() const
|
|
{
|
|
return times.back();
|
|
}
|
|
|
|
nanosecond_type min_time() const
|
|
{
|
|
return *std::min_element(times.begin(), times.end());
|
|
}
|
|
|
|
nanosecond_type max_time() const
|
|
{
|
|
return *std::max_element(times.begin(), times.end());
|
|
}
|
|
|
|
boost::timer::cpu_timer timer;
|
|
std::vector<boost::timer::nanosecond_type> times;
|
|
};
|
|
|
|
// returns the rate (in MB/s) for processing 'count' items of type 'T'
|
|
// in 'time' nanoseconds
|
|
template<class T>
|
|
double perf_rate(const size_t count, perf_timer::nanosecond_type time)
|
|
{
|
|
const size_t byte_count = count * sizeof(T);
|
|
|
|
return (double(byte_count) / 1024 / 1024) / (time / 1e9);
|
|
}
|
|
|
|
#endif // PERF_HPP
|