Gabriele Cosmo
474 lines
14 KiB
C++
474 lines
14 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:
|
|
// Helper classes for Geant4 Multi-Threaded.
|
|
// The classes defined in this header file provide a thread-private
|
|
// cache to store, in a class instance shared among threads,
|
|
// a thread-local variable V.
|
|
// These are templated classes on the to-be-stored object.
|
|
//
|
|
// Example:
|
|
// Let's assume an instance myObject of class G4Shared is sharead between
|
|
// threads. Still a data member of this class needs to be thread-private.
|
|
// A typical example of this being a "cache" for a local calculation.
|
|
// The helper here defined can be used to guarantee thread-safe operations
|
|
// on the thread-private object.
|
|
// Example:
|
|
// class G4Shared {
|
|
// G4double sharedData;
|
|
// G4Cache<G4double> threadPrivate;
|
|
// void foo() {
|
|
// G4double priv = threadPrivate.Get();
|
|
// if ( priv < 10 ) priv += sharedData;
|
|
// threadPrivate.Put( priv );
|
|
// }
|
|
// };
|
|
//
|
|
// Two variants of the base G4Cache exists. The first one being
|
|
// G4VectorCache similar to std::vector
|
|
// Example:
|
|
// G4VectorCache<G4double> aVect;
|
|
// aVect.Push_back( 3.2 );
|
|
// aVect.Push_back( 4.1 );
|
|
// cout<<aVect[0]<<endl;
|
|
// The second one being:
|
|
// G4MapCache similar to std::map
|
|
// Example:
|
|
// G4MapCache<G4int,G4double> aMap;
|
|
// aMap[320]=1.234;
|
|
//
|
|
// See classes definition for details.
|
|
// See testG4Cache unit test for details on usage
|
|
//
|
|
// History:
|
|
// 21 October 2013: A. Dotti - First implementation
|
|
|
|
#ifndef G4CACHE_HH
|
|
#define G4CACHE_HH
|
|
|
|
//Debug this code
|
|
//#define g4cdebug 1
|
|
|
|
#include <system_error>
|
|
#include <atomic>
|
|
|
|
// also included in G4CacheDetails.hh
|
|
#include "G4Threading.hh"
|
|
#include "G4AutoLock.hh"
|
|
|
|
//Thread Local storage details are in this header file
|
|
#include "G4CacheDetails.hh"
|
|
|
|
// A templated cache to store a thread-private data of type VALTYPE.
|
|
template<class VALTYPE>
|
|
class G4Cache {
|
|
public:
|
|
typedef VALTYPE value_type;
|
|
// The stored type
|
|
|
|
G4Cache();
|
|
// Default constructor
|
|
|
|
G4Cache(const value_type& v);
|
|
// Construct cache object with initial value
|
|
|
|
virtual ~G4Cache();
|
|
// Default destructor
|
|
|
|
inline value_type& Get() const;
|
|
// Gets reference to cached value of this threads
|
|
|
|
inline void Put( const value_type& val ) const;
|
|
// Sets this thread cached value to val
|
|
|
|
inline value_type Pop();
|
|
// Gets copy of cached value
|
|
|
|
G4Cache(const G4Cache& rhs);
|
|
G4Cache& operator=(const G4Cache& rhs);
|
|
|
|
protected:
|
|
const int& GetId() const { return id; }
|
|
|
|
private:
|
|
int id;
|
|
mutable G4CacheReference<value_type> theCache;
|
|
static std::atomic<unsigned int> instancesctr;
|
|
static std::atomic<unsigned int> dstrctr;
|
|
|
|
inline value_type& GetCache() const {
|
|
theCache.Initialize(id);
|
|
return theCache.GetCache(id);
|
|
}
|
|
|
|
};
|
|
|
|
|
|
// A vector version of the cache. Implements vector interface.
|
|
// Can be used directly as a std::vector would be used.
|
|
template<class VALTYPE>
|
|
class G4VectorCache : public G4Cache< std::vector<VALTYPE> > {
|
|
public:
|
|
//Some useful defintions
|
|
typedef VALTYPE value_type;
|
|
typedef typename std::vector<value_type> vector_type;
|
|
typedef typename vector_type::size_type size_type;
|
|
typedef typename vector_type::iterator iterator;
|
|
typedef typename vector_type::const_iterator const_iterator;
|
|
|
|
G4VectorCache();
|
|
// Default constructor
|
|
|
|
G4VectorCache( G4int nElems );
|
|
// Creates a vector cache of nElems elements
|
|
|
|
G4VectorCache( G4int nElems , value_type* vals );
|
|
// Creates a vector cache with elements from an array
|
|
|
|
virtual ~G4VectorCache();
|
|
// Default destructor
|
|
|
|
// Interface with funxtionalities of similar name of std::vector
|
|
inline void Push_back( const value_type& val );
|
|
inline value_type Pop_back();
|
|
inline value_type& operator[](const G4int& idx);
|
|
inline iterator Begin();
|
|
inline iterator End();
|
|
inline void Clear();
|
|
inline size_type Size() { return G4Cache<vector_type>::Get().size(); } //Needs to be here for a VC9 compilation problem
|
|
};
|
|
|
|
|
|
// a Map version of the cache. Implemetns std::map interface.
|
|
// Can be used directly as a std::map would be used.
|
|
// KEYTYPE being the key type and VALTYPE the value type.
|
|
#include <map>
|
|
template<class KEYTYPE, class VALTYPE>
|
|
class G4MapCache : public G4Cache<std::map<KEYTYPE,VALTYPE> > {
|
|
public:
|
|
//Some useful definitions
|
|
typedef KEYTYPE key_type;
|
|
typedef VALTYPE value_type;
|
|
typedef typename std::map<key_type,value_type> map_type;
|
|
typedef typename map_type::size_type size_type;
|
|
typedef typename map_type::iterator iterator;
|
|
typedef typename map_type::const_iterator const_iterator;
|
|
|
|
virtual ~G4MapCache();
|
|
// Default destructor
|
|
|
|
inline G4bool Has(const key_type& k );
|
|
// Returns true if map contains element corresponding to key k
|
|
|
|
// Interface with functionalities of similar name of std::map
|
|
inline std::pair<iterator,G4bool> Insert( const key_type& k , const value_type& v );
|
|
inline iterator Begin();
|
|
inline iterator End();
|
|
inline iterator Find(const key_type& k );
|
|
inline value_type& Get(const key_type& k );
|
|
inline size_type Erase(const key_type& k );
|
|
inline value_type& operator[](const key_type& k);
|
|
inline size_type Size() { return G4Cache<map_type>::Get().size(); } //Needs to be here for a VC9 compilation problem
|
|
};
|
|
|
|
|
|
|
|
//=============================================================
|
|
// Implementation details follow
|
|
//=============================================================
|
|
|
|
|
|
|
|
#ifdef g4cdebug
|
|
#include <iostream>
|
|
#include <sstream>
|
|
using std::cout;
|
|
using std::endl;
|
|
#endif
|
|
|
|
#include "G4AutoLock.hh"
|
|
|
|
|
|
//========= Implementation: G4Cache<V>
|
|
|
|
template<class V>
|
|
G4Cache<V>::G4Cache()
|
|
{
|
|
G4AutoLock l(G4TypeMutex<G4Cache<V>>());
|
|
id = instancesctr++;
|
|
#ifdef g4cdebug
|
|
cout<<"G4Cache id: "<<id<<endl;
|
|
#endif
|
|
}
|
|
|
|
template<class V>
|
|
G4Cache<V>::G4Cache(const G4Cache<V>& rhs)
|
|
{
|
|
//Copy is special, we need to copy the content
|
|
//of the cache, not the cache object
|
|
if ( this == &rhs ) return;
|
|
G4AutoLock l(G4TypeMutex<G4Cache<V>>());
|
|
id = instancesctr++;
|
|
//Force copy of cached data
|
|
V aCopy = rhs.GetCache();
|
|
Put( aCopy );
|
|
#ifdef g4cdebug
|
|
cout<<"Copy constructor with id: "<<id<<endl;
|
|
#endif
|
|
}
|
|
|
|
template<class V>
|
|
G4Cache<V>& G4Cache<V>::operator=(const G4Cache<V>& rhs)
|
|
{
|
|
if (this == &rhs) return *this;
|
|
//Force copy of cached data
|
|
V aCopy = rhs.GetCache();
|
|
Put(aCopy);
|
|
#ifdef g4cdebug
|
|
cout<<"Assignement operator with id: "<<id<<endl;
|
|
#endif
|
|
return *this;
|
|
}
|
|
|
|
template<class V>
|
|
G4Cache<V>::G4Cache(const V& v)
|
|
{
|
|
G4AutoLock l(G4TypeMutex<G4Cache<V>>());
|
|
id = instancesctr++;
|
|
Put(v);
|
|
#ifdef g4cdebug
|
|
cout<<"G4Cache id: "<<id<<" "<<endl;
|
|
#endif
|
|
}
|
|
|
|
template<class V>
|
|
G4Cache<V>::~G4Cache()
|
|
{ //Move base calss
|
|
#ifdef g4cdebug
|
|
cout<<"~G4Cache id: "<<id<<" "<<endl;
|
|
#endif
|
|
// don't automatically lock --> wait until we can catch an error
|
|
// without scoping the G4AutoLock
|
|
G4AutoLock l(G4TypeMutex<G4Cache<V>>(), std::defer_lock);
|
|
// sometimes the mutex is unavailable in destructors so
|
|
// try to lock the associated mutex, but catch if fails
|
|
try
|
|
{
|
|
// a system_error in lock means that the mutex is unavailable
|
|
// we want to throw the error that comes from locking an unavailable
|
|
// mutex so that we know there is a memory leak
|
|
// if the mutex is valid, this will hold until the other thread finishes
|
|
l.lock();
|
|
}
|
|
catch (std::system_error& e)
|
|
{
|
|
// the error that comes from locking an unavailable mutex
|
|
#ifdef G4VERBOSE
|
|
G4cout << "Non-critical error: mutex lock failure in ~G4Cache<"
|
|
<< typeid(V).name() << ">. "
|
|
<< "If the RunManagerKernel has been deleted, it failed to "
|
|
<< "delete an allocated resource and this destructor is being "
|
|
<< "called after the statics were destroyed." << G4endl;
|
|
G4cout << "Exception: [code: " << e.code() << "] caught: "
|
|
<< e.what() << G4endl;
|
|
#endif
|
|
}
|
|
++dstrctr;
|
|
G4bool last = ( dstrctr == instancesctr );
|
|
theCache.Destroy(id, last);
|
|
if (last) {
|
|
instancesctr.store(0);
|
|
dstrctr.store(0);
|
|
}
|
|
}
|
|
|
|
template<class V>
|
|
V& G4Cache<V>::Get() const
|
|
{ return GetCache(); }
|
|
|
|
template<class V>
|
|
void G4Cache<V>::Put( const V& val ) const
|
|
{ GetCache() = val; }
|
|
|
|
//Should here remove from cache element?
|
|
template<class V>
|
|
V G4Cache<V>::Pop()
|
|
{ return GetCache(); }
|
|
|
|
template<class V>
|
|
std::atomic<unsigned int> G4Cache<V>::instancesctr(0);
|
|
|
|
template<class V>
|
|
std::atomic<unsigned int> G4Cache<V>::dstrctr(0);
|
|
|
|
//========== Implementation: G4VectorCache<V>
|
|
template<class V>
|
|
G4VectorCache<V>::G4VectorCache()
|
|
{ }
|
|
|
|
template<class V>
|
|
G4VectorCache<V>::~G4VectorCache() {
|
|
#ifdef g4cdebug
|
|
cout<<"~G4VectorCache "<<G4Cache<G4VectorCache<V>::vector_type>::GetId()<<" with size: "<<Size()<<"->";
|
|
for ( size_type i = 0 ; i < Size() ; ++i )
|
|
cout<<operator[](i)<<",";
|
|
cout<<"<-"<<endl;
|
|
#endif
|
|
}
|
|
|
|
template<class V>
|
|
G4VectorCache<V>::G4VectorCache(G4int nElems ) {
|
|
vector_type& cc = G4Cache<vector_type>::Get();
|
|
cc.resize(nElems);
|
|
}
|
|
|
|
template<class V>
|
|
G4VectorCache<V>::G4VectorCache(G4int nElems , V* vals ) {
|
|
vector_type& cc = G4Cache<vector_type>::Get();
|
|
cc.resize(nElems);
|
|
for ( G4int idx = 0 ; idx < nElems ; ++idx )
|
|
cc[idx]=vals[idx];
|
|
}
|
|
|
|
template<class V>
|
|
void G4VectorCache<V>::Push_back( const V& val )
|
|
{
|
|
G4Cache<vector_type>::Get().push_back( val );
|
|
}
|
|
|
|
template<class V>
|
|
V G4VectorCache<V>::Pop_back()
|
|
{
|
|
vector_type& cc = G4Cache<vector_type>::Get();
|
|
value_type val = cc[cc.size()-1];
|
|
cc.pop_back();
|
|
return val;
|
|
}
|
|
|
|
template<class V>
|
|
V& G4VectorCache<V>::operator[](const G4int& idx)
|
|
{
|
|
vector_type& cc = G4Cache<vector_type>::Get();
|
|
return cc[idx];
|
|
}
|
|
|
|
template<class V>
|
|
typename G4VectorCache<V>::iterator G4VectorCache<V>::Begin()
|
|
{
|
|
return G4Cache<vector_type>::Get().begin();
|
|
}
|
|
|
|
template<class V>
|
|
typename G4VectorCache<V>::iterator G4VectorCache<V>::End()
|
|
{
|
|
return G4Cache<vector_type>::Get().end();
|
|
}
|
|
|
|
template<class V>
|
|
void G4VectorCache<V>::Clear()
|
|
{
|
|
G4Cache<vector_type>::Get().clear();
|
|
}
|
|
|
|
//template<class V>
|
|
//typename G4VectorCache<V>::size_type G4VectorCache<V>::Size()
|
|
//{
|
|
// return G4Cache<vector_type>::Get().size();
|
|
//}
|
|
|
|
//======== Implementation: G4MapType<K,V>
|
|
template<class K, class V>
|
|
G4MapCache<K,V>::~G4MapCache()
|
|
{
|
|
#ifdef g4cdebug
|
|
cout<<"~G4MacCache "<<G4Cache<map_type>::GetId()<<" with size: "<<Size()<<"->";
|
|
for ( iterator it = Begin() ; it != End() ; ++it )
|
|
cout<<it->first<<":"<<it->second<<",";
|
|
cout<<"<-"<<endl;
|
|
#endif
|
|
}
|
|
|
|
template<class K, class V>
|
|
std::pair<typename G4MapCache<K,V>::iterator,G4bool>
|
|
G4MapCache<K,V>::Insert(const K& k, const V& v)
|
|
{
|
|
return G4Cache<map_type>::Get().insert( std::pair<key_type,value_type>(k,v) );
|
|
}
|
|
|
|
//template<class K, class V>
|
|
//typename G4MapCache<K,V>::size_type G4MapCache<K,V>::Size()
|
|
//{
|
|
// return G4Cache<map_type>::Get().size();
|
|
//}
|
|
|
|
template<class K, class V>
|
|
typename G4MapCache<K,V>::iterator G4MapCache<K,V>::Begin()
|
|
{
|
|
return G4Cache<map_type>::Get().begin();
|
|
}
|
|
template<class K, class V>
|
|
typename G4MapCache<K,V>::iterator G4MapCache<K,V>::End()
|
|
{
|
|
return G4Cache<map_type>::Get().end();
|
|
}
|
|
|
|
template<class K, class V>
|
|
typename G4MapCache<K,V>::iterator G4MapCache<K,V>::Find(const K& k )
|
|
{
|
|
return G4Cache<map_type>::Get().find(k);
|
|
}
|
|
|
|
template<class K, class V>
|
|
G4bool G4MapCache<K,V>::Has(const K& k )
|
|
{
|
|
return ( Find(k) != End() );
|
|
}
|
|
|
|
template<class K, class V>
|
|
V& G4MapCache<K,V>::Get(const K& k )
|
|
{
|
|
return Find(k)->second;
|
|
}
|
|
|
|
template<class K, class V>
|
|
typename G4MapCache<K,V>::size_type G4MapCache<K,V>::Erase(const K& k )
|
|
{
|
|
return G4Cache<map_type>::Get().erase(k);
|
|
}
|
|
|
|
template<class K, class V>
|
|
V& G4MapCache<K,V>::operator[](const K& k)
|
|
{
|
|
return (G4Cache<map_type>::Get())[k];
|
|
}
|
|
|
|
#endif
|