#include "RealTime.h"
#include<random>
#include<iostream>
#include<iterator>

#include <thread>
#include <cstdatomic>
#include <functional>
#include <algorithm>
#include<vector>
#include<list>
// convert gcc to c0xx
#define thread_local __thread

typedef std::thread Thread;
typedef std::vector<std::thread> ThreadGroup;
typedef std::mutex Mutex;
typedef std::unique_lock<std::mutex> Guard;
typedef std::condition_variable Condition;

#include<sstream>

long long threadId() {
  std::stringstream ss;
  ss << std::this_thread::get_id();
  long long id;
  ss >> id;
  return id;
}



volatile long start;
void wait() {
  __sync_add_and_fetch(&start,-1);
  do{}while(start);
}


volatile long stop;

class Hist {
public:
  
  class Buffer {
  public:
    Buffer(Hist & ih) : h(ih), bsize(0){}
    ~Buffer() {fillFromBuffer();}
   
    void fill(int i) {
      if (100== bsize) fillFromBuffer();
      buffer[bsize++]=i;
    }

  private:
    void  fillFromBuffer() {
      Guard g(h.gl);
      for (int i=0; i!=bsize; ++i) ++h.h[buffer[i]];
      bsize=0;
    }


  private:
    Hist & h;
    int buffer[100];
    int bsize;
    friend class Hist;

  };


  Hist(int nlocks) : locks(new Mutex[nlocks]), stride(256/nlocks){
    for (int i=0; i<256; ++i) h[i]=0;
  }
  ~Hist() {}
  
  void fill(int i) {
    Guard g(locks[i/stride]);
    ++h[i];
  }
  
  
  std::unique_ptr<Mutex[]> locks;
  int stride;
  int h[256];
  // std::atomic<int> h[256];

  Mutex gl;


};


class Filler {
public:
  Filler(Hist& h) : hist(h){}

  void operator()() {
    std::mt19937 eng;
    std::uniform_int<int> ugen(0,255);
    eng.seed(threadId());
    {
      Hist::Buffer buffer(hist);
      wait();
      for (int i=0; i<1000000; ++i) {
	// buffer.fill(ugen(eng));
	hist.fill(ugen(eng));
      }
    }
    __sync_add_and_fetch(&stop,-1);
  }
  
  Hist & hist;
};


int main() {
  
  const int NUMTHREADS=10;
  start=NUMTHREADS+1;
  stop=NUMTHREADS;

  Hist hist (NUMTHREADS);
  Filler filler(hist);

  ThreadGroup threads;
  threads.reserve(NUMTHREADS);
  for (int i=0; i<NUMTHREADS; ++i)
    threads.push_back(Thread(std::ref(filler)));

  wait();
  long long st =  rdtsc();
  do{} while(stop); 
  long long tot = rdtsc()-st;

  int n=0;
  for (int i=0; i<256; ++i)
    n+= hist.h[i];
  
  std::copy(hist.h,hist.h+256,std::ostream_iterator<int>(std::cout,","));
  std::cout << std::endl;
  std::cout << "total " << n <<  std::endl;
  std::cout << "time filling " << double(tot)/1000. <<std::endl;
  
  return 0;
}