yinspire 0.1.0

data/bench/pq/bench_binaryheap.h

@@ -0,0 +1,46 @@
+#include "algo/binary_heap.h"
+#include "memory_allocator.h"
+
+namespace BenchBinaryHeap
+{
+  template<class ET>
+  struct T
+  {
+    typedef BinaryHeap<ET, MemoryAllocator<ET> > PQ;
+
+    struct ACC
+    {
+      inline void hold(PQ *pq, double increment)
+      {
+        ET e = pq->top();
+        e.priority += increment;
+        pq->pop();
+        pq->push(e);
+      }
+
+      inline void push(PQ *pq, double priority)
+      {
+        ET e;
+        e.priority = priority;
+        pq->push(e);
+      }
+
+      inline void pop(PQ *pq)
+      {
+        pq->pop();
+      }
+
+      inline double pop_return_priority(PQ *pq)
+      {
+        ET e = pq->top();
+        pq->pop();
+        return e.priority;
+      }
+
+      static const char* algorithm_name()
+      {
+        return "BinaryHeap";
+      }
+    };
+  };
+};

data/bench/pq/bench_calendarqueue.h

@@ -0,0 +1,58 @@
+#include "algo/calendar_queue.h"
+#include "chunked_freelist_allocator.h"
+
+namespace BenchCalendarQueue
+{
+  template<class ET>
+  struct T
+  {
+    typedef CalendarQueue<ET> PQ;
+
+    struct ACC
+    {
+      ChunkedFreelistAllocator<ET> *freelist;
+
+      ACC()
+      {
+        this->freelist = new ChunkedFreelistAllocator<ET>(100000);
+      }
+
+      ~ACC()
+      {
+        delete this->freelist;
+      }
+
+      inline void hold(PQ *pq, double increment)
+      {
+        ET *e = pq->pop();
+        e->_priority += increment;
+        pq->push(e);
+      }
+
+      inline void push(PQ *pq, double priority)
+      {
+        ET *e = this->freelist->allocate();
+        e->_priority = priority;
+        pq->push(e);
+      }
+
+      inline void pop(PQ *pq)
+      {
+        this->freelist->free(pq->pop());
+      }
+
+      inline double pop_return_priority(PQ *pq)
+      {
+        ET *e = pq->pop();
+        double res = e->_priority; 
+        this->freelist->free(e);
+        return res;
+      }
+
+      static const char* algorithm_name()
+      {
+        return "CalendarQueue";
+      }
+    };
+  };
+};

data/bench/pq/bench_pairingheap.h

@@ -0,0 +1,61 @@
+#include "algo/pairing_heap.h"
+#include "chunked_freelist_allocator.h"
+
+namespace BenchPairingHeap
+{
+  template<class ET>
+  struct T
+  {
+    typedef PairingHeap<ET> PQ;
+
+    struct ACC
+    {
+      ChunkedFreelistAllocator<ET> *freelist;
+
+      ACC()
+      {
+        this->freelist = new ChunkedFreelistAllocator<ET>(100000);
+      }
+
+      ~ACC()
+      {
+        delete this->freelist;
+      }
+
+      inline void hold(PQ *pq, double increment)
+      {
+        ET *e = pq->top();
+        e->priority += increment;
+        pq->pop();
+        pq->push(e);
+      }
+
+      inline void push(PQ *pq, double priority)
+      {
+        ET *e = this->freelist->allocate();
+        e->priority = priority;
+        pq->push(e);
+      }
+
+      inline void pop(PQ *pq)
+      {
+        this->freelist->free(pq->top());
+        pq->pop();
+      }
+
+      inline double pop_return_priority(PQ *pq)
+      {
+        ET *e = pq->top();
+        double res = e->priority; 
+        pq->pop();
+        this->freelist->free(e);
+        return res;
+      }
+
+      static const char* algorithm_name()
+      {
+        return "PairingHeap";
+      }
+    };
+  };
+};

data/bench/pq/bench_stlpq.h

@@ -0,0 +1,46 @@
+#include <vector>
+#include <queue>
+
+namespace BenchStlPq
+{
+  template<class ET>
+  struct T
+  {
+    typedef std::priority_queue<ET, std::vector<ET>, ET> PQ; 
+
+    struct ACC
+    {
+      inline void hold(PQ *pq, double increment)
+      {
+        ET e = pq->top();
+        e.priority += increment;
+        pq->pop();
+        pq->push(e);
+      }
+
+      inline void push(PQ *pq, double priority)
+      {
+        ET e;
+        e.priority = priority;
+        pq->push(e);
+      }
+
+      inline void pop(PQ *pq)
+      {
+        pq->pop();
+      }
+
+      inline double pop_return_priority(PQ *pq)
+      {
+        ET e = pq->top();
+        pq->pop();
+        return e.priority;
+      }
+
+      static const char* algorithm_name()
+      {
+        return "std::priority_queue";
+      }
+    };
+  };
+};

data/bench/pq/benchmark.h

@@ -0,0 +1,225 @@
+#include <assert.h>
+#include "distribution.h"
+#include <time.h> // clock()
+
+/*
+ *
+ * ACC: 
+ *
+ *   hold(PQ* pq, double priority_increment);
+ *   push(PQ* pq, double priority_value);
+ *
+ */
+template <class PQ, class ACC>
+class Benchmark
+{
+  public:
+
+    Benchmark(PQ *pq, Distribution *distribution)
+    {
+      this->pq = pq;
+      this->distribution = distribution; 
+    }
+
+    /*
+     * In the updown benchmark the xxx_cycles mean complete up/down
+     * cycles. 
+     */
+    double
+      updown(int max_queue_size, int warmup_cycles, int empty_updown_cycles, int updown_cycles)
+      {
+        clock_t t1, t2;
+
+        // warmup & validation
+        if (!run_updown_validate(max_queue_size, warmup_cycles))
+        {
+          throw "pq validation failed";
+        }
+
+        t1 = clock();
+        run_empty_updown(max_queue_size, empty_updown_cycles);
+        t2 = clock();
+        double empty_updown_time = ((double)(t2 - t1)) / empty_updown_cycles;
+
+        t1 = clock();
+        run_updown(max_queue_size, updown_cycles);
+        t2 = clock();
+        double updown_time = ((double)(t2 - t1)) / updown_cycles;
+
+        return (updown_time - empty_updown_time) / CLOCKS_PER_SEC;
+      }
+
+    double
+      classic_hold(int queue_size, int warmup_cycles, int empty_hold_cycles, int hold_cycles)
+      {
+        clock_t t1, t2;
+
+        setup(queue_size);
+        warmup(warmup_cycles);
+
+        t1 = clock();
+        perform_empty_holds(empty_hold_cycles);
+        t2 = clock();
+        double empty_hold_time = ((double)(t2 - t1)) / empty_hold_cycles;
+
+        t1 = clock();
+        perform_holds(hold_cycles);
+        t2 = clock();
+        double hold_time = ((double)(t2 - t1)) / hold_cycles;
+
+        return (hold_time - empty_hold_time) / CLOCKS_PER_SEC;
+      }
+
+  protected:
+
+    void
+      run_updown(unsigned int max_queue_size, unsigned int cycles)
+      {
+        unsigned int i, j;
+
+        for (i=0; i<cycles; i++)
+        {
+          for (j=0; j<max_queue_size; j++)
+          {
+            this->acc.push(this->pq, distribution->next());
+          }
+          for (j=0; j<max_queue_size; j++)
+          {
+            this->acc.pop(this->pq);
+          }
+        }
+      }
+
+    /*
+     * We assume a "<" relation.
+     */
+    bool
+      run_updown_validate(unsigned int max_queue_size, unsigned int cycles)
+      {
+        unsigned int i, j;
+        double last, prio;
+
+        for (i=0; i<cycles; i++)
+        {
+          for (j=0; j<max_queue_size; j++)
+          {
+            this->acc.push(this->pq, distribution->next());
+          }
+          last = -INFINITY;
+          for (j=0; j<max_queue_size; j++)
+          {
+            prio = this->acc.pop_return_priority(this->pq);
+            if (prio < last) return false;
+            last = prio;
+          }
+        }
+
+        return true;
+      }
+
+
+
+    void
+      run_empty_updown(unsigned int max_queue_size, unsigned int cycles)
+      {
+        unsigned int i, j;
+
+        for (i=0; i<cycles; i++)
+        {
+          // To avoid dead code elemination...
+          for (j=0; j<2*max_queue_size; j++)
+          {
+            if (j&1 == 0)
+            {
+              distribution->next();
+            }
+          }
+        }
+      }
+
+    /*
+     * Setup the priority queue with a size of +queue_size+.
+     */ 
+    void
+      setup(unsigned int queue_size, double insert_prob=0.75, double delete_prob=0.5)
+      {
+        RandomDistribution rnd_bool;
+        RandomDistribution rnd_real;
+
+        assert(insert_prob > delete_prob);
+
+        while (this->pq->size() < queue_size)
+        {
+          if (rnd_bool.next() < insert_prob)
+          {
+            this->acc.push(this->pq, rnd_real.next());
+          }
+
+          if (!this->pq->empty() && rnd_bool.next() < delete_prob)
+          {
+            this->acc.pop(this->pq);
+          }
+        }
+      }
+
+    /*
+     * To reach the steady state, +repeats+ number of hold operations are
+     * performed.
+     *
+     * A common number of repeat cycles is "30*queue_size".
+     */
+    void
+      warmup(int repeats) 
+      {
+        for (; repeats > 0; repeats--)
+        {
+          hold();
+        }
+      }
+
+    void
+      perform_empty_holds(int repeats)
+      {
+        for (; repeats > 0; repeats--)
+        {
+          empty_hold();
+        }
+      }
+
+    void
+      perform_holds(int repeats)
+      {
+        for (; repeats > 0; repeats--)
+        {
+          hold();
+        }
+      }
+
+    /*
+     * Perform a hold operation
+     */
+    inline void
+      hold()
+      {
+        this->acc.hold(this->pq, distribution->next()); 
+      }
+
+    /*
+     * Perform an empty hold operation for measuring the overhead of
+     * random number generation etc (all except priority queue
+     * operations).
+     */ 
+    inline void
+      empty_hold()
+      {
+        distribution->next();
+      }
+
+
+  private:
+
+    PQ *pq;
+    Distribution *distribution;
+    ACC acc;
+
+};

data/bench/pq/distribution.h

@@ -0,0 +1,93 @@
+#include <math.h>
+#include <ostream>
+#include <boost/random.hpp>
+
+class Distribution
+{
+  protected:
+
+    boost::mt19937 eng;
+    boost::uniform_real<> dis;
+    boost::variate_generator<boost::mt19937&, boost::uniform_real<> > gen;
+
+  public:
+
+    Distribution() : gen(eng, dis) {}
+
+    virtual double next() = 0;
+    virtual void output_name(std::ostream &o) { o << "undefined"; } 
+
+    void 
+      seed(unsigned seed)
+      {
+        eng.seed(seed);
+      }
+};
+
+struct RandomDistribution : public Distribution
+{
+  virtual double next() { return gen(); }
+  virtual void output_name(std::ostream &o) { o << "Random"; } 
+};
+
+struct ExponentialDistribution : public Distribution
+{
+  double a;
+  ExponentialDistribution(double _a) : a(_a) {}
+
+  virtual double next() { return a * -log(gen()); }
+
+  virtual void output_name(std::ostream &o) { o << "Exponential(" << this->a << ")"; } 
+};
+
+struct UniformDistribution : public Distribution
+{
+  double a, b;
+
+  UniformDistribution(double _a, double _b) : a(_a), b(_b) {} 
+
+  virtual double next() { return (a + (b-a)*gen()); }
+  virtual void output_name(std::ostream &o) { o << "Uniform(" << this->a << "," << this->b << ")"; } 
+};
+
+struct TriangularDistribution : public Distribution
+{
+  double a, b;
+
+  TriangularDistribution(double _a, double _b) : a(_a), b(_b) {} 
+
+  virtual double next() { return (a + (b-a)*sqrt(gen())); }
+  virtual void output_name(std::ostream &o) { o << "Triangular(" << this->a << "," << this->b << ")"; } 
+};
+
+struct NegativeTriangularDistribution : public Distribution
+{
+  double a, b;
+
+  NegativeTriangularDistribution(double _a, double _b) : a(_a), b(_b) {} 
+
+  virtual double next() { return (a + (b-a)*(1.0 - sqrt(1.0 - gen()))); }
+  virtual void output_name(std::ostream &o) { o << "NegativeTriangular(" << this->a << "," << this->b << ")"; } 
+};
+
+struct BimodalDistribution : public Distribution
+{
+  double a, b;
+
+  BimodalDistribution(double _a=9.95238, double _b=0.1) : a(_a), b(_b) {} 
+
+  virtual double next() { return a * gen() + (gen() < b ? a : 0); }
+    
+  virtual void output_name(std::ostream &o) { o << "Bimodal(" << this->a << "," << this->b << ")"; } 
+};
+
+struct ParetoDistribution : public Distribution
+{
+  double a;
+
+  ParetoDistribution(double _a) : a(_a) {} 
+
+  virtual double next() { return pow(1.0/(1.0 - gen()), 1.0 / a); }
+    
+  virtual void output_name(std::ostream &o) { o << "Pareto(" << this->a << ")"; } 
+};