#include <StorageAccount.h>

Public Member Functions
	Counter ()

	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 39 of file StorageAccount.h.

Constructor & Destructor Documentation

StorageAccount::Counter::Counter ( )

inline

Definition at line 40 of file StorageAccount.h.

References summarizeEdmComparisonLogfiles::successes, HLT_2018_cff::timeMax, and HLT_2018_cff::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 const & iOther )

inline

Definition at line 55 of file StorageAccount.h.

References attempts, summarizeEdmComparisonLogfiles::successes, HLT_2018_cff::timeMax, and HLT_2018_cff::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 84 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;
       }
     }