Efficient counter implementations for Gaudi.
A number of concepts and templated classes are defined:
Concepts
- Accumulator : object accumulating some data in some way. examples : counters, sum of squares accumulator, minimum accumulator (keeps minimum of all values)
- Atomicity : the atomicity of an accumulator. Can be none or full. "none" means that the accumulator is not thread safe and should only be used locally within a thread. "full" means that the accumulator is thread safe, but that you pay the price of atomics inside. Note that this price may be reduced by the usage of the Buffer class, see below.
- InputTransform : a transformation to be applied to the input of an Accumulator. for example "elevation to power 2" for a sum of squares Accumulator, "identity" for a sum Accumulator or a minimum Accumulator, "constant 1" for a pure counter
- OutputTransform : a transformation to be applied to the value of an Accumulator when reading it. Usually identity. You can think of square root for an RMS Accumulator (accumulating squares internally)
- ValueHandler : the class handling the internal value of an Accumulator, and responsible for updating it with a new input. It defines the initial default value, the storage type used (depending on atomicity) and the actual update operation (sum, keep min or max typically).
- AccumulatorSet : an Accumulator defined as a set of Accumulators with same InputType and Atomicity. Updating it means updating all Accumulators of the set with the same value. E.g. a set with Counter and Sum will be able to compute some average
- Buffer : a wrapper around a thread safe Accumulator that allows to accumulate locally (in a non thread safe Accumulator) data before merging into the original one when Buffer is destructed. To be use when accumulators are updated in tight loops
- Counter : a higher level object that is an Accumulator and provides extra methods, most notably a way to print itself via operator<<, a print method and a buffer method to retrieve a Buffer on top of it.
Classes and helper functions
- many classes are directly linked to concepts :
- Constant, Identity, Square are InputTransforms / OutputTransforms
- BaseValueHandler : a base class for ValueHandlers Adder, Minimum and Maximum
- Adder, Extremum, Minimum, Maximum, Binomial are ValueHandlers
- GenericAccumulator : implements a generic Accumulator. See class definition for details
- AccumulatorSet binds together a set of Accumulators into a new accumulator
- Buffer implements the local buffering of an Accumulator
- some classes implements the most common Accumulators :
- MaxAccumulator : keeps the max, has a max() method
- MinAccumulator : keeps the min, has a min() method
- CountAccumulator : keeps count of number of values, has a nEntries() method
- SumAccumulator : keeps the sum of all values, has a sum() method
- SquareAccumulator : keeps the sum of all values squared, has a sum2() method
- TrueAccumulator : keeps a count of the number of true values, has a nTrueEntries() method
- FalseAccumulator : keeps a count of the number of false values, has a nFalseEntries() method
- BinomialAccumulator : set of TrueAccumulator and FalseAccumulator. Has extra nEntries(), efficiency() and efficiencyErr() methods
- AveragingAccumulator : set of CountAccumulator and SumAccumulator. Has an extra mean() method
- SigmaAccumulator : set of AveragingAccumulator and SquareAccumulator. Has extra methods variance(), standard_deviation() and meanErr()
- MsgCounter: keeps a count of number of values, and prints the first N times it is incremented at a specified logging level
- StatAccumulator : set of SigmaAccumulator, MinAccumulator and MaxAccumulator
- some classes implement the most common Counters :
- PrintableCounter is the interface to be used for abstract counters that can be printed
- BufferableCounter is the base class for counters that can be buffered. It provides a buffer method returning a Buffer on the current counter
- Counter, AveragingCounter, SigmaCounter, StatCounter, BinomialCounter : standard counters based on the corresponding accumulators
- StatEntity : a counter meant to be backward compatible with the old one and actually being a set of StatAccumulator and BinomialAccumulator. StatEntity should not be used and should be dropped when ancient code has been ported to the other counters
Notes
All Accumulators and Counters defined above are provided in their atomic and non atomic versions
Here is an example of the typical usage of these classes :
AveragingCounter<> avg;
avg += 3;
avg += 5;
avg += 6;
SigmaCounter<> sig;
sig += 3;
sig += 5;
sig += 6;
AveragingCounter<float, atomicity::full> avg2;
{
auto buf = avg2.buffer();
for ( int i = 0; i < 1000; i++ ) buf += i;
}
BinomialCounter<> bin;
bin += false;
bin += true;
bin += true;
bin += false;
bin += false;
se += 3;
se += 5;
se += 6;
1.8.15