#include <stdlib.h>
#include <time.h>
#include <chrono>
#include <stdio.h>
#include <iostream>
#include <vector>

using namespace std;

static const int s_iArrayLen = 999999;
static const int s_iMaxPipelineLen = 60;
static const int s_iNumTrials = 10;


int doWorkAndReturnMicrosecondsElapsed(int* vals, int pipelineLen)
{
    int* zeroNums = new int[pipelineLen];
    int* oneNums = new int[pipelineLen];
    for(int i = 0; i < pipelineLen; ++i)
        zeroNums[i] = oneNums[i] = 0;

    chrono::time_point<chrono::system_clock> start, end;
    start = chrono::system_clock::now();
    for(int i = 0; i < s_iArrayLen; ++i)
    {
        if(vals[i] == 0)
        {
            for(int i = 0; i < pipelineLen; ++i)
                ++zeroNums[i];
        }
        else
        {
            for(int i = 0; i < pipelineLen; ++i)
                ++oneNums[i];
        }
    }
    end = chrono::system_clock::now();
    int elapsedMicroseconds = (int)chrono::duration_cast<chrono::microseconds>(end-start).count();

    //This should never fire, it just exists to guarantee the compiler doesn't compile out our zeroNums/oneNums
    for(int i = 0; i < pipelineLen - 1; ++i)
        if(zeroNums[i] != zeroNums[i+1] || oneNums[i] != oneNums[i+1])
            return -1;

    delete[] zeroNums;
    delete[] oneNums;

    return elapsedMicroseconds;
}


struct TestMethod
{
    string name;
    void (*func)(int, int&);
    int* results;

    TestMethod(string _name, void (*_func)(int, int&)) { name = _name; func = _func; results = new int[s_iMaxPipelineLen]; }
};

int main()
{
    srand( (unsigned int)time(nullptr) );

    vector<TestMethod> testMethods;
    testMethods.push_back(TestMethod("all-zero", [](int index, int& out) { out = 0; } ));
    testMethods.push_back(TestMethod("repeat-0-1", [](int index, int& out) { out = index % 2; } ));
    testMethods.push_back(TestMethod("repeat-0-0-0-1", [](int index, int& out) { out = (index % 4 == 0) ? 0 : 1; } ));
    testMethods.push_back(TestMethod("rand", [](int index, int& out) { out = rand() % 2; } ));


    int* vals = new int[s_iArrayLen];

    for(int currentPipelineLen = 0; currentPipelineLen < s_iMaxPipelineLen; ++currentPipelineLen)
    {
        for(int currentMethod = 0; currentMethod < (int)testMethods.size(); ++currentMethod)
        {
            int resultsSum = 0;
            for(int trialNum = 0; trialNum < s_iNumTrials; ++trialNum)
            {
                //Generate a new array...
                for(int i = 0; i < s_iArrayLen; ++i)
                    testMethods[currentMethod].func(i, vals[i]);

                //And record how long it takes
                resultsSum += doWorkAndReturnMicrosecondsElapsed(vals, currentPipelineLen);
            }

            testMethods[currentMethod].results[currentPipelineLen] = (resultsSum / s_iNumTrials);
        }
    }

    cout << "\t";
    for(int i = 0; i < s_iMaxPipelineLen; ++i)
    {
        cout << i << "\t";
    }
    cout << "\n";
    for (int i = 0; i < (int)testMethods.size(); ++i)
    {
        cout << testMethods[i].name.c_str() << "\t";
        for(int j = 0; j < s_iMaxPipelineLen; ++j)
        {
            cout << testMethods[i].results[j] << "\t";
        }
        cout << "\n";
    }

    int end;
    cin >> end;

    delete[] vals;
}