yinspire 0.1.0

data/pure_cpp/src/json/json_parser.h

@@ -0,0 +1,15 @@
+#ifndef __YINSPIRE__JSON_PARSER__
+#define __YINSPIRE__JSON_PARSER__
+
+#include "json.h"
+
+class jsonParser
+{
+  public:
+
+    static jsonValue* parse(char* content, int size);
+    static jsonValue* parse_file(const char* filename);
+    static jsonValue* parse_file_mmap(const char* filename);
+};
+
+#endif

data/pure_cpp/src/json/json_parser.rl

@@ -0,0 +1,213 @@
+%%{
+  machine jsonParser;
+
+  jnull = "null" %{ PB(new jsonNull()); };
+
+  true = "true" %{ PB(new jsonTrue()); };
+
+  false = "false" %{ PB(new jsonFalse()); };
+
+  exp = ("e"|"E") ("+"|"-")? [0-9]+;
+  number = (("+" | "-")? ([0-9] | [1-9] [0-9]*) ("." [0-9]*  )? exp?) >{ tstart=p; } %{
+    PB(json_number(tstart, p, numbuf, numbufsz));
+  };
+
+  pos_inf = (("+")? "Infinity") %{ PB(new jsonNumber(INFINITY)); };
+
+  neg_inf = "-Infinity" %{ PB(new jsonNumber(-INFINITY)); };
+
+  string = ('"' [^"]* '"' | "'" [^']* "'") >{ tstart=p; } %{
+    PB(json_string(tstart+1, p-1));
+  };
+
+  label = (("_" | alpha) ("_" | alnum)*) >{ tstart=p; } %{
+    PB(json_string(tstart, p));
+  };
+
+  whitespace = space | "//" [^\n\r]* [\n\r];
+
+  any_value = (jnull | true | false | number | pos_inf | neg_inf 
+              | string 
+              | ("{" @{ fcall hash; })
+              | ("[" @{ fcall array; }) 
+              );
+
+  main := whitespace* any_value whitespace*;
+
+  kv = (whitespace* (label|string) whitespace* ":" whitespace* any_value) %{ 
+    if (values.size() < 3) throw "invalid format";
+    jsonValue* v = values.back();
+    values.pop_back();
+    jsonString* k = (jsonString*) values.back(); 
+    values.pop_back();
+    jsonHash* h = (jsonHash*) values.back();
+    h->set(k, v);
+  };
+
+  hash := (
+    (kv whitespace* ("," kv whitespace*)*)? whitespace* "}"
+  ) >{ PB(new jsonHash());} @{ fret; };
+
+  array := (
+    whitespace* ( (any_value (whitespace* "," whitespace* any_value)*)? whitespace* "]" )
+  ) >{ array_i.push_back(values.size()); } @{ 
+    jsonArray* a = new jsonArray();
+    for (int i=array_i.back(); i<values.size(); i++) a->push(values[i]);
+    while (values.size() > array_i.back()) values.pop_back();
+    PB(a);
+    array_i.pop_back();
+    fret;
+  };
+
+}%%
+
+#include <vector>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include "json_parser.h"
+
+#define PB(x) values.push_back(x)
+
+inline static jsonString* json_string(char* from, char* to)
+{
+  return new jsonString(from, to-from);
+}
+
+inline static jsonNumber* json_number(char* from, char* to, char* buf, int maxsz)
+{
+  const int sz = to-from; 
+
+  if (sz > maxsz) throw "fatal";
+
+  memcpy(buf, from, sz);
+  buf[sz] = '\000';
+ 
+  return new jsonNumber(strtod(buf, NULL));
+}
+
+%% write data;
+
+jsonValue* jsonParser::parse(char* content, int size)
+{
+  int cs;
+  int top;
+  int stack[20];
+  char numbuf[61];
+  const int numbufsz = 60;
+
+  char *ps = content;
+  char *p = ps;
+  char *pe = content + size;
+
+  // user defined
+  char* tstart = NULL; 
+  std::vector<jsonValue*> values; 
+  std::vector<int> array_i;
+
+  %%write init;
+  %%write exec;
+
+  if (p != pe)
+  {
+    int err_pos = (int)(p-ps);
+    std::cout << "error at: " << err_pos << std::endl;
+    throw "error occured while parsing";
+  }
+
+  if (values.size() != 1)
+  {
+    throw "error occured while parsing";
+  }
+
+  return values[0];
+}
+
+#include <fcntl.h>
+#include <unistd.h>
+
+jsonValue* jsonParser::parse_file(const char* filename)
+{
+  int fh;
+  void *mem;
+  int size;
+  jsonValue* res;
+
+  fh = open(filename, O_RDONLY);
+  if (fh < 0)
+  {
+    throw "cannot open file";
+  }
+
+  size = lseek(fh, 0, SEEK_END);
+  if (size < 0)
+  {
+    throw "error";
+  }
+  lseek(fh, 0, SEEK_SET);
+
+  mem = malloc(size);
+
+  if (mem == NULL)
+  {
+    throw "malloc failed";
+  }
+
+  int c = read(fh, mem, size);
+
+  if (c != size)
+  {
+    throw "couldn't read entire file";
+  }
+
+  res = jsonParser::parse((char*)mem, size);
+
+  free(mem);
+  close(fh);
+
+  return res;
+}
+
+#ifdef WITHOUT_MMAP
+jsonValue* jsonParser::parse_file_mmap(const char* filename)
+{
+  return parse_file(filename);
+}
+#else
+#include <sys/mman.h>
+jsonValue* jsonParser::parse_file_mmap(const char* filename)
+{
+  int fh;
+  void *mem;
+  int size;
+  jsonValue* res;
+
+  fh = open(filename, O_RDONLY);
+  if (fh < 0)
+  {
+    throw "cannot open file";
+  }
+
+  size = lseek(fh, 0, SEEK_END);
+  if (size < 0)
+  {
+    throw "error";
+  }
+  lseek(fh, 0, SEEK_SET);
+
+  mem = mmap(NULL, size, PROT_READ, MAP_SHARED, fh, 0);
+
+  if (mem == MAP_FAILED)
+  {
+    throw "mmap failed";
+  }
+
+  res = jsonParser::parse((char*)mem, size);
+
+  munmap(mem, size);
+  close(fh);
+
+  return res;
+}
+#endif

data/pure_cpp/src/main.cc

@@ -0,0 +1,49 @@
+#include "simulator.h"
+#include <iostream>
+
+#include "synapse.h"
+#include "neuron_srm_01.h"
+
+#define DEF_TYPE(t) NeuralEntity *make_##t() { return new t(); }
+#define REG_TYPE(t, s) (s)->entity_register_type(#t, make_##t)
+
+DEF_TYPE(Synapse)
+DEF_TYPE(Neuron_SRM_01)
+
+int main(int argc, char** argv)
+{
+  Simulator sim;
+  simtime stop_at;
+  real tolerance = 0.0;
+  char *net;
+
+  if (argc == 3 || argc == 4)
+  {
+    net = argv[1];
+    stop_at = atof(argv[2]);
+
+    if (argc == 4)
+    {
+      tolerance = atof(argv[3]);
+    }
+  }
+  else
+  {
+    std::cout << "USAGE: yinspire net stop_at [tolerance]" << std::endl;
+    return 1;
+  }
+
+  REG_TYPE(Synapse, &sim);
+  REG_TYPE(Neuron_SRM_01, &sim);
+
+  std::cout << "net: " << net << std::endl;
+  std::cout << "stop_at: " << stop_at << std::endl;
+  std::cout << "tolerance: " << tolerance << std::endl;
+
+  sim.load(net);
+  sim.run(stop_at);
+
+  std::cout << sim.stat_event_counter << std::endl;
+  std::cout << sim.stat_fire_counter << std::endl;
+  return 0;
+}

data/pure_cpp/src/memory_allocator.h

@@ -0,0 +1,45 @@
+#ifndef __YINSPIRE__MEMORY_ALLOCATOR__
+#define __YINSPIRE__MEMORY_ALLOCATOR__
+
+#include <stdlib.h>
+
+/*
+ * Provides some basic utility functions for allocating and releasing
+ * memory.
+ */
+template <typename T>
+class MemoryAllocator
+{
+  public:
+
+    inline static T*
+      alloc_n(size_t n)
+      {
+        T* ptr = (T*) calloc(n, sizeof(T));
+        if (ptr == NULL)
+        {
+          throw "memory allocation failed";
+        }
+        return ptr;
+      }
+
+    inline static T*
+      realloc_n(T* old_ptr, size_t n)
+      {
+        T* ptr = (T*) realloc(old_ptr, sizeof(T)*n);
+        if (ptr == NULL)
+        {
+          throw "memory allocation failed";
+        }
+        return ptr;
+      }
+
+    inline static void
+      free(T* ptr)
+      {
+        ::free(ptr);
+      }
+
+};
+
+#endif

data/pure_cpp/src/neural_entity.cc

@@ -0,0 +1,208 @@
+#include "neural_entity.h"
+#include "simulator.h"
+#include <math.h>
+
+NeuralEntity::NeuralEntity()
+{
+  this->simulator = NULL;
+  this->id = NULL;
+  this->schedule_index = 0;
+  this->schedule_at = INFINITY;
+  this->schedule_stepping_list_prev = NULL;
+  this->schedule_stepping_list_next = NULL;
+  this->schedule_stepping_list_internal_next = NULL;
+}
+
+NeuralEntity::~NeuralEntity()
+{
+}
+
+
+void
+NeuralEntity::load(jsonHash *data)
+{
+}
+
+void
+NeuralEntity::dump(jsonHash *into)
+{
+}
+
+static void
+iter_disconnect(NeuralEntity *self, NeuralEntity *conn)
+{
+  self->disconnect(conn);
+}
+
+void
+NeuralEntity::disconnect_all()
+{
+  each_connection(iter_disconnect);
+}
+
+void
+NeuralEntity::schedule(simtime at)
+{
+  // FIXME: make sure that this->schedule_at is reset
+  // when the entity is removed from the pq.
+  if (this->schedule_at != at)
+  {
+    this->schedule_at = at;
+    this->simulator->schedule_update(this);
+  }
+}
+
+inline bool
+NeuralEntity::schedule_stepping_enabled()
+{
+  return (this->schedule_stepping_list_prev != NULL && 
+          this->schedule_stepping_list_next != NULL);
+}
+
+void
+NeuralEntity::schedule_enable_stepping()
+{
+  if (!schedule_stepping_enabled())
+  {
+    NeuralEntity*& root = this->simulator->schedule_stepping_list_root; 
+    if (root != NULL)
+    {
+      this->schedule_stepping_list_prev = root;
+      this->schedule_stepping_list_next = root->schedule_stepping_list_next;
+      root->schedule_stepping_list_next = this; 
+      this->schedule_stepping_list_next->schedule_stepping_list_prev = this; 
+    }
+    else
+    {
+      root = this; 
+      this->schedule_stepping_list_prev = this;
+      this->schedule_stepping_list_next = this;
+    }
+  }
+}
+
+void
+NeuralEntity::schedule_disable_stepping()
+{
+  if (schedule_stepping_enabled())
+  {
+    if (this->schedule_stepping_list_prev != this->schedule_stepping_list_next)
+    {
+      this->schedule_stepping_list_prev->schedule_stepping_list_next = this->schedule_stepping_list_next; 
+      this->schedule_stepping_list_next->schedule_stepping_list_prev = this->schedule_stepping_list_prev;  
+    }
+    else
+    {
+      /*
+       * We are the last entity in the stepping list.
+       */
+      this->simulator->schedule_stepping_list_root = NULL;
+      this->schedule_stepping_list_prev = NULL;
+      this->schedule_stepping_list_next = NULL;
+    }
+  }
+}
+
+static bool
+stimuli_accum(Stimulus &parent, const Stimulus &element, void *tolerance)
+{
+  if ((element.at - parent.at) > *((real*)tolerance)) return false;
+
+  if (isinf(element.weight))
+  {
+    /*
+     * We only accumulate two infinitive values!
+     */
+    return (isinf(parent.weight) ? true : false);
+  }
+
+  parent.weight += element.weight;
+  return true;
+}
+
+void
+NeuralEntity::stimuli_add(simtime at, real weight)
+{
+  Stimulus s; s.at = at; s.weight = weight;
+  if (this->simulator->stimuli_tolerance >= 0.0)
+  {
+    //find_parent
+    if (this->stimuli_pq.accumulate(s, stimuli_accum, &this->simulator->stimuli_tolerance)) return;
+  }
+  this->stimuli_pq.push(s);
+  schedule(this->stimuli_pq.top().at);
+}
+
+real
+NeuralEntity::stimuli_sum(simtime until)
+{
+  real weight = 0.0;
+
+  while (!this->stimuli_pq.empty() && this->stimuli_pq.top().at <= until)
+  {
+    weight += this->stimuli_pq.top().weight;
+    this->stimuli_pq.pop();
+  }
+
+  /*
+   * NOTE: we don't have to remove the entity from the schedule if the
+   * pq is empty.
+   */
+  if (!this->stimuli_pq.empty())
+  {
+    schedule(this->stimuli_pq.top().at);
+  }
+
+  return weight;
+}
+
+real
+NeuralEntity::stimuli_sum_inf(simtime until, bool &is_inf)
+{
+  real weight = 0.0;
+  is_inf = false;
+
+  while (!this->stimuli_pq.empty() && this->stimuli_pq.top().at <= until)
+  {
+    if (isinf(this->stimuli_pq.top().weight))
+    {
+      is_inf = true;
+    }
+    else
+    {
+      weight += this->stimuli_pq.top().weight;
+    }
+    this->stimuli_pq.pop();
+  }
+
+  if (!this->stimuli_pq.empty())
+  {
+    schedule(this->stimuli_pq.top().at);
+  }
+
+  return weight;
+}
+
+void
+NeuralEntity::set_simulator(Simulator *simulator)
+{
+  this->simulator = simulator;
+}
+
+Simulator *
+NeuralEntity::get_simulator() const
+{
+  return this->simulator; 
+}
+
+void
+NeuralEntity::set_id(const char *id)
+{
+  this->id = id;
+}
+
+const char *
+NeuralEntity::get_id() const
+{
+  return this->id;
+}