#ifndef COMMON_INC_CPP
#define COMMON_INC_CPP


#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>

#include <atomic>
#include <vector>
#include <string>
#include <chrono>
#include <algorithm>

#include <mutex>
#include <thread>
#include <condition_variable>


#include "layout.inc.cpp"


typedef double WeightReal;
typedef double NeuronReal;
typedef double AccumReal;

typedef int WeightInt;
typedef int AccumInt;



#define RANDOM_MAX 0x7fffffff
inline unsigned int randomNext(unsigned int prev)
  { return (1103515245*prev + 12345) & RANDOM_MAX; }
inline unsigned int randomBranch(unsigned int seed)
  { return randomNext(seed + 1); }
  
inline void busyloop(unsigned int count)
  { while(count--) __asm__ __volatile__(""); }
inline void sleep()
  { std::this_thread::sleep_for(std::chrono::nanoseconds(0)); }
inline void sleepUs(long long us)
  { std::this_thread::sleep_for(std::chrono::microseconds(us)); }


inline long long timeUs() {
  static std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
  return (long long)std::chrono::duration_cast<std::chrono::microseconds>( std::chrono::steady_clock::now() - begin ).count();
}


  
struct Accum {
  union { AccumReal v; AccumInt i; };
};


struct Neuron {
  NeuronReal v, d;
  Accum a;
};


struct Weight {
  union { WeightReal w; WeightInt i; };
};


struct Iter {
  typedef Accum AccumType;
  typedef NeuronReal* DataType;
  typedef AccumType DataAccumType;
  static inline void init(Neuron&, AccumType&) { }
  static inline void iter(Neuron&, Weight&, AccumType&) { }
  static inline void done(Neuron&, AccumType&) { }
  static inline void iter2(Neuron&, Neuron&, Weight&) { }
  static inline void iter3(Neuron&) { }
  static inline void iter4(Neuron&, DataType, DataAccumType&) { }
};



class Barrier;

class ThreadControl {
private:
  friend class Barrier;
  
  std::mutex mutex;
  std::condition_variable cond;
  std::atomic<unsigned int> counter;
  std::vector<std::thread*> threads;
  unsigned int commonSeed;
  
  void runSingleThread(unsigned int tid, unsigned int seed);

protected:
  virtual void threadFunc(Barrier&) { }
  
public:
  ThreadControl(): counter(0), commonSeed() { }
  void runThreads(unsigned int threadsCount = 1) {
    assert(threadsCount);
    counter = 0;
    threads.clear();
    threads.resize(threadsCount);
    commonSeed = rand();
    for(unsigned int i = 1; i < threadsCount; ++i)
      threads[i] = new std::thread(&ThreadControl::runSingleThread, this, i, rand());
    runSingleThread(0, rand());
    for(unsigned int i = 1; i < threadsCount; ++i)
      { threads[i]->join(); delete threads[i]; }
    threads.clear();
  }
};


class Barrier {
private:
  ThreadControl &owner;
  unsigned int next;
  unsigned int busyseed;
public:
  const unsigned int tid;
  const unsigned int threads;
  unsigned int seed;
  unsigned int commonSeed;

  Barrier(const Barrier&) = delete;
  inline Barrier(ThreadControl &owner, unsigned int tid, unsigned int seed, unsigned int commonSeed):
    owner(owner), next(), busyseed(randomBranch(seed)), tid(tid), threads(owner.threads.size()), seed(seed), commonSeed(commonSeed)
    { assert(tid < threads); }
    
  //inline void busyloop() { }
  inline void busyloop(unsigned int maxCycles = 4096) { ::busyloop( (busyseed = randomNext(busyseed))%maxCycles ); }
  inline unsigned int rand() { return seed = randomNext(seed); }
  inline unsigned int commonRand() { return commonSeed = randomNext(commonSeed); }
  inline void wait() { next += threads; ++owner.counter; while(owner.counter < next) busyloop(); }
  inline void subwait() { while(owner.counter < next + tid) busyloop(); }
  
  inline void wait2() {
    next += threads;
    std::unique_lock<std::mutex> lock(owner.mutex);
    if (++owner.counter == next) owner.cond.notify_all(); else
      while(owner.counter < next) owner.cond.wait(lock);
  }
  
  inline void wait3() { next += threads; ++owner.counter; while(owner.counter < next) sleepUs(1); }
};


void ThreadControl::runSingleThread(unsigned int tid, unsigned int seed) {
  Barrier barrier(*this, tid, seed, commonSeed);
  threadFunc(barrier);
}



struct Stat {
  int neurons;
  int activeNeurons;
  int weights;
  int links;
  size_t memsize;

  Stat(): neurons(), activeNeurons(), weights(), links(), memsize() { }

  Stat& operator+= (const Stat &b) {
    neurons += b.neurons;
    activeNeurons += b.activeNeurons;
    weights += b.weights;
    links   += b.links;
    memsize += b.memsize;
    return *this;
  }

  void print(const char *prefix = nullptr) const {
    if (prefix && *prefix) printf("%s: ", prefix);
    printf("neurons: %d / %d, links %d / %d, memSize: %llu\n", activeNeurons, neurons, weights, links, (unsigned long long)memsize);
  }
};


struct Quality {
  AccumReal train;
  AccumReal human;
  
  inline Quality(AccumReal train, AccumReal human): train(train), human(human) {}
  inline explicit Quality(AccumReal train = 0): Quality(train, train) {}
  inline static Quality nan() { return Quality(NAN); }
  inline static Quality bad() { return Quality(INFINITY); }
  
  inline Quality& operator+=(const Quality &b)
    { train += b.train; human += b.human; return *this; }
  inline Quality& operator*=(AccumReal x)
    { train *= x; human *= x; return *this; }
  inline bool operator<(const Quality &b) const {
    return human < b.human ? true
         : b.human < human ? false
         : train < b.train;
  }
};


struct QualityPair {
  Quality measure;
  Quality train;
  
  inline explicit QualityPair(const Quality &measure = Quality(), const Quality &train = Quality()):
    measure(measure), train(train) { }

  inline QualityPair& operator+=(const QualityPair &b)
    { measure += b.measure; train += b.train; return *this; }
  inline QualityPair& operator*=(AccumReal x)
    { measure *= x; train *= x; return *this; }
  inline bool operator<(const QualityPair &b) const {
    return measure < b.measure ? true
         : b.measure < measure ? false
         : train < b.train;
  }
};


#endif