// $Id: speedtest.h 223 2008-04-07 16:56:58Z tb $
// Not really an include file, more a base file for the speed tests.

#include <assert.h>
#include <stdint.h>
#include <math.h>
#include <time.h>

#include <vector>
#include <map>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <numeric>
#include <cmath>
#include <algorithm>
#include <limits>

// *** Speedtest Parameters ***

// speed test different buffer sizes in this range
const unsigned int buffermin = 16;
const unsigned int buffermax = 16 * 65536;
const unsigned int baserepeatsize = 65536;
const unsigned int minrepeats = 4;
const unsigned int measureruns = 16;

#ifndef _MSC_VER
#include <sys/time.h>
#else
#include <windows.h>
#endif

/// Time is measured using gettimeofday() or GetTickCount()
inline double timestamp()
{
#ifndef _MSC_VER
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec + tv.tv_usec * 0.000001;
#else
    return timeGetTime() / 1000.0;
#endif
}

// *** Global Buffers and Settings for the Speedtest Functions ***

unsigned char	enckey[32];	/// 256 bit encryption key
unsigned char	enciv[16];	/// 16 byte initialization vector if needed.

unsigned char	buffer[buffermax];	/// encryption buffer
unsigned int	bufferlen;		/// currently tested buffer length

// *** run_test() ***

/**
 * This function will run a test routine multiple times with different buffer
 * sizes configured. It measures the time required to encrypt a number of
 * bytes. The average time and standard deviation are calculated and written to
 * a log file for gnuplot.
 */

template <void (*testfunc)()>
void run_test(const char* logfile)
{
    std::cout << "Speed testing for " << logfile << "\n";

    // Save the time required for each run.
    std::map<unsigned int, std::vector<double> > timelog;
	
    for(unsigned int fullrun = 0; fullrun < measureruns; ++fullrun)
    {
        unsigned int repeatsize = baserepeatsize;

	for(unsigned int bufflen = buffermin; bufflen <= buffermax; bufflen *= 2)
	{
REDO:
	    // because small time measurements are inaccurate, repeat very fast
	    // tests until the same amount of data is encrypted as in the large
	    // tests.
	    unsigned int repeat = repeatsize / bufflen;
	    if (repeat < minrepeats) repeat = minrepeats;

	    // std::cout << "Test: bufflen " << bufflen << " repeat " << repeat << "\n";

	    bufferlen = bufflen;

	    // fill buffer
	    for(unsigned int i = 0; i < bufferlen; ++i)
		buffer[i] = (uint8_t)i;

	    double ts1 = timestamp();

	    for(unsigned int testrun = 0; testrun < repeat; ++testrun)
	    {
		testfunc();
	    }

	    double ts2 = timestamp();

	    double tsdelta = ts2 - ts1;

	    // Adapt number of repetitions to the clock's accuracy.
	    if (tsdelta < 0.5) {
       		printf("Run %d bufferlen %d repeat %d took only %.2f sec. Increasing repetitons.\n",
		       fullrun, bufferlen, repeat, tsdelta);
		repeatsize *= 2;
		goto REDO;
	    }
	    else {
       		printf("Run %d bufferlen %d repeat %d took %.2f sec.\n",
		       fullrun, bufferlen, repeat, tsdelta);
	    }

	    // check buffer status after repeated en/decryption
	    for(unsigned int i = 0; i < bufferlen; ++i)
		assert(buffer[i] == (uint8_t)i);

	    timelog[bufferlen].push_back( tsdelta / (double)repeat );
	}
    }

    // Calculate and output statistics.
    std::ofstream of (logfile);

    // First output time absolute measurements
    for(std::map<unsigned int, std::vector<double> >::const_iterator ti = timelog.begin();
	ti != timelog.end(); ++ti)
    {
	const std::vector<double>& timelist = ti->second;

	double average = std::accumulate(timelist.begin(), timelist.end(), 0.0) / timelist.size();

	double variance = 0.0;
	for(unsigned int i = 0; i < timelist.size(); ++i)
	{
	    variance += (timelist[i] - average) * (timelist[i] - average);
	}
	variance = variance / (timelist.size() - 1);

	double stddev = std::sqrt(variance);

	if (timelist.size() == 1) { // only one run -> no variance or stddev
	    variance = stddev = 0.0;
	}

	double vmin = *std::min_element(timelist.begin(), timelist.end());
	double vmax = *std::max_element(timelist.begin(), timelist.end());

	of << std::setprecision(16);
	of << ti->first << " " << average << " " << stddev << " " << vmin << " " << vmax << "\n";
    }
    of << "\n\n";

    // Second output speed measurements
    for(std::map<unsigned int, std::vector<double> >::const_iterator ti = timelog.begin();
	ti != timelog.end(); ++ti)
    {
	const std::vector<double>& timelist = ti->second;

	double average = 0.0;
	double vmin = std::numeric_limits<double>::infinity();
	double vmax = 0;

	for(unsigned int i = 0; i < timelist.size(); ++i)
	{
	    average += (double)ti->first / timelist[i];
	    vmin = std::min<double>(vmin, (double)ti->first / timelist[i]);
	    vmax = std::max<double>(vmax, (double)ti->first / timelist[i]);
	}
	average /= timelist.size();

	double variance = 0.0;
	for(unsigned int i = 0; i < timelist.size(); ++i)
	{
	    double delta = ((double)ti->first / timelist[i]) - average;
	    variance += delta * delta;
	}
	variance = variance / (timelist.size() - 1);

	double stddev = std::sqrt(variance);

	if (timelist.size() == 1) { // only one run -> no variance or stddev
	    variance = stddev = 0.0;
	}

	of << std::setprecision(16);
	of << ti->first << " " << average << " " << stddev << " " << vmin << " " << vmax << "\n";
    }
    of.close();
}