Gabriele Cosmo
254 lines
8.1 KiB
C++
254 lines
8.1 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// $Id$
|
|
//
|
|
// ---------------------------------------------------------------
|
|
// GEANT 4 class header file
|
|
//
|
|
// Class Description:
|
|
// The classes contained in this header files are used by
|
|
// G4Cache to store a TLS instance of the cached object.
|
|
// These classes should not be used by client code, but
|
|
// are used by one of the G4Cache classes.
|
|
//
|
|
// This class is container of the cached value
|
|
// Not memory efficient, but CPU efficient (constant time access)
|
|
// A different version with a map instead of a vector should be
|
|
// memory efficient
|
|
// and less CPU efficient (log-time access).
|
|
// If really a lot of these objects are used
|
|
// we may want to consider the map version to save some memory
|
|
//
|
|
// These are simplified "split-classes" without any
|
|
// copy-from-master logic. Each cached object is associated
|
|
// a unique identified (an integer), that references an instance
|
|
// of the cached value (of template type VALTYPE) in a
|
|
// static TLS data structure
|
|
//
|
|
// In case the cache is used for a cached object the object class
|
|
// has to provide a default constructor. Alternatively pointers to
|
|
// objects can be stored in the cache and this limitation is removed
|
|
// but explicit handling of memory (new/delete) of cached object becomes
|
|
// client responsibility.
|
|
//
|
|
// History:
|
|
// 21 Oct 2013: A. Dotti - First implementation
|
|
//
|
|
// Todos: - Understand if map based class can be more efficent than
|
|
// vector one
|
|
// - Evaluate use of specialized allocator for TLS "new"
|
|
|
|
#include <vector>
|
|
#include "G4Threading.hh"
|
|
|
|
#ifdef g4cdebug
|
|
#include <iostream>
|
|
#include <sstream>
|
|
using std::cout;
|
|
using std::endl;
|
|
#endif
|
|
|
|
// A TLS storage for a cache of type VALTYPE
|
|
template<class VALTYPE>
|
|
class G4CacheReference {
|
|
public:
|
|
inline void Initialize( unsigned int id );
|
|
// Initliaze TLS storage
|
|
|
|
inline void Destroy( unsigned int id , G4bool last);
|
|
// Cleanup TLS storage for instance id. If last==true
|
|
// destroy and cleanup object container
|
|
|
|
inline VALTYPE& GetCache(unsigned int id) const;
|
|
// Returns cached value for instance id
|
|
private:
|
|
typedef std::vector<VALTYPE*> cache_container;
|
|
// Implementation detail: the cached object is stored as a
|
|
// pointer. See Note (1)
|
|
static G4ThreadLocal cache_container *cache;
|
|
};
|
|
|
|
// Note (1) : Object is stored as a pointer to avoid too large
|
|
// std::vector in case of stored objects and allow use
|
|
// of spcialized allocators
|
|
|
|
// Template specialization for pointers
|
|
// Note that objects are not owned by cache, for this
|
|
// version of the cache the explicit new/delete of the
|
|
// cached object
|
|
template<class VALTYPE>
|
|
class G4CacheReference<VALTYPE*> {
|
|
public:
|
|
inline void Initialize( unsigned int id );
|
|
|
|
inline void Destroy( unsigned int id , G4bool last);
|
|
|
|
inline VALTYPE*& GetCache(unsigned int id) const;
|
|
|
|
private:
|
|
typedef std::vector<VALTYPE*> cache_container;
|
|
static G4ThreadLocal cache_container *cache;
|
|
};
|
|
|
|
// Template specialization for probably the most used case: double
|
|
// Be more efficient avoiding unnecessary "new/delete"
|
|
template<>
|
|
class G4CacheReference<G4double> {
|
|
public:
|
|
inline void Initialize( unsigned int id );
|
|
|
|
inline void Destroy( unsigned int id , G4bool last);
|
|
|
|
inline G4double& GetCache(unsigned int id) const;
|
|
|
|
private:
|
|
typedef std::vector<G4double> cache_container;
|
|
static G4ThreadLocal std::vector<G4double> *cache;
|
|
};
|
|
|
|
|
|
//================================
|
|
// Implementation details follow
|
|
//================================
|
|
|
|
//======= Implementation: G4CacheReference<V>
|
|
|
|
template<class V>
|
|
void G4CacheReference<V>::Initialize(unsigned int id)
|
|
{
|
|
#ifdef g4cdebug
|
|
if ( cache == 0 )
|
|
cout<<"Generic template"<<endl;
|
|
#endif
|
|
//Create cache container
|
|
if ( cache == 0 )
|
|
cache = new cache_container;
|
|
if ( cache->size() <= id )
|
|
cache->resize(id+1,static_cast<V*>(0));
|
|
if ( (*cache)[id] == 0 ) (*cache)[id]=new V;
|
|
|
|
}
|
|
|
|
template<class V>
|
|
void G4CacheReference<V>::Destroy( unsigned int id, G4bool last )
|
|
{
|
|
if ( cache ) {
|
|
#ifdef g4cdebug
|
|
cout<<"Destroying element"<<id<<" is last?"<<last<<endl;
|
|
#endif
|
|
if ( cache->size() <id && (*cache)[id] ) {
|
|
delete (*cache)[id];
|
|
(*cache)[id]=0;
|
|
}
|
|
if (last ) {
|
|
delete cache;
|
|
cache = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class V>
|
|
V& G4CacheReference<V>::GetCache(unsigned int id) const
|
|
{
|
|
return *(cache->operator[](id));
|
|
}
|
|
|
|
template<class V>
|
|
G4ThreadLocal typename G4CacheReference<V>::cache_container * G4CacheReference<V>::cache = 0;
|
|
|
|
//======= Implementation: G4CacheReference<V*>
|
|
template<class V>
|
|
void G4CacheReference<V*>::Initialize( unsigned int id )
|
|
{
|
|
#ifdef g4cdebug
|
|
if ( cache == 0 )
|
|
cout<<"Pointer template"<<endl;
|
|
#endif
|
|
if ( cache == 0 )
|
|
cache = new cache_container;
|
|
if ( cache->size() <= id )
|
|
cache->resize(id+1,static_cast<V*>(0));
|
|
//No need to create pointee
|
|
//if ( (*cache)[id] == 0 ) (*cache)[id]=new VALTYPE;
|
|
}
|
|
|
|
template<class V>
|
|
inline void G4CacheReference<V*>::Destroy( unsigned int id , G4bool last)
|
|
{
|
|
if ( cache ) {
|
|
#ifdef g4cdebug
|
|
cout<<"Destroying element"<<id<<" is last?"<<last<<"-Pointer template specialization-"<<endl;
|
|
#endif
|
|
if ( cache->size() <id && (*cache)[id] ) {
|
|
//Ownership is for client
|
|
//delete (*cache)[id];
|
|
(*cache)[id]=0;
|
|
}
|
|
if (last ) {
|
|
delete cache;
|
|
cache = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class V>
|
|
V*& G4CacheReference<V*>::GetCache(unsigned int id) const
|
|
{
|
|
return (cache->operator[](id));
|
|
}
|
|
|
|
template<class V>
|
|
G4ThreadLocal typename G4CacheReference<V*>::cache_container * G4CacheReference<V*>::cache=0;
|
|
|
|
//======= Implementation: G4CacheReference<double>
|
|
void G4CacheReference<G4double>::Initialize( unsigned int id )
|
|
{
|
|
#ifdef g4cdebug
|
|
cout<<"Specialized template for G4double"<<endl;
|
|
#endif
|
|
if ( cache == 0 )
|
|
cache = new cache_container;
|
|
if ( cache->size() <= id )
|
|
cache->resize(id+1,static_cast<G4double>(0));
|
|
}
|
|
|
|
void G4CacheReference<G4double>::Destroy( unsigned int /*id*/ , G4bool last) {
|
|
if ( cache && last ) {
|
|
#ifdef g4cdebug
|
|
cout<<"Destroying element"<<id<<" is last?"<<last<<"-Pointer template specialization-"<<endl;
|
|
#endif
|
|
delete cache;
|
|
cache = 0;
|
|
}
|
|
}
|
|
|
|
G4double& G4CacheReference<G4double>::GetCache(unsigned int id) const {
|
|
return cache->operator[](id);
|
|
}
|
|
|
|
//G4ThreadLocal std::vector<G4double>* G4CacheReference<G4double>::cache = 0;
|
|
|