JAllocator.cc

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <random>

#include "JLang/JAllocator.hh"
#include "JLang/JRAM.hh"
#include "JLang/JObjectAllocator.hh"

#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "Jeep/JTimer.hh"


namespace {

  struct __A__ 
  {
    __A__() :
      i(0),
      d(0.0)
    {}

    int    i;
    double d;
  };


  struct __B__ : 
    public __A__,
    public JLANG::JObjectAllocator<__A__, JLANG::JAllocator>
  {};


  struct __C__ : 
    public __A__,
    public JLANG::JObjectAllocator<__A__, JLANG::JRAM>
  {};


  /**
   * Test method for memory allocation and de-allocation.
   *
   * \param  argc    number of command line arguments
   * \param  argv    list   of command line arguments
   * \param  title   title of this template process
   * \return         status
   */
  template<class JType_t>
  int do_main(int argc, char **argv, const char* title)
  {
    using namespace std;

    int         numberOfAllocs;
    int         numberOfEvents;
    bool        random;
    bool        reverse;
    int         debug;
  
    try {

      JParser<> zap("Auxiliary program to test speed of memory allocation.");

      zap['n'] = make_field(numberOfAllocs) = 1000;
      zap['N'] = make_field(numberOfEvents) = 1000;
      zap['r'] = make_field(random);
      zap['R'] = make_field(reverse);
      zap['d'] = make_field(debug)          = 3;

    zap(argc, argv);
    }
    catch(const exception &error) {
      FATAL(error.what() << endl);
    }


    using namespace JPP;
    
    cout << endl << title << endl;

    JTimer timer1("Allocate");
    JTimer timer2("Free");

    timer1.reset();
    timer2.reset();


    vector<JType_t*> buffer;

    for (int event_count = 0; event_count != numberOfEvents; ++event_count) {

      buffer.resize(numberOfAllocs);

      typename vector<JType_t*>::iterator out = buffer.begin();

      timer1.start();

      for (int i = numberOfAllocs; i != 0; --i, ++out) {
        *out = new JType_t();
      }

      timer1.stop();

      if (random) {

        random_device rd;
        mt19937 g(rd());

        std::shuffle(buffer.begin(), buffer.end(), g);
      }

      if (reverse) {
        std::reverse(buffer.begin(), buffer.end());
      }    

      timer2.start();

      for (typename vector<JType_t*>::iterator i = buffer.begin(); i != buffer.end(); ++i) {
        delete *i;
      }

      timer2.stop();
    }

    const double factor = 1.0 / (numberOfEvents * numberOfAllocs);

    timer1.print(cout, factor, nano_t);
    timer2.print(cout, factor, nano_t);

    return 0;
  }
}

/**
 * \file
 *
 * Auxiliary program to test speed of JLANG::JObjectAllocator class.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  if (do_main<__A__>(argc, argv, "C++")        != 0) return 1;
  if (do_main<__B__>(argc, argv, "JAllocator") != 0) return 1;
  if (do_main<__C__>(argc, argv, "JRAM")       != 0) return 1;
}