// Copyright Sebastian Jeckel 2014.

// 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)

#pragma once

#include <functional>

#include <iostream>

#include <vector>

#include "tbb/tick_count.h"

#include "BenchmarkBase.h"

#include "react/Signal.h"

using namespace react;

///////////////////////////////////////////////////////////////////////////////////////////////////

/// GridGraphGenerator

///////////////////////////////////////////////////////////////////////////////////////////////////

template

<

typename D,

typename TValue

>

class GridGraphGenerator

{

public:

using MySignal = Signal<D,TValue>;

using Func1T = std::function<TValue(TValue)>;

using Func2T = std::function<TValue(TValue,TValue)>;

using SignalVectT = std::vector<MySignal>;

using WidthVectT = std::vector<size_t>;

SignalVectT InputSignals;

SignalVectT OutputSignals;

Func1T Function1;

Func2T Function2;

WidthVectT Widths;

void Generate()

{

assert(InputSignals.size() >= 1);

assert(Widths.size() >= 1);

SignalVectT buf1 = InputSignals;

SignalVectT buf2;

SignalVectT* curBuf = &buf1;

SignalVectT* nextBuf = &buf2;

size_t curWidth = InputSignals.size();

size_t nodeCount = 1;

nodeCount += curWidth;

for (auto targetWidth : Widths)

{

while (curWidth != targetWidth)

{

// Grow or shrink?

bool shouldGrow = targetWidth > curWidth;

auto l = curBuf->begin();

auto r = curBuf->begin();

if (r != curBuf->end())

++r;

if (shouldGrow)

{

auto s = (*l) ->* Function1;

nextBuf->push_back(s);

}

while (r != curBuf->end())

{

auto s = (*l,*r) ->* Function2;

nextBuf->push_back(s);

nodeCount++;

++l; ++r;

}

if (shouldGrow)

{

auto s = (*l) ->* Function1;

nextBuf->push_back(s);

nodeCount++;

}

curBuf->clear();

// Swap buffer pointers

SignalVectT* t = curBuf;

curBuf = nextBuf;

nextBuf = t;

if (shouldGrow)

curWidth++;

else

curWidth--;

}

}

//printf ("NODE COUNT %d\n", nodeCount);

OutputSignals.clear();

OutputSignals.insert(OutputSignals.begin(), curBuf->begin(), curBuf->end());

}

};

///////////////////////////////////////////////////////////////////////////////////////////////////

/// Benchmark_Grid

///////////////////////////////////////////////////////////////////////////////////////////////////

struct BenchmarkParams_Grid

{

BenchmarkParams_Grid(int n, int k) :

N(n),

K(k)

{}

void Print(std::ostream& out) const

{

out << "N = " << N

<< ", K = " << K;

}

const int N;

const int K;

};

template <typename D>

struct Benchmark_Grid : public BenchmarkBase<D>

{

double Run(const BenchmarkParams_Grid& params)

{

auto in = MakeVar<D>(1);

GridGraphGenerator<D,int> generator;

generator.InputSignals.push_back(in);

generator.Widths.push_back(params.N);

generator.Widths.push_back(1);

generator.Function1 = [] (int a) { return a; };

generator.Function2 = [] (int a, int b) { return a + b; };

generator.Generate();

auto t0 = tbb::tick_count::now();

for (int i=0; i<params.K; i++)

in <<= 10+i;

auto t1 = tbb::tick_count::now();

double d = (t1 - t0).seconds();

//printf("Time %g\n", d);

return d;

}

};