ThreadSpecificRandomEngine.h

Go to the documentation of this file.

#ifndef THREADSPECIFICRANDOMENGINE_H_
#define THREADSPECIFICRANDOMENGINE_H_

#include "RandomEngine.h"
#include <boost/thread/tss.hpp>
#include <boost/thread/mutex.hpp>

//#include <iostream>
//using std::cerr;
//using std::cout;
//using std::endl;

typedef MersenneTwister19937 ThreadSpecificRandomEngineType;

class ThreadSpecificRandomEngine
{
public:
    ThreadSpecificRandomEngine() :
            tsp(cleanup),
            alloc_ptr(0)
    { /* NOOP */ }

    virtual ~ThreadSpecificRandomEngine()
    {
      free_ptr();
    }

    void free_ptr(void) {
        boost::mutex::scoped_lock scoped_lock(mutex);
        for( size_t i=0; i<alloc_ptr.size(); i++ ) {
            if( alloc_ptr[i] != NULL ) delete alloc_ptr[i];
            alloc_ptr[i] = NULL;
        }
    }

    void init(void)
    {
        RandomEngine *eng = tsp.get();
        if( eng == NULL ) {
            boost::mutex::scoped_lock scoped_lock(mutex);
            eng = new ThreadSpecificRandomEngineType;
            //cerr << "ThreadSpecificRandomEngine::init: new engine " << dis << " allocated\n\n" ;
            tsp.reset( eng );
            alloc_ptr.push_back( eng );
        }
    }

    void set( RandomEngine *eng )
    {
        tsp.reset( eng );
        //cerr << "ThreadSpecificRandomEngine::set: new engine " << eng << " set\n\n" ;
    }

    void unset( RandomEngine *eng )
    {
        tsp.release();
        init();
    }


    RandomEngine *get(void )
    {
        return tsp.get();
    }


private:
    boost::thread_specific_ptr< RandomEngine > tsp;
    boost::mutex mutex;
    std::vector< RandomEngine * > alloc_ptr;
    static void cleanup( RandomEngine *e ) { };
};

extern ThreadSpecificRandomEngine theThreadSpecificRandomEngine;


#endif /*THREADSPECIFICRANDOMENGINE_H_*/

---