lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.3.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2024-06-28 13:08:51 +02:00
parent f7b23877ed
commit e58e650b32
5232 changed files with 239416 additions and 244360 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/extended/parallel/ThreadsafeScorers/include/G4atomic.hh
+236 -253
View File
@@ -75,293 +75,276 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
template <typename _Tp>
template<typename _Tp>
class G4atomic
{
public:
typedef typename std::atomic<_Tp> base_type;
typedef _Tp value_type;
public:
typedef typename std::atomic<_Tp> base_type;
typedef _Tp value_type;
private:
using mem_ord = std::memory_order;
private:
using mem_ord = std::memory_order;
public:
// constructors
explicit G4atomic(mem_ord mo = std::memory_order_acq_rel)
: fMemOrder(mo)
{
atomics::set(&fvalue, value_type());
}
public:
// constructors
explicit G4atomic(mem_ord mo = std::memory_order_acq_rel) : fMemOrder(mo)
{
atomics::set(&fvalue, value_type());
}
explicit G4atomic(const value_type& _init,
mem_ord mo = std::memory_order_acq_rel)
: fMemOrder(mo)
{
atomics::set(&fvalue, _init);
}
explicit G4atomic(const value_type& _init, mem_ord mo = std::memory_order_acq_rel)
: fMemOrder(mo)
{
atomics::set(&fvalue, _init);
}
// copy-constructor from pure C++11 atomic
explicit G4atomic(const base_type& rhs,
mem_ord mo = std::memory_order_acq_rel)
: fMemOrder(mo)
{
atomics::set(&fvalue, rhs);
}
// copy-constructor from pure C++11 atomic
explicit G4atomic(const base_type& rhs, mem_ord mo = std::memory_order_acq_rel) : fMemOrder(mo)
{
atomics::set(&fvalue, rhs);
}
// copy-constructor
explicit G4atomic(const G4atomic& rhs)
: fMemOrder(rhs.fMemOrder)
{
atomics::set(&fvalue, rhs.base());
}
// copy-constructor
explicit G4atomic(const G4atomic& rhs) : fMemOrder(rhs.fMemOrder)
{
atomics::set(&fvalue, rhs.base());
}
// assignment operators
G4atomic& operator=(const G4atomic& rhs)
{
if(this != &rhs)
atomics::set(&fvalue, rhs.fvalue);
return *this;
}
// assignment operators
G4atomic& operator=(const G4atomic& rhs)
{
if (this != &rhs) atomics::set(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator=(const value_type& rhs)
{
atomics::set(&fvalue, rhs);
return *this;
}
G4atomic& operator=(const value_type& rhs)
{
atomics::set(&fvalue, rhs);
return *this;
}
G4atomic& operator=(const base_type& rhs)
{
atomics::set(&fvalue, rhs);
return *this;
}
G4atomic& operator=(const base_type& rhs)
{
atomics::set(&fvalue, rhs);
return *this;
}
// destructor
~G4atomic() { fvalue.~base_type(); }
// destructor
~G4atomic() { fvalue.~base_type(); }
// base version
base_type& base() { return fvalue; }
const base_type& base() const { return fvalue; }
base_type& base() volatile { return fvalue; }
const base_type& base() const volatile { return fvalue; }
// base version
base_type& base() { return fvalue; }
const base_type& base() const { return fvalue; }
base_type& base() volatile { return fvalue; }
const base_type& base() const volatile { return fvalue; }
// check if atomic is lock-free
bool is_lock_free() const { return fvalue.is_lock_free(); }
bool is_lock_free() const volatile { return fvalue.is_lock_free(); }
// check if atomic is lock-free
bool is_lock_free() const { return fvalue.is_lock_free(); }
bool is_lock_free() const volatile { return fvalue.is_lock_free(); }
// store functions
void store(_Tp _desired, mem_ord mo = std::memory_order_seq_cst)
{
atomics::set(fvalue, _desired, mo);
}
void store(_Tp _desired, mem_ord mo = std::memory_order_seq_cst) volatile
{
atomics::set(fvalue, _desired, mo);
}
// store functions
void store(_Tp _desired, mem_ord mo = std::memory_order_seq_cst)
{
atomics::set(fvalue, _desired, mo);
}
void store(_Tp _desired, mem_ord mo = std::memory_order_seq_cst) volatile
{
atomics::set(fvalue, _desired, mo);
}
// load functions
_Tp load(mem_ord mo = std::memory_order_seq_cst) const
{
return atomics::get(fvalue, mo);
}
_Tp load(mem_ord mo = std::memory_order_seq_cst) const volatile
{
return atomics::get(fvalue, mo);
}
// load functions
_Tp load(mem_ord mo = std::memory_order_seq_cst) const { return atomics::get(fvalue, mo); }
_Tp load(mem_ord mo = std::memory_order_seq_cst) const volatile
{
return atomics::get(fvalue, mo);
}
// implicit conversion functions
operator _Tp() const { return this->load(); }
operator _Tp() const volatile { return this->load(); }
// implicit conversion functions
operator _Tp() const { return this->load(); }
operator _Tp() const volatile { return this->load(); }
operator base_type&() const { return fvalue; }
operator base_type&() const { return fvalue; }
// compare-and-swap functions
bool compare_exchange_weak(_Tp& _expected, _Tp _desired, mem_ord _success,
mem_ord _failure)
{
return fvalue.compare_exchange_weak(_expected, _desired, _success,
_failure);
}
bool compare_exchange_weak(_Tp& _expected, _Tp _desired, mem_ord _success,
mem_ord _failure) volatile
{
return fvalue.compare_exchange_weak(_expected, _desired, _success,
_failure);
}
bool compare_exchange_weak(_Tp& _expected, _Tp _desired, mem_ord _order)
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
bool compare_exchange_weak(_Tp& _expected, _Tp _desired,
mem_ord _order) volatile
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired, mem_ord _success,
mem_ord _failure)
{
return fvalue.compare_exchange_weak(_expected, _desired, _success,
_failure);
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired, mem_ord _success,
// compare-and-swap functions
bool compare_exchange_weak(_Tp& _expected, _Tp _desired, mem_ord _success, mem_ord _failure)
{
return fvalue.compare_exchange_weak(_expected, _desired, _success, _failure);
}
bool compare_exchange_weak(_Tp& _expected, _Tp _desired, mem_ord _success,
mem_ord _failure) volatile
{
return fvalue.compare_exchange_weak(_expected, _desired, _success,
_failure);
}
{
return fvalue.compare_exchange_weak(_expected, _desired, _success, _failure);
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired, mem_ord _order)
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired,
mem_ord _order) volatile
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
bool compare_exchange_weak(_Tp& _expected, _Tp _desired, mem_ord _order)
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
bool compare_exchange_weak(_Tp& _expected, _Tp _desired, mem_ord _order) volatile
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
// value_type operators
G4atomic& operator+=(const value_type& rhs)
{
atomics::increment(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator-=(const value_type& rhs)
{
atomics::decrement(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator*=(const value_type& rhs)
{
atomics::multiply(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator/=(const value_type& rhs)
{
atomics::divide(&fvalue, rhs, fMemOrder);
return *this;
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired, mem_ord _success, mem_ord _failure)
{
return fvalue.compare_exchange_weak(_expected, _desired, _success, _failure);
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired, mem_ord _success,
mem_ord _failure) volatile
{
return fvalue.compare_exchange_weak(_expected, _desired, _success, _failure);
}
// atomic operators
G4atomic& operator+=(const G4atomic& rhs)
{
atomics::increment(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator-=(const G4atomic& rhs)
{
atomics::decrement(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator*=(const G4atomic& rhs)
{
atomics::multiply(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator/=(const G4atomic& rhs)
{
atomics::divide(&fvalue, rhs.fvalue);
return *this;
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired, mem_ord _order)
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
bool compare_exchange_strong(_Tp& _expected, _Tp _desired, mem_ord _order) volatile
{
return fvalue.compare_exchange_weak(_expected, _desired, _order);
}
G4atomic& operator+=(const G4atomic& rhs) volatile
{
atomics::increment(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator-=(const G4atomic& rhs) volatile
{
atomics::decrement(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator*=(const G4atomic& rhs) volatile
{
atomics::multiply(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator/=(const G4atomic& rhs) volatile
{
atomics::divide(&fvalue, rhs.fvalue);
return *this;
}
// value_type operators
G4atomic& operator+=(const value_type& rhs)
{
atomics::increment(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator-=(const value_type& rhs)
{
atomics::decrement(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator*=(const value_type& rhs)
{
atomics::multiply(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator/=(const value_type& rhs)
{
atomics::divide(&fvalue, rhs, fMemOrder);
return *this;
}
// STL atomic operators
G4atomic& operator+=(const std::atomic<_Tp>& rhs)
{
atomics::increment(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator-=(const std::atomic<_Tp>& rhs)
{
atomics::decrement(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator*=(const std::atomic<_Tp>& rhs)
{
atomics::multiply(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator/=(const std::atomic<_Tp>& rhs)
{
atomics::divide(&fvalue, rhs, fMemOrder);
return *this;
}
// atomic operators
G4atomic& operator+=(const G4atomic& rhs)
{
atomics::increment(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator-=(const G4atomic& rhs)
{
atomics::decrement(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator*=(const G4atomic& rhs)
{
atomics::multiply(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator/=(const G4atomic& rhs)
{
atomics::divide(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator+=(const std::atomic<_Tp>& rhs) volatile
{
atomics::increment(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator-=(const std::atomic<_Tp>& rhs) volatile
{
atomics::decrement(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator*=(const std::atomic<_Tp>& rhs) volatile
{
atomics::multiply(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator/=(const std::atomic<_Tp>& rhs) volatile
{
atomics::divide(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator+=(const G4atomic& rhs) volatile
{
atomics::increment(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator-=(const G4atomic& rhs) volatile
{
atomics::decrement(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator*=(const G4atomic& rhs) volatile
{
atomics::multiply(&fvalue, rhs.fvalue);
return *this;
}
G4atomic& operator/=(const G4atomic& rhs) volatile
{
atomics::divide(&fvalue, rhs.fvalue);
return *this;
}
// increment operators
value_type operator++()
{
value_type _tmp = ++fvalue;
return _tmp;
}
value_type operator++(int)
{
value_type _tmp = fvalue++;
return _tmp;
}
// STL atomic operators
G4atomic& operator+=(const std::atomic<_Tp>& rhs)
{
atomics::increment(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator-=(const std::atomic<_Tp>& rhs)
{
atomics::decrement(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator*=(const std::atomic<_Tp>& rhs)
{
atomics::multiply(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator/=(const std::atomic<_Tp>& rhs)
{
atomics::divide(&fvalue, rhs, fMemOrder);
return *this;
}
value_type operator--()
{
value_type _tmp = --fvalue;
return _tmp;
}
value_type operator--(int)
{
value_type _tmp = fvalue--;
return _tmp;
}
G4atomic& operator+=(const std::atomic<_Tp>& rhs) volatile
{
atomics::increment(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator-=(const std::atomic<_Tp>& rhs) volatile
{
atomics::decrement(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator*=(const std::atomic<_Tp>& rhs) volatile
{
atomics::multiply(&fvalue, rhs, fMemOrder);
return *this;
}
G4atomic& operator/=(const std::atomic<_Tp>& rhs) volatile
{
atomics::divide(&fvalue, rhs, fMemOrder);
return *this;
}
protected:
base_type fvalue;
mem_ord fMemOrder;
// increment operators
value_type operator++()
{
value_type _tmp = ++fvalue;
return _tmp;
}
value_type operator++(int)
{
value_type _tmp = fvalue++;
return _tmp;
}
value_type operator--()
{
value_type _tmp = --fvalue;
return _tmp;
}
value_type operator--(int)
{
value_type _tmp = fvalue--;
return _tmp;
}
protected:
base_type fvalue;
mem_ord fMemOrder;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#else // ! G4MULTITHREADED
template <typename _Tp>
template<typename _Tp>
using G4atomic = _Tp;
#endif // G4MULTITHREADED