#include <iostream>
#include <boost/pool/object_pool.hpp>
#include <boost/chrono.hpp>

#include "ace/Malloc_T.h"
#include "ace/Synch.h"

#include <unistd.h>
#include <sched.h>
#include <cstdio>

using namespace std;
using namespace boost;
using namespace boost::chrono;

class Foo {
    public:
        void* operator new( size_t, void *location )
        {
            return location;
        }
        void operator delete(void*, void* buff) {}
        void operator delete(void*) {}
    Foo(int i) : _i(i) {}
    private:
        int _i;
};

int main(int argc, char * argv[])
{
    int type = 1;
    if(argc>1)
        type = atoi(argv[1]);
    unsigned long test_number = 1000;
    if(argc>2)
    {
        test_number = (unsigned long)atol(argv[2]);
    }
    Foo **foo = new Foo*[test_number];

    pool<> pool(sizeof(Foo));
    ACE_Cached_Allocator< Foo, ACE_Null_Mutex> *pacepool;
    pacepool = new ACE_Cached_Allocator< Foo, ACE_Null_Mutex>(1);


    high_resolution_clock::time_point tp_start, tp_end;

  
    // setting realtime priority to the current process
    int res;
    struct sched_param initial_sp;

    res = sched_getparam(0, &initial_sp);
    if(res !=0)
    {
        cout << "failed to read priority!" << endl;
        return 0;
    }

    int prio = sched_get_priority_max(SCHED_RR);
    struct sched_param shp;
    shp.sched_priority = prio;//-3;
    res = sched_setscheduler(0,SCHED_RR,&shp);
    if(res != 0)
    {
        cout << "failed to set real time priority!" << endl;
        return 0;
    }
 
    // checking that the priority was set properly
    res = sched_getparam(0, &initial_sp);
    prio = sched_getscheduler(0);
    cout << prio << "\t" << initial_sp.__sched_priority << endl;


    tp_start = high_resolution_clock::now();
    if(type==1)
    {
        for(unsigned long i=0; i<test_number; i++)
        {
            foo[i] = (Foo*)pool.malloc();
        }
    }
    else if(type==2)
    {
        for(unsigned long i=0; i<test_number; i++)
        {
            foo[i] = (Foo*)pacepool->malloc();
        }
    }

    tp_end = high_resolution_clock::now();
    nanoseconds delta1 = duration_cast<nanoseconds>(tp_end-tp_start);
    tp_start = high_resolution_clock::now();
    if(type==1)
    {
        for(unsigned long i=0; i<test_number; i++)
        {
            pool.free(foo[i]);
        }
    }
    else if(type==2)
    {
        for(unsigned long i=0; i<test_number; i++)
        {
            pacepool->free(foo[i]);
        }
    }
   
    tp_end = high_resolution_clock::now();
    nanoseconds delta2 = duration_cast<nanoseconds>(tp_end-tp_start);
    cout << delta1 << "\t" << delta2 << endl;

    delete pacepool;

    return 0;
}