Gabriele Cosmo
317 lines
9.4 KiB
C++
317 lines
9.4 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. *
|
|
// ********************************************************************
|
|
//
|
|
// G4CacheDetails
|
|
//
|
|
// 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.
|
|
//
|
|
// G4Cache is a 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.
|
|
//
|
|
// Todos: - Understand if map based class can be more efficent than
|
|
// vector one.
|
|
// - Evaluate use of specialized allocator for TLS "new".
|
|
|
|
// Author: A.Dotti, 21 October 2013 - First implementation
|
|
// --------------------------------------------------------------------
|
|
#ifndef G4CacheDetails_hh
|
|
#define G4CacheDetails_hh
|
|
|
|
#include "G4Threading.hh"
|
|
#include "globals.hh"
|
|
#include <vector>
|
|
|
|
// 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:
|
|
using cache_container = std::vector<VALTYPE*>;
|
|
// Implementation detail: the cached object is stored as a
|
|
// pointer. Object is stored as a pointer to avoid too large
|
|
// std::vector in case of stored objects and allow use of
|
|
// specialized allocators
|
|
|
|
static cache_container*& cache();
|
|
};
|
|
|
|
// Template specialization for pointers
|
|
// Note: 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:
|
|
using cache_container = std::vector<VALTYPE*>;
|
|
static 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:
|
|
using cache_container = std::vector<G4double>;
|
|
static G4GLOB_DLL cache_container*& cache();
|
|
};
|
|
|
|
//======= Implementation: G4CacheReference<V>
|
|
//===========================================
|
|
|
|
template <class V>
|
|
void G4CacheReference<V>::Initialize(unsigned int id)
|
|
{
|
|
// Create cache container
|
|
if(cache() == nullptr)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "Generic template container..." << std::endl;
|
|
#endif
|
|
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() != nullptr)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "V: Destroying element " << id << " is last? " << last
|
|
<< std::endl;
|
|
#endif
|
|
if(cache()->size() < id)
|
|
{
|
|
G4ExceptionDescription msg;
|
|
msg << "Internal fatal error. Invalid G4Cache size (requested id: " << id
|
|
<< " but cache has size: " << cache()->size();
|
|
msg << " Possibly client created G4Cache object in a thread and"
|
|
<< " tried to delete it from another thread!";
|
|
G4Exception("G4CacheReference<V>::Destroy", "Cache001", FatalException,
|
|
msg);
|
|
return;
|
|
}
|
|
if(cache()->size() > id && (*cache())[id] != nullptr)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "V: Destroying element " << id
|
|
<< " size: " << cache()->size() << std::endl;
|
|
#endif
|
|
delete(*cache())[id];
|
|
(*cache())[id] = nullptr;
|
|
}
|
|
if(last)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "V: Destroying LAST element!" << std::endl;
|
|
#endif
|
|
delete cache();
|
|
cache() = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <class V>
|
|
V& G4CacheReference<V>::GetCache(unsigned int id) const
|
|
{
|
|
return *(cache()->operator[](id));
|
|
}
|
|
|
|
template <class V>
|
|
typename G4CacheReference<V>::cache_container*& G4CacheReference<V>::cache()
|
|
{
|
|
G4ThreadLocalStatic cache_container* _instance = nullptr;
|
|
return _instance;
|
|
}
|
|
|
|
//======= Implementation: G4CacheReference<V*>
|
|
//============================================
|
|
|
|
template <class V>
|
|
void G4CacheReference<V*>::Initialize(unsigned int id)
|
|
{
|
|
if(cache() == nullptr)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "Pointer template container..." << std::endl;
|
|
#endif
|
|
cache() = new cache_container;
|
|
}
|
|
if(cache()->size() <= id)
|
|
{
|
|
cache()->resize(id + 1, static_cast<V*>(0));
|
|
}
|
|
}
|
|
|
|
template <class V>
|
|
inline void G4CacheReference<V*>::Destroy(unsigned int id, G4bool last)
|
|
{
|
|
if(cache() != nullptr)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "V*: Destroying element " << id << " is last? " << last
|
|
<< std::endl;
|
|
#endif
|
|
if(cache()->size() < id)
|
|
{
|
|
G4ExceptionDescription msg;
|
|
msg << "Internal fatal error. Invalid G4Cache size (requested id: " << id
|
|
<< " but cache has size: " << cache()->size();
|
|
msg << " Possibly client created G4Cache object in a thread and"
|
|
<< " tried to delete it from another thread!";
|
|
G4Exception("G4CacheReference<V*>::Destroy", "Cache001", FatalException,
|
|
msg);
|
|
return;
|
|
}
|
|
if(cache()->size() > id && (*cache())[id] != nullptr)
|
|
{
|
|
// Ownership is for client
|
|
// delete (*cache())[id];
|
|
#ifdef g4cdebug
|
|
std::cout << "V*: Resetting element " << id
|
|
<< " size: " << cache()->size() << std::endl;
|
|
#endif
|
|
(*cache())[id] = nullptr;
|
|
}
|
|
if(last)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "V*: Deleting LAST element!" << std::endl;
|
|
#endif
|
|
delete cache();
|
|
cache() = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <class V>
|
|
V*& G4CacheReference<V*>::GetCache(unsigned int id) const
|
|
{
|
|
return (cache()->operator[](id));
|
|
}
|
|
|
|
template <class V>
|
|
typename G4CacheReference<V*>::cache_container*& G4CacheReference<V*>::cache()
|
|
{
|
|
G4ThreadLocalStatic cache_container* _instance = nullptr;
|
|
return _instance;
|
|
}
|
|
|
|
//======= Implementation: G4CacheReference<double>
|
|
//============================================
|
|
|
|
void G4CacheReference<G4double>::Initialize(unsigned int id)
|
|
{
|
|
if(cache() == nullptr)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "Specialized template for G4double container..." << std::endl;
|
|
#endif
|
|
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() != nullptr && last)
|
|
{
|
|
#ifdef g4cdebug
|
|
std::cout << "DB: Destroying LAST element! Is it last? " << last
|
|
<< std::endl;
|
|
#endif
|
|
delete cache();
|
|
cache() = nullptr;
|
|
}
|
|
}
|
|
|
|
G4double& G4CacheReference<G4double>::GetCache(unsigned int id) const
|
|
{
|
|
return cache()->operator[](id);
|
|
}
|
|
|
|
#endif
|