// Benchmark.h: Benchmark functions for CPU tests



#ifndef __BENCHMARK_H

#define __BENCHMARK_H



#if (defined _WIN32) || (defined _WIN32_WCE)

#define ITS_WINDOWS

#endif



#ifdef ITS_WINDOWS

#include <windows.h>

#endif



#include <stdlib.h>

#include <string.h>

#include <time.h>



#if defined(_M_X64) || defined(_M_AMD64) || defined(__x86_64__)

#define MY_CPU_AMD64

#endif



#if defined(_M_IX86) || defined(__i386__)

#define MY_CPU_X86

#endif



#if defined(MY_CPU_X86) || defined(MY_CPU_AMD64)

#define MY_CPU_X86_OR_AMD64

#endif



#if defined(__sparc_v9__) || (defined(__sparc__) && defined(__arch64__))

#define MY_CPU_SPARCV9

#endif



typedef unsigned UInt32;

#ifdef __GNUC__

typedef long long int Int64;

typedef unsigned long long int UInt64;

#else

typedef __int64 Int64;

typedef unsigned __int64 UInt64;

#endif



UInt64 GetTimeCount2()

{

  #ifdef ITS_WINDOWS

  LARGE_INTEGER value; if (::QueryPerformanceCounter(&value)) return value.QuadPart;

  return GetTickCount();

  #else

  return clock();

  #endif

}



UInt64 GetFreq2()

{

  #ifdef ITS_WINDOWS

  LARGE_INTEGER value; if (::QueryPerformanceFrequency(&value)) return value.QuadPart;

  return 1000;

  #else

  return CLOCKS_PER_SEC;

  #endif

}



#if defined(MY_CPU_X86_OR_AMD64) || defined(MY_CPU_SPARCV9)

#define CYCLES_MODE

#define TIMER_IS_FAST

#endif



inline UInt64 GetTimeCount()

{

  #if defined(_WIN32) && defined(MY_CPU_X86_OR_AMD64)

    #ifdef _WIN64

      return __rdtsc();

    #else

      UInt32 valueLow, valueHigh;

      __asm RDTSC;

      __asm mov valueLow, EAX;

      __asm mov valueHigh, EDX;

      return ((UInt64)(valueHigh) << 32) | valueLow;

    #endif

  #elif defined(__GNUC__) && defined (MY_CPU_X86_OR_AMD64)

    UInt64 value;

    __asm__ __volatile__("rdtsc" : "=A" (value));

    return value;

  #elif defined(__GNUC__) && defined (_ARCH_PPC)

    UInt32 valueLow, valueHigh, valueHigh2;

    do

    {

      __asm__ __volatile__("mftbu %0" : "=r" (valueHigh));

      __asm__ __volatile__("mftb %0"  : "=r" (valueLow));

      __asm__ __volatile__("mftbu %0" : "=r" (valueHigh2));

    }

    while (valueHigh2 != valueHigh)

    return ((UInt64)(valueHigh) << 32) | valueLow;

  #elif defined(__GNUC__) && defined(MY_CPU_SPARCV9)

    UInt64 value;

    #ifdef __arch64__

    __asm__ __volatile__("rd %%tick,%0" : "=r" (value));

    #else

    __asm__ __volatile__("rd %%tick,%%g1\n\t"

                         "stx %%g1,%0"

                         : "=m" (value) :: "g1");

    #endif

  #else

  return GetTimeCount2();

  #endif

}



#if defined(ITS_WINDOWS) && !defined(UNDER_CE)

#define MY_SET_AFFINITY_NUMBER(n) SetThreadAffinityMask(GetCurrentThread(), 1 << (n))

#else

#define MY_SET_AFFINITY_NUMBER(n)

#endif



#define MY_SET_AFFINITY MY_SET_AFFINITY_NUMBER(0)



class CRandomGenerator

{

  UInt32 A1;

  UInt32 A2;

public:

  CRandomGenerator() { Init(); }

  void Init() { A1 = 362436069; A2 = 521288629;}

  UInt32 GetRnd()

  {

    return

      ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) +

      ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)) );

  }

  UInt64 GetRnd64()

  {

    UInt64 res = ((UInt64)GetRnd()) << 32;

    return res | GetRnd();

  }

  UInt32 GetRnd32(UInt32 size)

  {

    return (UInt32)(GetRnd64() % size);

  }

};



struct CPrinter

{

  char *buf;

  size_t pos;

  size_t size;

  

  CPrinter(int size)

  {

    buf = new char[size];

    this->size = size;

    Init();

  }

  void Init()

  {

    pos = 0;

    *buf = 0;

  }

  void Print(const char *s);

  void NewLine();

};



void CPrinter::Print(const char *s)

{

  size_t len = strlen(s);

  size_t rem = size - pos;

  if (len >= rem)

    len = rem - 1;

  memcpy(buf + pos, s, len);

  pos += len;

  buf[pos] = 0;

}



void CPrinter::NewLine()

{

  Print("\n");

}



#endif