HiveNumbers.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
// Framework include files
#include <GaudiKernel/IRndmGen.h>
#include <GaudiKernel/SmartIF.h>
 
// STL includes
#include <memory>
#include <vector>
 
#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 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 );
    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 ).ignore( /* AUTOMATICALLY ADDED FOR gaudi/Gaudi!763 */ );
          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;
    }
  };
 
} // namespace HiveRndm