HiveNumbers.h

Go to the documentation of this file.

#ifndef GAUDIHIVE_HIVENUMBERS_H
#define GAUDIHIVE_HIVENUMBERS_H

// Framework include files
#include "GaudiKernel/IRndmGen.h"
#include "GaudiKernel/SmartIF.h"

// STL includes
#include <vector>
#include <memory>

#include "tbb/spin_rw_mutex.h"

// Forward declarations
class IRndmGen;
class IRndmGenSvc;

/*
 * This is a first solution to the problem of the thread safe random generation.
 * It is locking, but the locking is "diluted" by a caching mechanism of the
 * random numbers.
 */

namespace HiveRndm{

  typedef tbb::spin_rw_mutex_v3 HiveNumbersMutex;

  class GAUDI_API HiveNumbers   {
  private:
    unsigned int m_buffer_index;
    const unsigned int m_buffer_size;
    std::vector<double> m_buffer;
    static HiveNumbersMutex m_genMutex;
  protected:
    IRndmGen*           m_generator;
  public:
    HiveNumbers();
    HiveNumbers(const HiveNumbers& copy );
    HiveNumbers(const SmartIF<IRndmGenSvc>& svc, const IRndmGen::Param& par);
    virtual ~HiveNumbers();
    virtual StatusCode initialize(const SmartIF<IRndmGenSvc>& svc, const IRndmGen::Param& par);
#if !defined(GAUDI_V22_API) || defined(G22_NEW_SVCLOCATOR)
    HiveNumbers(IRndmGenSvc* svc, const IRndmGen::Param& par);
    virtual StatusCode initialize(IRndmGenSvc* svc, const IRndmGen::Param& par);
#endif
    virtual StatusCode finalize();
    operator bool  ()  const  {
      return m_generator != 0;
    }
    double operator() ()   {
      return this->shoot();
    }
    double pop()    {
      return this->shoot();
    }
    double shoot()    {
      if ( 0 != m_generator )   {
        if (m_buffer_index==0){// we are out of numbers
            this->shootArray(m_buffer, m_buffer_size);
            m_buffer_index=m_buffer_size-1;
        }
        const double number=m_buffer[m_buffer_index];
        m_buffer_index--;
        return number;
      }
      return -1;
    }
    StatusCode shootArray(std::vector<double>& array, long num, long start=0)  {
      if ( 0 != m_generator )   {
         StatusCode status;
         {
          HiveNumbersMutex::scoped_lock lock(m_genMutex);
          status = m_generator->shootArray(array, num, start);
          }
        return status;
      }
      return StatusCode::FAILURE;
    }
  };


} // end of Rndm namespace


#endif    // GAUDIHIVE_HIVENumbers_H