/*******************************************************

* Copyright (c) 2014, ArrayFire

* All rights reserved.

*

* This file is distributed under 3-clause BSD license.

* The complete license agreement can be obtained at:

* http://arrayfire.com/licenses/BSD-3-Clause

********************************************************/

#include <af/device.h>

#include <af/timing.h>

#include <algorithm>

#include <array>

#include <cmath>

#include <vector>

using namespace af;

// get current time

static inline timer time_now() {

#if defined(OS_WIN)

timer time;

QueryPerformanceCounter(&time.val);

#elif defined(OS_MAC)

timer time = {mach_absolute_time()};

#elif defined(OS_LNX)

timer time;

gettimeofday(&time.val, NULL);

#endif

return time;

}

// absolute difference between two times (in seconds)

static inline double time_seconds(timer start, timer end) {

#if defined(OS_WIN)

if (start.val.QuadPart > end.val.QuadPart) {

timer temp = end;

end = start;

start = temp;

}

timer system_freq;

QueryPerformanceFrequency(&system_freq.val);

return (double)(end.val.QuadPart - start.val.QuadPart) /

system_freq.val.QuadPart;

#elif defined(OS_MAC)

if (start.val > end.val) {

timer temp = start;

start = end;

end = temp;

}

// calculate platform timing epoch

thread_local mach_timebase_info_data_t info;

mach_timebase_info(&info);

double nano = (double)info.numer / (double)info.denom;

return (end.val - start.val) * nano * 1e-9;

#elif defined(OS_LNX)

struct timeval elapsed {};

timersub(&start.val, &end.val, &elapsed);

long sec = elapsed.tv_sec;

long usec = elapsed.tv_usec;

double t = sec + usec * 1e-6;

return t >= 0 ? t : -t;

#endif

}

namespace af {

thread_local timer _timer_;

timer timer::start() { return _timer_ = time_now(); }

double timer::stop(timer start) { return time_seconds(start, time_now()); }

double timer::stop() { return time_seconds(_timer_, time_now()); }

double timeit(void (*fn)()) {

// Minimum target duration to limit impact of clock precision

constexpr double targetDurationPerTest = 0.050;

// samples during which the nr of cycles are determined to obtain target

// duration

constexpr int testSamples = 2;

// cycles needed to include CPU-GPU overlapping (if present)

constexpr int minCycles = 3;

// initial cycles used for the test samples

int cycles = minCycles;

// total number of real samples taken, of which the median is returned

constexpr int nrSamples = 10;

std::array<double, nrSamples> X;

for (int s = -testSamples; s < nrSamples; ++s) {

af::sync();

af::timer start = af::timer::start();

for (int i = cycles; i > 0; --i) { fn(); }

af::sync();

const double time = af::timer::stop(start);

if (s >= 0) {

// real sample, so store it for later processing

X[s] = time;

} else {

// test sample, so improve nr cycles

cycles = std::max(

minCycles,

static_cast<int>(trunc(targetDurationPerTest / time * cycles)));

};

}

std::sort(X.begin(), X.end());

// returns the median (iso of mean), to limit impact of outliers

return X[nrSamples / 2] / cycles;

}

} // namespace af