#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 <thread>
#include <algorithm>


#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 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 {
private:
  std::atomic<unsigned int> &counter;
  unsigned int next;
  unsigned int busyseed;
public:
  const unsigned int tid;
  const unsigned int threads;
  unsigned int seed;

  Barrier(const Barrier&) = delete;
  inline Barrier(std::atomic<unsigned int> &counter, unsigned int tid, unsigned int threads, unsigned int seed):
    counter(counter), next(), busyseed(randomBranch(seed)), tid(tid), threads(threads), seed(seed) { 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 void wait() { next += threads; ++counter; while(counter < next) busyloop(); }
  inline void subwait() { while(counter < next + tid) busyloop(); }
  
};


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