|| || || || || || || ||

---

TimePlot.h

Go to the documentation of this file.

#ifndef Impala_Util_TimePlot_h
#define Impala_Util_TimePlot_h

#include <iostream>
#include <string>
#include "Basis/Timer.h"

namespace Impala
{
namespace Util
{


class TimePlot {
public:

    TimePlot(int nrFunctions, int nrXCoords, int* xCoords, int nrSplitTimes,
             int nrRuns) : mTimer0(0), mTimer1(1)
    {
        mNrFunctions = nrFunctions;
        mNrXCoords = nrXCoords;
        mXCoords = new int[nrXCoords];
        for (int x=0 ; x<nrXCoords ; x++)
            mXCoords[x] = xCoords[x];
        mNrSplitTimes = nrSplitTimes;
        mNrRuns = nrRuns;
        mNrTimers = 2;
        mRunDataSize = mNrSplitTimes + 1; // +1 for final time
        mXCoordDataSize = mRunDataSize * mNrRuns; 
        mFuncDataSize = mNrXCoords * mXCoordDataSize;
        mTimerDataSize = mNrFunctions * mFuncDataSize;
        mData = new double[mNrTimers * mTimerDataSize];
    }

    ~TimePlot()
    {
        delete mXCoords;
        delete mData;
    }

    void
    Start(int function, int xCoord, int run) // start counting at 0
    {
        mCurFunc = function;
        mCurXCoord = xCoord;
        mCurDataPtr0 = GetPtr(0, mCurFunc, mCurXCoord, 0, run);
        mCurDataPtr1 = GetPtr(1, mCurFunc, mCurXCoord, 0, run);
        mTimer0.Start();
        mTimer1.Start();
    }

    void
    SplitTime()
    {
        *mCurDataPtr0++ = mTimer0.SplitTime();
        *mCurDataPtr1++ = mTimer1.SplitTime();
    }

    void
    Stop()
    {
        *mCurDataPtr0 = mTimer0.Stop();
        *mCurDataPtr1 = mTimer1.Stop();
    }

    void
    PrintAverageFinal(FILE* fp, int timer)
    {
        PrintAverageSplit(fp, timer, mNrSplitTimes);
    }

    void
    PrintAverageSplit(FILE* fp, int timer, int split) // start counting at 0
    {
        fprintf(fp, "\n\n# Average of split %d using timer mode %d\n",
                split, timer);
        if (split == mNrSplitTimes)
            fprintf(fp, "# This split is actually the end time\n");
        for (int x=0 ; x<mNrXCoords ; x++)
        {
            fprintf(fp, "%d", mXCoords[x]);
            for (int f=0 ; f<mNrFunctions ; f++)
            {
                double avg = 0;
                for (int r=0 ; r<mNrRuns ; r++)
                    avg += *GetPtr(timer, f, x, split, r);
                avg /= mNrRuns;
                fprintf(fp, "\t%f", avg);
            }
            fprintf(fp, "\n");
        }
    }

    void
    PrintRunsSplit(FILE* fp, int timer, int function, int split)
    {
        fprintf(fp, "\n\n# All of split %d of func %d using timer mode %d\n",
                split, function, timer);
        if (split == mNrSplitTimes)
            fprintf(fp, "# This split is actually the end time\n");
        for (int x=0 ; x<mNrXCoords ; x++)
        {
            fprintf(fp, "%d", mXCoords[x]);
            for (int r=0 ; r<mNrRuns ; r++)
                fprintf(fp, "\t%f", *GetPtr(timer, function, x, split, r));
            fprintf(fp, "\n");
        }
    }

    void
    SaveData(std::string machineName, std::string experiment,
             std::string imageName, std::string* funcName)
    {
        std::string baseName = machineName + "/" + machineName + "_" + experiment +
            "_" + imageName;
        printf("Saving data %s\n", baseName.c_str());

        // data, timer = 0

        std::string fileName = baseName + "_proctime.dat";
        FILE* fp;
        if (! (fp = DoOpenFile(fileName)))
            return;
        DoSaveData(fp, machineName, experiment, imageName, 0, funcName);
        fclose(fp);

        // data, timer = 1

        fileName = baseName + "_realtime.dat";
        if (! (fp = DoOpenFile(fileName)))
            return;
        DoSaveData(fp, machineName, experiment, imageName, 1, funcName);
        fclose(fp);

        // gnuplot files

        fileName = baseName + "_proctime.gp";
        if (! (fp = DoOpenFile(fileName)))
            return;
        DoWriteGpBase(fp, machineName, experiment, imageName,
                      std::string("proctime"));
        fclose(fp);

        fileName = baseName + "_realtime.gp";
        if (! (fp = DoOpenFile(fileName)))
            return;
        DoWriteGpBase(fp, machineName, experiment, imageName,
                      std::string("realtime"));
        fclose(fp);

        fileName = baseName + "_split_average.gp";
        if (! (fp = DoOpenFile(fileName)))
            return;
        DoWriteGpSplitAverage(fp, machineName, experiment, imageName, funcName);
        fclose(fp);

        fileName = baseName + "_func_decomp.gp";
        if (! (fp = DoOpenFile(fileName)))
            return;
        DoWriteGpFuncDecomp(fp, machineName, experiment, imageName);
        fclose(fp);

        fileName = baseName + "_func_runs.gp";
        if (! (fp = DoOpenFile(fileName)))
            return;
        DoWriteGpFuncRuns(fp, machineName, experiment, imageName);
        fclose(fp);
    }

private:

    FILE*
    DoOpenFile(std::string fileName)
    {
        FILE* fp = fopen(fileName.c_str(), "w") ;
        if (!fp)
        {
            std::cout << "TimePlot: Error opening file " << fileName << std::endl;
            return 0;
        }
        return fp;
    }

    void
    DoSaveData(FILE* fp, std::string machineName, std::string experiment,
               std::string imageName, int timer, std::string* funcName)
    {
        fprintf(fp, "# machine %s, experiment %s, image %s, timer %d\n",
                machineName.c_str(), experiment.c_str(), imageName.c_str(), timer);
        fprintf(fp, "# %d runs with %d splitTimes on %d functions : \n", mNrRuns,
                mNrSplitTimes, mNrFunctions);
        for (int i=0 ; i<mNrFunctions ; i++)
            fprintf(fp, "# func %d = %s\n", i, funcName[i].c_str());
        PrintAverageFinal(fp, timer);
        for (int split=0 ; split<mNrSplitTimes ; split++)
            PrintAverageSplit(fp, timer, split);
        for (int function=0 ; function<mNrFunctions ; function++)
            PrintRunsSplit(fp, timer, function, mNrSplitTimes);
    }

    void
    DoWriteGpBase(FILE* fp, std::string machineName, std::string experiment,
                  std::string imageName, std::string timer)
    {
        int i;
        for (i=0 ; i<=mNrSplitTimes ; i++)
            fprintf(fp, "call '%s_%s_%s_split_average.gp' %s %d\n",
                    machineName.c_str(), experiment.c_str(), imageName.c_str(),
                    timer.c_str(), i);
        fprintf(fp, "\n");
        for (i=0 ; i<mNrFunctions ; i++)
            fprintf(fp, "call '%s_%s_%s_func_decomp.gp' %s %d\n",
                    machineName.c_str(), experiment.c_str(), imageName.c_str(),
                    timer.c_str(), i);
        fprintf(fp, "\n");
        for (i=0 ; i<mNrFunctions ; i++)
            fprintf(fp, "call '%s_%s_%s_func_runs.gp' %s %d\n",
                    machineName.c_str(), experiment.c_str(), imageName.c_str(),
                    timer.c_str(), i);
    }

    void
    DoWriteGpSplitAverage(FILE* fp, std::string machineName, std::string experiment,
                          std::string imageName, std::string* funcName)
    {
        fprintf(fp, "print \"%s_%s_%s_split_average timer=[$0] split=[$1]\"\n\n",
                machineName.c_str(), experiment.c_str(), imageName.c_str());
        fprintf(fp, "set xlabel 'Kernel size'\n");
        fprintf(fp, "set ylabel 'Time'\n");
        fprintf(fp, "set key left top\n");
        fprintf(fp, "set data style linespoints\n\n\n");
        fprintf(fp, "set title '%s . %s . %s . average of split $1 . $0'\n",
                machineName.c_str(), experiment.c_str(), imageName.c_str());
        fprintf(fp, "plot ");
        for (int i=0 ; i<mNrFunctions ; i++)
        {
            if (i>0)
                fprintf(fp, ", \\\n     ");
            fprintf(fp, "'%s_%s_%s_$0.dat' index $1 using 1:%d title '%s'",
                    machineName.c_str(), experiment.c_str(), imageName.c_str(),
                    2+i, funcName[i].c_str());
        }
        fprintf(fp, "\n\npause -1 \"Hit return\"\n");
    }

    void
    DoWriteGpFuncDecomp(FILE* fp, std::string machineName, std::string experiment,
                        std::string imageName)
    {
        fprintf(fp, "print \"%s_%s_%s_func_decomp timer=[$0] func=[$1]\"\n\n",
                machineName.c_str(), experiment.c_str(), imageName.c_str());
        fprintf(fp, "set xlabel 'Kernel size'\n");
        fprintf(fp, "set ylabel 'Time'\n");
        fprintf(fp, "set key left top\n");
        fprintf(fp, "set data style linespoints\n\n\n");
        fprintf(fp, "set title '%s . %s . %s . decomposition function $1 . $0'\n",
                machineName.c_str(), experiment.c_str(), imageName.c_str());
        fprintf(fp, "plot ");
        for (int i=0 ; i<=mNrSplitTimes ; i++)
        {
            if (i>0)
                fprintf(fp, ", \\\n     ");
            fprintf(fp, "'%s_%s_%s_$0.dat' index %d using 1:2+$1 ",
                    machineName.c_str(), experiment.c_str(), imageName.c_str(), i);
            if (i == 0)
                fprintf(fp, "title 'final'");
            else
                fprintf(fp, "title 'split %d'", i);
        }
        fprintf(fp, "\n\npause -1 \"Hit return\"\n");
    }

    void
    DoWriteGpFuncRuns(FILE* fp, std::string machineName, std::string experiment,
                      std::string imageName)
    {
        fprintf(fp, "print \"%s_%s_%s_func_runs timer=[$0] func=[$1]\"\n\n",
                machineName.c_str(), experiment.c_str(), imageName.c_str());
        fprintf(fp, "set xlabel 'Kernel size'\n");
        fprintf(fp, "set ylabel 'Time'\n");
        fprintf(fp, "set key left top\n");
        fprintf(fp, "set data style linespoints\n\n\n");
        fprintf(fp, "set title '%s . %s . %s . all runs of function $1 . $0'\n",
                machineName.c_str(), experiment.c_str(), imageName.c_str());
        fprintf(fp, "plot '%s_%s_%s_$0.dat' index 0 using 1:2+$1 title 'average'",
                machineName.c_str(), experiment.c_str(), imageName.c_str());
        for (int i=0 ; i<mNrRuns ; i++)
        {
            fprintf(fp, ", \\\n     ");
            fprintf(fp, "'%s_%s_%s_$0.dat' index %d+$1 using 1:%d title 'run %d'",
                    machineName.c_str(), experiment.c_str(), imageName.c_str(),
                    mNrSplitTimes+1, 2+i, 1+i);
        }
        fprintf(fp, "\n\npause -1 \"Hit return\"\n");
    }

    double*
    GetPtr(int timer, int function, int xCoord, int split, int run)
    {
        return mData + timer * mTimerDataSize + function * mFuncDataSize 
            + xCoord * mXCoordDataSize + run * mRunDataSize + split;
    }

/* Memory layout data:

timer0 | function0 = run0 ; run1 ; run2       with run = split0 ; split1 ; ...
       | function1 = run0 ; run1 ; run2
       | function3
       | ...
timer1 | function0
       | ...
*/

    int     mNrFunctions;
    int     mNrXCoords;
    int*    mXCoords;
    int     mNrSplitTimes;
    int     mNrRuns;
    int     mNrTimers;
    Timer   mTimer0;
    Timer   mTimer1;
    double* mData;
    int     mTimerDataSize;
    int     mFuncDataSize;
    int     mXCoordDataSize;
    int     mRunDataSize;
    int     mCurFunc;
    int     mCurXCoord;
    int     mCurSplit;
    int     mCurRun;
    double* mCurDataPtr0;
    double* mCurDataPtr1;

};

} // namespace Util
} // namespace Impala

#endif

---