#include <StorageAccount.h>

Public Member Functions
	Counter ()

	Counter (Counter &&)=default

	Counter (Counter const &iOther)

Static Public Member Functions
static void	addTo (std::atomic< double > &iAtomic, double iToAdd)

Public Attributes
std::atomic< uint64_t >	amount

std::atomic< double >	amount_square

std::atomic< uint64_t >	attempts

std::atomic< uint64_t >	successes

std::atomic< double >	timeMax

std::atomic< double >	timeMin

std::atomic< double >	timeTotal

std::atomic< int64_t >	vector_count

std::atomic< int64_t >	vector_square

Detailed Description

Definition at line 40 of file StorageAccount.h.

Constructor & Destructor Documentation

StorageAccount::Counter::Counter ( )

inline

Definition at line 41 of file StorageAccount.h.

References summarizeEdmComparisonLogfiles::successes, HBHEMethod2Parameters_cfi::timeMax, and HBHEMethod2Parameters_cfi::timeMin.

              :
     attempts{0},
     successes{0},
     amount{0},
     amount_square{0.},
     vector_count{0},
     vector_square{0},
     timeTotal{0.},
     timeMin{0.},
     timeMax{0.} {}

StorageAccount::Counter::Counter ( Counter && )

default

StorageAccount::Counter::Counter ( Counter const & iOther )

inline

Definition at line 58 of file StorageAccount.h.

References attempts, summarizeEdmComparisonLogfiles::successes, HBHEMethod2Parameters_cfi::timeMax, and HBHEMethod2Parameters_cfi::timeMin.

                                    :
     attempts{iOther.attempts.load()},
     successes{iOther.successes.load()},
     amount{iOther.amount.load()},
     amount_square{iOther.amount_square.load()},
     vector_count{iOther.vector_count.load()},
     vector_square{iOther.vector_square.load()},
     timeTotal{iOther.timeTotal.load()},
     timeMin{iOther.timeMin.load()},
     timeMax{iOther.timeMax.load()} {}

Member Function Documentation

static void StorageAccount::Counter::addTo	(	std::atomic< double > &	iAtomic,
		double	iToAdd
	)

inlinestatic

Definition at line 87 of file StorageAccount.h.

Referenced by StorageAccount::Stamp::tick().

                                                                  {
       double oldValue = iAtomic.load();
       double newValue = oldValue + iToAdd;
       while( not iAtomic.compare_exchange_weak(oldValue, newValue)) {
         newValue = oldValue+iToAdd;
       }
     }