---

stor::RollingSampleCounter Class Reference

#include <EventFilter/StorageManager/interface/RollingSampleCounter.h>

Inheritance diagram for stor::RollingSampleCounter:

List of all members.

Public Types
enum	AccumulationStyle { INCLUDE_SAMPLES_AFTER_BINNING = 0, INCLUDE_SAMPLES_IMMEDIATELY = 1 }
Public Member Functions
void	addSample (double value=1.0, double currentTime=getCurrentTime())
	Adds the specified sample value to the counter instance.
void	dumpData (std::ostream &outStream)
	Dumps the contents of the counter to the specified output stream.
double	getDuration (double currentTime=0.0)
	Returns the amount of time (in seconds) that has elapsed between the time that the earliest sample in the counter was stored and the time that the latest was stored.
int	getSampleCount ()
	Returns the number of samples stored in the counter.
double	getSampleRate (double currentTime=0.0)
	Returns the rate of samples stored in the counter (number of samples divided by duration) or 0.0 if no samples have been stored.
double	getValueAverage ()
	Returns the average value of the samples that have been stored in the counter or 0.0 if no samples have been added.
double	getValueRate ()
	Returns the sample value rate (the sum of all sample values stored in the counter divided by the duration) or 0.0 if no samples have been stored.
double	getValueSum ()
	Returns the sum of all sample values stored in the counter.
bool	hasValidResult ()
	Tests if the counter has a valid result (enough samples have been stored).
	RollingSampleCounter (int windowSize=-1, int binSize=-1, int validSubWindowSize=-1, AccumulationStyle style=INCLUDE_SAMPLES_AFTER_BINNING)
	Constructor.
Private Member Functions
long long	getBinId (long long sampleCount)
	Calculates the bin ID for the given sample count.
void	shuffleBins (long long sampleCount)
	Modifies the internal list of bins so that it correctly reflects the current window.
Private Attributes
AccumulationStyle	accumStyle_
boost::shared_ptr< std::vector < double > >	binContents_
int	binCount_
int	binSize_
boost::shared_ptr< std::vector < double > >	binStartTimes_
boost::shared_ptr< std::vector < double > >	binStopTimes_
double	currentTotal_
boost::recursive_mutex	dataMutex_
long long	processedBinCount_
long long	sampleCount_
int	validBinCount_
int	windowSize_
long long	workingBinId_
double	workingBinStartTime_
double	workingBinSum_

---

Detailed Description

Definition at line 19 of file RollingSampleCounter.h.

---

Member Enumeration Documentation

enum stor::RollingSampleCounter::AccumulationStyle

Enumerator:

INCLUDE_SAMPLES_AFTER_BINNING
INCLUDE_SAMPLES_IMMEDIATELY

Definition at line 24 of file RollingSampleCounter.h.

                           { INCLUDE_SAMPLES_AFTER_BINNING = 0,
                             INCLUDE_SAMPLES_IMMEDIATELY = 1 };

---

Constructor & Destructor Documentation

RollingSampleCounter::RollingSampleCounter	(	int	windowSize = -1,
		int	binSize = -1,
		int	validSubWindowSize = -1,
		AccumulationStyle	style = INCLUDE_SAMPLES_AFTER_BINNING
	)

Constructor.

Definition at line 13 of file RollingSampleCounter.cc.

References binContents_, binCount_, binSize_, binStartTimes_, binStopTimes_, getBinId(), INCLUDE_SAMPLES_IMMEDIATELY, int, processedBinCount_, validBinCount_, windowSize_, and workingBinId_.

                                             :
  accumStyle_(style),
  sampleCount_(0),
  processedBinCount_(0),
  workingBinSum_(0.0),
  workingBinStartTime_(0.0),
  currentTotal_(0.0)
{
  // provide a reasonable default for the window size, if needed
  if (windowSize <= 0) {
    this->windowSize_ = 100;  // 100 samples
  }
  else {
    this->windowSize_ = windowSize;
  }

  // provide a reasonable default for the bin size, if needed
  if (binSize <= 0) {
    this->binSize_ = this->windowSize_;
  }
  else {
    this->binSize_ = binSize;
  }

  // determine the bin count from the window and bin sizes
  if (this->windowSize_ > 0 && this->binSize_ > 0) {
    this->binCount_ =
      (int) (0.5 + ((double) this->windowSize_ / (double) this->binSize_));
    if (this->binCount_ < 1) {
      this->binCount_ = 1;
    }

    // recalculate the window size to handle rounding
    this->windowSize_ = this->binCount_ * this->binSize_;
  }
  else {
    this->binCount_ = 1;
  }

  // determine the number of bins needed for a valid result
  this->validBinCount_ =
    (int) (0.5 + ((double) validSubWindowSize / (double) this->binSize_));
  if (this->validBinCount_ <= 0) {
    this->validBinCount_ = 1;
  }

  // if working with data immediately, assume the first bin is good
  if (this->accumStyle_ == INCLUDE_SAMPLES_IMMEDIATELY) {
    processedBinCount_ = 1;
  }

  // initialize times and bins
  this->workingBinId_ = getBinId(this->sampleCount_);
  this->binStartTimes_.reset(new std::vector<double>);
  this->binStopTimes_.reset(new std::vector<double>);
  this->binContents_.reset(new std::vector<double>);
  for (int idx = 0; idx < this->binCount_; ++idx) {
    this->binStartTimes_->push_back(0.0);
    this->binStopTimes_->push_back(0.0);
    this->binContents_->push_back(0.0);
  }
}

---

Member Function Documentation

void RollingSampleCounter::addSample	(	double	value = 1.0,
		double	currentTime = getCurrentTime()
	)

Adds the specified sample value to the counter instance.

Definition at line 80 of file RollingSampleCounter.cc.

References accumStyle_, binCount_, currentTotal_, dataMutex_, INCLUDE_SAMPLES_AFTER_BINNING, int, sampleCount_, shuffleBins(), sl, workingBinId_, workingBinStartTime_, and workingBinSum_.

{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  // shuffle the bins so that they correctly reflect the sample window
  shuffleBins(sampleCount_);
  ++sampleCount_;

  // add the new sample to either the working sum or the current
  // sum depending on the accumulation style
  if (accumStyle_ == INCLUDE_SAMPLES_AFTER_BINNING) {
    workingBinSum_ += value;
    if (sampleCount_ == 1) {
      workingBinStartTime_ = currentTime;
    }
  }
  else {
    int binIndex = (int) (workingBinId_ % binCount_);
    (*binContents_)[binIndex] += value;
    currentTotal_ += value;
    if (sampleCount_ == 1) {
      (*binStartTimes_)[binIndex] = currentTime;
    }
    (*binStopTimes_)[binIndex] = currentTime;
  }
}

void RollingSampleCounter::dumpData

(

std::ostream &

outStream

)

Dumps the contents of the counter to the specified output stream.

Definition at line 253 of file RollingSampleCounter.cc.

References binContents_, binCount_, binSize_, binStartTimes_, binStopTimes_, currentTotal_, lat::endl(), stor::BaseCounter::getCurrentTime(), int, processedBinCount_, sampleCount_, windowSize_, workingBinId_, and workingBinSum_.

{
  outStream << "RollingSampleCounter 0x" << std::hex
            << ((int) this) << std::dec << std::endl;
  char nowString[32];
  sprintf(nowString, "%16.4f", getCurrentTime());
  outStream << "  Now = " << nowString << std::endl;
  outStream << "  Window size = " << windowSize_ << std::endl;
  outStream << "  Bin size = " << binSize_ << std::endl;
  outStream << "  Sample count = " << sampleCount_ << std::endl;
  outStream << "  Processed bin count = " << processedBinCount_ << std::endl;
  outStream << "  Working index = "
            << ((int) (workingBinId_ % binCount_)) << std::endl;
  outStream << "  Working value = " << workingBinSum_ << std::endl;
  outStream << "  Current total = " << currentTotal_ << std::endl;

  char binString[200];
  for (int idx = 0; idx < binCount_; idx++) {
    sprintf(binString,
            "    bin %2d, value %10.2f, startTime %13.2f, stopTime %13.2f",
            idx, (*binContents_)[idx], (*binStartTimes_)[idx],
            (*binStopTimes_)[idx]);
    outStream << binString << std::endl;
  }
}

long long RollingSampleCounter::getBinId

(

long long

sampleCount

)

[private]

Calculates the bin ID for the given sample count.

Definition at line 329 of file RollingSampleCounter.cc.

References binSize_.

Referenced by RollingSampleCounter(), and shuffleBins().

{
  return (long long) (sampleCount / (long long) binSize_);
}

double RollingSampleCounter::getDuration

(

double

currentTime = 0.0

)

Returns the amount of time (in seconds) that has elapsed between the time that the earliest sample in the counter was stored and the time that the latest was stored.

Since old samples are discarded to make room for new ones, this does *not* correspond to the time since the first sample was added.
15-Apr-2008, KAB: added time argument. If it is non-zero, then the result of this method is the time between the earliest sample and the specified time.

Definition at line 211 of file RollingSampleCounter.cc.

References accumStyle_, binCount_, binStartTimes_, binStopTimes_, dataMutex_, hasValidResult(), INCLUDE_SAMPLES_IMMEDIATELY, int, processedBinCount_, sl, and workingBinId_.

Referenced by getSampleRate(), and getValueRate().

{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  //if (processedBinCount_ < 1 || ! hasValidResult()) {
  if (! hasValidResult()) {
    return 0.0;
  }
  else {
    int actualBinCount = binCount_;
    if (processedBinCount_ < binCount_) {
      actualBinCount = (int) processedBinCount_;
    }
    long long startBinId = workingBinId_ - actualBinCount;
    long long stopBinId = workingBinId_ - 1;
    if (accumStyle_ == RollingSampleCounter::INCLUDE_SAMPLES_IMMEDIATELY) {
      ++startBinId;
      ++stopBinId;
    }

    int startBinIndex = (int) (startBinId % binCount_);
    int stopBinIndex = (int) (stopBinId % binCount_);

    if ((*binStopTimes_)[stopBinIndex] > 0.0 &&
        (*binStartTimes_)[startBinIndex] > 0.0) {
      if (currentTime <= 0.0) {
        return ((*binStopTimes_)[stopBinIndex] -
                (*binStartTimes_)[startBinIndex]);
      }
      else {
        return (currentTime - (*binStartTimes_)[startBinIndex]);
      }
    }
    else {
      return 0.0;
    }
  }
}

int RollingSampleCounter::getSampleCount

(

)

Returns the number of samples stored in the counter.

This value will stop increasing when the full window size is reached.

Definition at line 122 of file RollingSampleCounter.cc.

References accumStyle_, binSize_, dataMutex_, INCLUDE_SAMPLES_IMMEDIATELY, int, HLT_VtxMuL3::result, sampleCount_, sl, and windowSize_.

Referenced by getSampleRate(), and getValueAverage().

{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  int result = windowSize_;
  if (sampleCount_ < windowSize_) {
    result = (int) sampleCount_;
  }
  else if (accumStyle_ == INCLUDE_SAMPLES_IMMEDIATELY && binSize_ > 1) {
    // NEED TO FIX!!!
    result = 1 + (int) ((sampleCount_ - 1) % windowSize_);
  }

  return result;
}

double RollingSampleCounter::getSampleRate

(

double

currentTime = 0.0

)

Returns the rate of samples stored in the counter (number of samples divided by duration) or 0.0 if no samples have been stored.

The units of the return value are samples per second.

Definition at line 143 of file RollingSampleCounter.cc.

References dataMutex_, getDuration(), getSampleCount(), and sl.

{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  double duration = getDuration(currentTime);
  if (duration > 0.0) {
    return ((double) getSampleCount()) / duration;
  }
  else {
    return 0.0;
  }
}

double RollingSampleCounter::getValueAverage

(

)

Returns the average value of the samples that have been stored in the counter or 0.0 if no samples have been added.

Definition at line 169 of file RollingSampleCounter.cc.

References currentTotal_, dataMutex_, getSampleCount(), and sl.

{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  if (getSampleCount() > 0) {
    return ((double) currentTotal_) / ((double) getSampleCount());
  }
  else {
    return 0.0;
  }
}

double RollingSampleCounter::getValueRate

(

)

Returns the sample value rate (the sum of all sample values stored in the counter divided by the duration) or 0.0 if no samples have been stored.

The units of the return value are [the units of the sample values] per second (e.g. MByte/sec).

Definition at line 187 of file RollingSampleCounter.cc.

References currentTotal_, dataMutex_, getDuration(), and sl.

{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  double duration = getDuration();
  if (duration > 0.0) {
    return ((double) currentTotal_) / duration;
  }
  else {
    return 0.0;
  }
}

double RollingSampleCounter::getValueSum

(

)

Returns the sum of all sample values stored in the counter.

Definition at line 159 of file RollingSampleCounter.cc.

References currentTotal_, dataMutex_, and sl.

                                         {
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  return currentTotal_;
}

bool RollingSampleCounter::hasValidResult

(

)

Tests if the counter has a valid result (enough samples have been stored).

Definition at line 111 of file RollingSampleCounter.cc.

References dataMutex_, processedBinCount_, sl, and validBinCount_.

Referenced by getDuration().

{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  return (processedBinCount_ >= validBinCount_);
}

void RollingSampleCounter::shuffleBins

(

long long

sampleCount

)

[private]

Modifies the internal list of bins so that it correctly reflects the current window.

Definition at line 283 of file RollingSampleCounter.cc.

References accumStyle_, binCount_, currentTotal_, getBinId(), stor::BaseCounter::getCurrentTime(), INCLUDE_SAMPLES_AFTER_BINNING, int, processedBinCount_, workingBinId_, workingBinStartTime_, and workingBinSum_.

Referenced by addSample().

{
  // determine the current bin
  long long currentBinId = getBinId(sampleCount);
  //std::cout << "Shuffle " << workingBinId_ << " "
  //          << currentBinId << std::endl;

  // if we're still working on the current bin, no shuffling is needed
  if (currentBinId == workingBinId_) {
    return;
  }
  ++processedBinCount_;
  double now = getCurrentTime();

  // handle the different accumulation styles
  if (accumStyle_ == INCLUDE_SAMPLES_AFTER_BINNING) {

    // move the working bin value into the list
    int binIndex = (int) (workingBinId_ % binCount_);
    currentTotal_ -= (*binContents_)[binIndex];
    (*binContents_)[binIndex] = workingBinSum_;
    (*binStartTimes_)[binIndex] = workingBinStartTime_;
    (*binStopTimes_)[binIndex] = now;
    currentTotal_ += workingBinSum_;
    workingBinSum_ = 0.0;
    workingBinStartTime_ = now;
  }

  else {

    // clear out the current bin value so it's ready for new data
    int binIndex = (int) (currentBinId % binCount_);
    currentTotal_ -= (*binContents_)[binIndex];
    (*binContents_)[binIndex] = 0.0;

    int binIndex2 = (int) (workingBinId_ % binCount_);
    (*binStartTimes_)[binIndex] = (*binStopTimes_)[binIndex2];
  }

  // update the working bin ID to the current bin
  workingBinId_ = currentBinId;
}

---

Member Data Documentation

AccumulationStyle stor::RollingSampleCounter::accumStyle_ [private]

Definition at line 47 of file RollingSampleCounter.h.

Referenced by addSample(), getDuration(), getSampleCount(), and shuffleBins().

boost::shared_ptr< std::vector<double> > stor::RollingSampleCounter::binContents_ [private]

Definition at line 65 of file RollingSampleCounter.h.

Referenced by dumpData(), and RollingSampleCounter().

int stor::RollingSampleCounter::binCount_ [private]

Definition at line 51 of file RollingSampleCounter.h.

Referenced by addSample(), dumpData(), getDuration(), RollingSampleCounter(), and shuffleBins().

int stor::RollingSampleCounter::binSize_ [private]

Definition at line 50 of file RollingSampleCounter.h.

Referenced by dumpData(), getBinId(), getSampleCount(), and RollingSampleCounter().

boost::shared_ptr< std::vector<double> > stor::RollingSampleCounter::binStartTimes_ [private]

Definition at line 63 of file RollingSampleCounter.h.

Referenced by dumpData(), getDuration(), and RollingSampleCounter().

boost::shared_ptr< std::vector<double> > stor::RollingSampleCounter::binStopTimes_ [private]

Definition at line 64 of file RollingSampleCounter.h.

Referenced by dumpData(), getDuration(), and RollingSampleCounter().

double stor::RollingSampleCounter::currentTotal_ [private]

Definition at line 61 of file RollingSampleCounter.h.

Referenced by addSample(), dumpData(), getValueAverage(), getValueRate(), getValueSum(), and shuffleBins().

boost::recursive_mutex stor::RollingSampleCounter::dataMutex_ [private]

Definition at line 67 of file RollingSampleCounter.h.

Referenced by addSample(), getDuration(), getSampleCount(), getSampleRate(), getValueAverage(), getValueRate(), getValueSum(), and hasValidResult().

long long stor::RollingSampleCounter::processedBinCount_ [private]

Definition at line 55 of file RollingSampleCounter.h.

Referenced by dumpData(), getDuration(), hasValidResult(), RollingSampleCounter(), and shuffleBins().

long long stor::RollingSampleCounter::sampleCount_ [private]

Definition at line 54 of file RollingSampleCounter.h.

Referenced by addSample(), dumpData(), and getSampleCount().

int stor::RollingSampleCounter::validBinCount_ [private]

Definition at line 52 of file RollingSampleCounter.h.

Referenced by hasValidResult(), and RollingSampleCounter().

int stor::RollingSampleCounter::windowSize_ [private]

Definition at line 49 of file RollingSampleCounter.h.

Referenced by dumpData(), getSampleCount(), and RollingSampleCounter().

long long stor::RollingSampleCounter::workingBinId_ [private]

Definition at line 59 of file RollingSampleCounter.h.

Referenced by addSample(), dumpData(), getDuration(), RollingSampleCounter(), and shuffleBins().

double stor::RollingSampleCounter::workingBinStartTime_ [private]

Definition at line 58 of file RollingSampleCounter.h.

Referenced by addSample(), and shuffleBins().

double stor::RollingSampleCounter::workingBinSum_ [private]

Definition at line 57 of file RollingSampleCounter.h.

Referenced by addSample(), dumpData(), and shuffleBins().

---

The documentation for this class was generated from the following files:

• EventFilter/StorageManager/interface/RollingSampleCounter.h
• EventFilter/StorageManager/src/RollingSampleCounter.cc

---