performanceTestClasses.h

Go to the documentation of this file.

/*   rambrain - a dynamical physical memory extender
 *   Copyright (C) 2015 M. Imgrund, A. Arth
 *   mimgrund (at) mpifr-bonn.mpg.de
 *   arth (at) usm.uni-muenchen.de
 *
 *   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 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef PERFORMANCETESTCLASSES_H
#define PERFORMANCETESTCLASSES_H

#include <iostream>
#include <vector>
#include <cstring>
#include <cmath>
#include <string>
#include <sstream>
#include <cstdlib>
#include <map>
#include <inttypes.h>

#include "tester.h"

#include "managedFileSwap.h"
#include "cyclicManagedMemory.h"
#include "managedPtr.h"
#include "rambrainconfig.h"

using namespace std;
using namespace rambrain;

class testParameterBase
{
public:
    virtual ~testParameterBase() {}

    virtual string valueAsString() = 0;
    virtual string valueAsString ( unsigned int step ) = 0;

    unsigned int steps;
    bool deltaLog;
    string name;
    bool enabled = true;
};


template<typename T>
class testParameter : public testParameterBase
{

public:
    virtual ~testParameter() {}

    virtual inline string valueAsString() {
        return toString ( mean );
    }

    virtual inline string valueAsString ( unsigned int step ) {
        return toString ( valueAtStep ( step ) );
    }

    T min, max, mean;

protected:
    T valueAtStep ( unsigned int step ) {
        if ( steps < 2 ) {
            return min;
        } else if ( deltaLog ) {
            return pow ( 10.0, ( log10 ( max ) - log10 ( min ) ) * step / ( steps - 1 ) ) * min;
        } else {
            return ( max - min ) * step / ( steps - 1 ) + min;
        }
    }

    string toString ( const T &t ) {
        stringstream ss;
        ss << t;
        return ss.str();
    }

};


template<typename... U>
class performanceTest;


template<>
class performanceTest<>
{

public:
    performanceTest ( const char *name );
    virtual ~performanceTest() {}

    virtual void runTests ( unsigned int repetitions, const string &path = "./" );
    static void runRegisteredTests ( unsigned int repetitions, const string &path = "./" );
    static void enableTest ( const string &name, bool enabled );
    static void enableAllTests ( bool enabled );
    static void unregisterTest ( const string &name );
    static void dumpTestInfo();

    static bool runRespectiveTest ( const string &name, tester &myTester, unsigned int repetitions, char **arguments, int &offset, int argumentscount );

    virtual void actualTestMethod ( tester &test, char **arguments, int &offset, unsigned int argumentscount ) = 0;

    virtual string getComment() = 0;

    inline static void setDisplayPlots ( bool display ) {
        displayPlots = display;
    }

protected:
    virtual inline unsigned int getStepsForParam ( unsigned int varryParam ) {
        return parameters[varryParam]->steps;
    }

    virtual string getParamsString ( int varryParam, unsigned int step, const string &delimiter = " " );
    virtual string getTestOutfile ( int varryParam, unsigned int step );
    virtual void resultToTempFile ( int varryParam, unsigned int step, ofstream &file );
    virtual vector<string> splitString ( const string &in, char delimiter );
    virtual string generateGnuplotScript ( const string &infile, const string &name, const string &xlabel, const string &ylabel, const string &title, bool log, int paramColumn );
    virtual void handleTimingInfos ( int varryParam, unsigned int step, unsigned int repetitions );
    virtual vector<vector<string>> getRelevantTimingParts ( ifstream &in, unsigned long long start, unsigned long long end );
    virtual void timingInfosToFile ( ofstream &out, const vector<vector<string>> &relevantTimingParts, unsigned long long &starttime );
    virtual void plotTimingInfos ( ofstream &gnutemp, const string &outname, const string &dataFile, unsigned int measurements, unsigned int repetitions, bool linesPoints );
    virtual void plotTimingHitMissInfos ( ofstream &gnutemp, const string &outname, const string &dataFile, unsigned int measurements, unsigned int repetitions, bool linesPoints );

    virtual string generateMyGnuplotPlotPart ( const string &file, int paramColumn ) = 0;

    const char *name;
    bool enabled = true;
    vector<testParameterBase *> parameters;
    static map<string, performanceTest<> *> testClasses;
    vector<string> plotParts;
    static bool displayPlots;
    bool plotTimingStats = true;

};


template<typename T, typename... U>
class performanceTest<T, U...> : public performanceTest<U...>
{

public:
    performanceTest ( const char *name ) : performanceTest<U...> ( name ) {
        this->parameters.push_back ( &parameter );
    }

    virtual ~performanceTest() {}

protected:
    testParameter<T> parameter;

};


#define PARAMREFS(number, param, params...) testParameter<param> &parameter##number = (performanceTest<param, ##params>::parameter)

#define ONEPARAM(param) PARAMREFS(1, param)
#define TWOPARAMS(param1, param2) PARAMREFS(1, param1, param2); \
                                  PARAMREFS(2, param2)
#define THREEARAMS(param1, param2, param3) PARAMREFS(1, param1, param2, param3); \
                                           PARAMREFS(2, param2, param3); \
                                           PARAMREFS(3, param3)

#define ONECONVERT(param) param p = convert<param>(arguments[offset++]); \
                          actualTestMethod(test, p)
#define TWOCONVERT(param1, param2) param1 p1 = convert<param1>(arguments[offset++]); \
                                   param2 p2 = convert<param2>(arguments[offset++]); \
                                   actualTestMethod(test, p1, p2)
#define THREECONVERT(param1, param2, param3) param1 p1 = convert<param1>(arguments[offset++]); \
                                             param2 p2 = convert<param2>(arguments[offset++]); \
                                             param3 p3 = convert<param3>(arguments[offset++]); \
                                             actualTestMethod(test, p1, p2, p3)

#define TESTCLASS(name, parammacro, convertmacro, params...) \
    class name : public performanceTest<params> \
    { \
    public: \
        name(); \
        virtual ~name() {} \
        virtual inline void actualTestMethod(tester& test, char **arguments, int& offset, unsigned int argumentscount); \
        virtual void actualTestMethod(tester&, params); \
        virtual inline string getComment() { return comment; } \
        parammacro; \
        static string comment; \
    protected: \
        virtual string generateMyGnuplotPlotPart(const string& file, int paramColumn); \
        template<typename T> \
        inline T convert(char* str) { \
            return T(str); \
        } \
    }; \
    template<> \
    inline int name::convert<int>(char* str) { \
        return atoi(str); \
    } \
    void name::actualTestMethod(tester& test, char **arguments, int& offset, unsigned int argumentscount) { \
        if (argumentscount - offset < parameters.size()) { \
            cerr << "Not enough parameters supplied for test!" << endl; \
        } else {\
            convertmacro; \
        } \
    } \
    extern name name##Instance

#define ONEPARAMTEST(name, param) TESTCLASS(name, ONEPARAM(param), ONECONVERT(param), param)
#define TWOPARAMTEST(name, param1, param2) TESTCLASS(name, TWOPARAMS(param1, param2), TWOCONVERT(param1, param2), param1, param2)
#define THREEPARAMTEST(name, param1, param2, param3) TESTCLASS(name, THREEPARAMS(param1, param2, param3), THREECONVERT(param1, param2, param3), param1, param2, param3)


// Actual performance test classes come here

TWOPARAMTEST ( matrixTransposeTest, int, int );
TWOPARAMTEST ( matrixCleverTransposeTest, int, int );
TWOPARAMTEST ( matrixCleverTranspose2Test, int, int );
#ifndef OpenMP_NOT_FOUND
TWOPARAMTEST ( matrixCleverTransposeOpenMPTest, int, int );
#endif
TWOPARAMTEST ( matrixCleverBlockTransposeTest, int, int );
#ifndef OpenMP_NOT_FOUND
TWOPARAMTEST ( matrixCleverBlockTransposeOpenMPTest, int, int );
#endif
TWOPARAMTEST ( matrixMultiplyTest, int, int );
#ifndef OpenMP_NOT_FOUND
TWOPARAMTEST ( matrixMultiplyOpenMPTest, int, int );
#endif
TWOPARAMTEST ( matrixCopyTest, int, int );
#ifndef OpenMP_NOT_FOUND
TWOPARAMTEST ( matrixCopyOpenMPTest, int, int );
#endif
TWOPARAMTEST ( matrixDoubleCopyTest, int, int );
#ifndef OpenMP_NOT_FOUND
TWOPARAMTEST ( matrixDoubleCopyOpenMPTest, int, int );
#endif
TWOPARAMTEST ( measureThroughputTest, int, int );
TWOPARAMTEST ( measurePreemptiveSpeedupTest, int, int );
TWOPARAMTEST ( measureExplicitAsyncSpeedupTest, int, int );
ONEPARAMTEST ( measureConstSpeedupTest, int );
ONEPARAMTEST ( demonstrateDecayTest, int );
#endif // PERFORMANCETESTCLASSES_H