Initial commitHEADmaster

1 files changed, 268 insertions, 0 deletions

diff --git a/core/sim_replay.hpp b/core/sim_replay.hpp
new file mode 100644
index 0000000..c34e216
--- /dev/null
+++ b/core/sim_replay.hpp
@@ -0,0 +1,268 @@
+#ifndef BjxF7IwCJEpR8eQGIzMk04pwFg
+#define BjxF7IwCJEpR8eQGIzMk04pwFg
+
+#include <algorithm>
+#include <boost/tuple/tuple.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/contains.hpp>
+
+#include "context.hpp"
+#include "event.hpp"
+#include "evolve.hpp"
+#include "index.hpp"
+#include "index_global.hpp"
+#include "index_spike.hpp"
+#include "index_spike_arrival.hpp"
+#include "filter.hpp"
+#include "multi_queue.hpp"
+#include "pla_apply.hpp"
+#include "pla_evolve.hpp"
+#include "pla_generate.hpp"
+#include "pla_initbycopy.hpp"
+#include "pla_sync.hpp"
+#include "time.hpp"
+#include "topology.hpp"
+#include "type_set.hpp"
+
+#include "model.hpp"
+
+namespace SimReplayImpl {
+
+using namespace boost;
+using namespace boost::mpl;
+
+// TODO: remove (is redundant code)
+template <typename Quant> struct CalcDPtr { 
+  typedef Ptr<Quant> type; 
+};
+template <> struct CalcDPtr<SpikeArrival> {
+  typedef boost::tuple<Ptr<SpikeArrival>, Ptr<Synapse>> type;
+};
+
+/// factory defining which discrete quants we have to consider
+
+template<typename ReplayQuant>
+struct MultiQueueFactory;
+
+template<>
+struct MultiQueueFactory<Global> {
+  typedef list<GlobalMsg> dependencies;
+  typedef MultiQueue<Time, FilterPayload, dependencies, FilterContainer> type;
+  typedef IdList<Ptr<Global>::ptr_t> id_list_t;
+  static type instance(id_list_t &, const Time time) {
+    return type(time);
+  }
+};
+
+template<>
+struct MultiQueueFactory<Neuron> {
+  typedef list<GlobalMsg, Spike, RandomSpike, SpikeArrival> dependencies;
+  typedef MultiQueue<Time, FilterPayload, dependencies, FilterContainer> type;
+  typedef IdList<Ptr<Neuron>::ptr_t> id_list_t;
+  static type instance(id_list_t ids, const Time time) {
+    return type(Filter<GlobalMsg>   (time),
+		Filter<Spike>       (ids, time),
+		Filter<RandomSpike> (ids, time),
+		Filter<SpikeArrival>(ids, time));
+  }
+};
+
+template<>
+struct MultiQueueFactory<Synapse> : MultiQueueFactory<Neuron> {
+  typedef IdList<Ptr<Synapse>::ptr_t> id_list_t;
+  static type instance(id_list_t ids_synapse, Time time) {
+    MultiQueueFactory<Neuron>::id_list_t ids_neuron;
+    for (auto syn : ids_synapse)
+      ids_neuron.insert(Ptr<Synapse>(syn).extractNeuron()());
+    return MultiQueueFactory<Neuron>::instance(ids_neuron, time);
+  }
+};
+
+/// template brainfuck to prevent instancing unnecessary handleEvents<>()
+
+template<typename ReplayQuant, typename Quant>
+struct MaybeHandleEvent {
+  template<typename Q> struct HandleEvent {
+    template<typename Sim> void operator() (Sim &sim) {
+      sim.template handleEvent<Q>();
+    }
+  };
+
+  struct IgnoreEvent {
+    template<typename Sim> void operator() (Sim &sim) {}
+  };
+
+  typedef typename contains<
+    typename MultiQueueFactory<ReplayQuant>::dependencies,
+    Quant>::type isRelevant;
+  typedef typename if_<isRelevant,
+		       HandleEvent<Quant>,
+		       IgnoreEvent
+		       >::type impl;
+};
+
+
+/// extract neurons from arbitrary id list
+template<typename Quant> struct ExtractNeuronIDs;
+
+template<>
+struct ExtractNeuronIDs<Global> {
+  IdList<Ptr<Neuron>::ptr_t> operator() (IdList<Ptr<Global>::ptr_t> &) {
+    return IdList<Ptr<Neuron>::ptr_t>();
+  }
+};
+
+template<>
+struct ExtractNeuronIDs<Neuron> {
+  IdList<Ptr<Neuron>::ptr_t> operator() (IdList<Ptr<Neuron>::ptr_t> &src) {
+    return src;
+  }
+};
+
+template<>
+struct ExtractNeuronIDs<Synapse> {
+  IdList<Ptr<Neuron>::ptr_t> operator() (IdList<Ptr<Synapse>::ptr_t> &src) {
+    IdList<Ptr<Neuron>::ptr_t> res;
+    for (auto id : src)
+      res.insert(Ptr<Synapse>(id).extractNeuron()());
+    return res;
+  }
+};
+
+/// the precious replay
+
+template<typename PropList, typename ReplayQuant,
+	 template<class, class> class EventHandler = MaybeHandleEvent>
+struct SimReplay {
+  typedef PropertyComposition<PropList> PropComp;
+  typedef Checkpoint<Void, 1> Cp;
+  typedef IdList<typename Ptr<ReplayQuant>::ptr_t> id_list_t;
+  typedef IdList<typename Ptr<Neuron>::ptr_t> neuron_list_t;
+
+  SimReplay(id_list_t ids, Time start)
+    // we need the previous checkpoint interval
+    : ct(Cp::interval() * (std::max((const uint32_t) 1, Cp::binTime(start)) - 1)),
+      ids(ids),
+      neurons(ExtractNeuronIDs<ReplayQuant>()(ids)),
+      queues(std::move(MultiQueueFactory<ReplayQuant>::instance(ids, ct)))
+  {
+    // init values of our quant
+    pc.cast(PLA_InitByCopy{ct});
+
+    // forward precisely to the request time
+    run(start, -1);
+  }
+
+  template<typename Prop>
+  typename Prop::type get(Ptr<ReplayQuant> id, Time t) {
+    // TODO (maybe): allow to read all calculated values, not just
+    // those of the ReplayQuant (e.g. the synapses properties of a
+    // simulated neuron)
+    assert(t >= ct);
+    assert(ids.count(id()));
+    run(t, -1);
+    typedef ContinuousContext<ReplayQuant> Ctx;
+    PLA_Get<Prop, Ctx> pla_get(t, Ctx(id));
+    return pc.call(pla_get);
+  }
+
+  bool run(const Time until, uint64_t maxEvents) {
+    assert(until != Time::never());
+    while (queues.min() <= until && maxEvents) {
+      ct = queues.min();
+      switch (queues.minType()) {
+#define HT(T) case RuntimeID<T>::value: typename EventHandler<ReplayQuant, T>::impl()(*this); break;
+	HT(SpikeArrival);
+	HT(Spike);
+	HT(RandomSpike);
+	HT(GlobalMsg);
+#undef HT
+      default: assert(false);
+      }
+      --maxEvents;
+    }
+    return maxEvents;
+  }
+    
+  template<typename Quant>
+  inline bool handleEvent() {
+    typedef typename QuantDestinationQuant<Quant>::type DstQuant;
+    typename CalcDPtr<Quant>::type src(queues.get<Quant>().minPayload().src);
+    Ptr<DstQuant>                  dst(queues.get<Quant>().minPayload().dst);
+
+    // deliever the event and check if to create new events
+    DelieverContext<Quant, DstQuant> delieverContext{src, dst};
+    PLA_Apply<Quant, DstQuant, PropComp> apply(ct, delieverContext);
+    pc.call(apply);
+    
+    // create events
+    if (apply.generateAny()) {
+      // determine how much we have to simulate:
+      if (is_same<ReplayQuant, Global>::value) {
+	// - global replay don't needs any childs
+	pc.cast(PLA_Evolve<Global>{ContinuousContext<Global>{Ptr<Global>{}}, ct});
+      }else{
+	if (is_same<DstQuant, Global>::value) {
+	  // - neuron/synapse replay needs global and selected neurons
+	  for (auto id : neurons)
+	    Evolve<Neuron>()(pc, ct, Ptr<Neuron>{id});
+	  pc.cast(PLA_Evolve<Global>{ContinuousContext<Global>{Ptr<Global>{}}, ct});
+	}else{
+	  // - neuron/synapse evolve happens as usual
+	  Evolve<DstQuant>()(pc, ct, dst);
+	}
+      }
+    }
+    // commit data calculated during apply
+    //   this is necessary because childs are only eventually evolved,
+    //   but require the pre-event values of the instance we are
+    //   committing to now
+    apply.commit(pc);
+
+    // call the continuous property related post-event triggers to
+    // update state
+#define HGE(Q) \
+    if (apply.template generate<Q>()) \
+      handleEventGeneration<DstQuant, Q, Quant>(ct, dst, apply);
+
+    HGE(GlobalMsg);
+    HGE(Spike);
+    HGE(RandomSpike);
+    HGE(SpikeArrival);
+#undef HGE
+
+    queues.template removeMin<Quant>(ct);
+
+    return apply.template generate<Spike>();
+  }
+
+  template<typename ContQuant, typename EventQuant, typename SrcEvQuant>
+  inline void handleEventGeneration(Time ct, Ptr<ContQuant> src, 
+				    PLA_Apply<SrcEvQuant, ContQuant, PropComp> &)
+  {
+    Void nix;
+    pc.cast(PLA_Generate<ContQuant, EventQuant, Void, Void>
+	    (ct, EmitContext<ContQuant, EventQuant>(src, Ptr<EventQuant>(-1)),
+	     nix, nix));
+  }
+
+  Time currentTime() {
+    return ct;
+  }
+
+  /// ephermal state
+  Time ct;
+  id_list_t ids;
+  neuron_list_t neurons;
+  typename MultiQueueFactory<ReplayQuant>::type queues;
+  PropComp pc;  
+
+  /// persistant data storage (holds every mmap'ed data structure)
+  //Topology topology;
+};
+
+} // Namespace ReplayImpl
+
+using SimReplayImpl::SimReplay;
+
+#endif // BjxF7IwCJEpR8eQGIzMk04pwFg