---

stor::EventServer Class Reference

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

List of all members.

Public Types
enum	STATS_SAMPLE_TYPE { INPUT_STATS = 10, OUTPUT_STATS = 11, UNIQUE_ACCEPT_STATS = 12 }
enum	STATS_TIME_FRAME { SHORT_TERM_STATS = 0, LONG_TERM_STATS = 1 }
enum	STATS_TIMING_TYPE { CPUTIME = 20, REALTIME = 21 }
Public Member Functions
void	addConsumer (boost::shared_ptr< ConsumerPipe > consumer)
	Adds the specified consumer to the event server.
void	clearQueue ()
	EventServer (double maxEventRate, double maxDataRate, std::string hltOutputSelection, bool runFairShareAlgo=false)
	EventServer constructor.
boost::shared_ptr< ConsumerPipe >	getConsumer (uint32 consumerId)
	Returns a shared pointer to the consumer pipe with the specified ID or an empty pointer if the ID was not found.
std::map< uint32, boost::shared_ptr < ConsumerPipe > >	getConsumerTable ()
double	getDataRate (STATS_TIME_FRAME timeFrame=SHORT_TERM_STATS, STATS_SAMPLE_TYPE sampleType=INPUT_STATS, uint32 outputModuleId=0, double currentTime=ForeverCounter::getCurrentTime())
	Returns the data rate for the specified statistics types (short term vs.
double	getDuration (STATS_TIME_FRAME timeFrame=SHORT_TERM_STATS, STATS_SAMPLE_TYPE sampleType=INPUT_STATS, uint32 outputModuleId=0, double currentTime=ForeverCounter::getCurrentTime())
	Returns the duration (in seconds) for the specified statistics types (short term vs.
boost::shared_ptr< std::vector < char > >	getEvent (uint32 consumerId)
	Returns the next event for the specified consumer.
long long	getEventCount (STATS_TIME_FRAME timeFrame=SHORT_TERM_STATS, STATS_SAMPLE_TYPE sampleType=INPUT_STATS, uint32 outputModuleId=0, double currentTime=ForeverCounter::getCurrentTime())
	Returns the number of events for the specified statistics types (short term vs.
double	getEventRate (STATS_TIME_FRAME timeFrame=SHORT_TERM_STATS, STATS_SAMPLE_TYPE sampleType=INPUT_STATS, uint32 outputModuleId=0, double currentTime=ForeverCounter::getCurrentTime())
	Returns the rate of events for the specified statistics types (short term vs.
std::string	getHLTOutputSelection () const
double	getInternalTime (STATS_TIME_FRAME timeFrame=SHORT_TERM_STATS, STATS_TIMING_TYPE timingType=CPUTIME, double currentTime=ForeverCounter::getCurrentTime())
	Returns the amount of time spent processing events inside the event server for the specified time frame (short or long term) and timing type (CPU time or real time).
double	getMaxDataRate () const
double	getMaxEventRate () const
int	getSelectionTableStringSize ()
std::map< std::string, Strings >	getStreamSelectionTable ()
double	getTimeFraction (STATS_TIME_FRAME timeFrame=SHORT_TERM_STATS, STATS_TIMING_TYPE timingType=CPUTIME, double currentTime=ForeverCounter::getCurrentTime())
	Returns the fraction of time spent processing events inside the event server for the specified time frame (short or long term) and timing type (CPU time or real time).
double	getTotalTime (STATS_TIME_FRAME timeFrame=SHORT_TERM_STATS, STATS_TIMING_TYPE timingType=CPUTIME, double currentTime=ForeverCounter::getCurrentTime())
	Returns the total time used by the current process (both inside and outside the event server) for the specified time frame (short or long term) and timing type (CPU time or real time).
void	processEvent (const EventMsgView &eventView)
	Processes the specified event.
void	setStreamSelectionTable (std::map< std::string, Strings > const &selTable)
Strings	updateTriggerSelectionForStreams (Strings const &selectionList)
	~EventServer ()
	EventServer destructor.
Private Attributes
boost::mt19937	baseGenerator_
std::map< uint32, boost::shared_ptr < ConsumerPipe > >	consumerTable_
int	disconnectedConsumerTestCounter_
boost::shared_ptr < boost::uniform_01 < boost::mt19937 > >	generator_
uint32	hltOutputModuleId_
std::string	hltOutputSelection_
edm::CPUTimer	insideTimer_
boost::shared_ptr< ForeverCounter >	longTermInsideCPUTimeCounter_
boost::shared_ptr< ForeverCounter >	longTermInsideRealTimeCounter_
boost::shared_ptr< ForeverCounter >	longTermOutsideCPUTimeCounter_
boost::shared_ptr< ForeverCounter >	longTermOutsideRealTimeCounter_
std::map< uint32, boost::shared_ptr < ForeverCounter > >	ltAcceptCounters_
std::map< uint32, boost::shared_ptr < ForeverCounter > >	ltInputCounters_
std::map< uint32, boost::shared_ptr < ForeverCounter > >	ltOutputCounters_
double	maxDataRate_
double	maxEventRate_
edm::CPUTimer	outsideTimer_
boost::shared_ptr< RateLimiter >	rateLimiter_
bool	runFairShareAlgo_
int	selTableStringSize_
boost::shared_ptr < RollingIntervalCounter >	shortTermInsideCPUTimeCounter_
boost::shared_ptr < RollingIntervalCounter >	shortTermInsideRealTimeCounter_
boost::shared_ptr < RollingIntervalCounter >	shortTermOutsideCPUTimeCounter_
boost::shared_ptr < RollingIntervalCounter >	shortTermOutsideRealTimeCounter_
std::map< uint32, boost::shared_ptr < RollingIntervalCounter > >	stAcceptCounters_
std::map< uint32, boost::shared_ptr < RollingIntervalCounter > >	stInputCounters_
std::map< uint32, boost::shared_ptr < RollingIntervalCounter > >	stOutputCounters_
std::map< std::string, Strings >	streamSelectionTable_

---

Detailed Description

Definition at line 36 of file EventServer.h.

---

Member Enumeration Documentation

enum stor::EventServer::STATS_SAMPLE_TYPE

Enumerator:

INPUT_STATS
OUTPUT_STATS
UNIQUE_ACCEPT_STATS

Definition at line 40 of file EventServer.h.

                           { INPUT_STATS = 10, OUTPUT_STATS = 11,
                             UNIQUE_ACCEPT_STATS = 12 };

enum stor::EventServer::STATS_TIME_FRAME

Enumerator:

SHORT_TERM_STATS
LONG_TERM_STATS

Definition at line 39 of file EventServer.h.

{ SHORT_TERM_STATS = 0, LONG_TERM_STATS = 1 };

enum stor::EventServer::STATS_TIMING_TYPE

Enumerator:

CPUTIME
REALTIME

Definition at line 42 of file EventServer.h.

{ CPUTIME = 20, REALTIME = 21 };

---

Constructor & Destructor Documentation

EventServer::EventServer	(	double	maxEventRate,
		double	maxDataRate,
		std::string	hltOutputSelection,
		bool	runFairShareAlgo = false
	)

EventServer constructor.

Throttling events are supported: specifying a maximimum allowed rate of accepted events

Definition at line 23 of file EventServer.cc.

References baseGenerator_, disconnectedConsumerTestCounter_, generator_, hltOutputModuleId_, hltOutputSelection_, insideTimer_, L, longTermInsideCPUTimeCounter_, longTermInsideRealTimeCounter_, longTermOutsideCPUTimeCounter_, longTermOutsideRealTimeCounter_, ltAcceptCounters_, ltInputCounters_, ltOutputCounters_, maxDataRate_, maxEventRate_, outsideTimer_, edm::CPUTimer::reset(), runFairShareAlgo_, selTableStringSize_, shortTermInsideCPUTimeCounter_, shortTermInsideRealTimeCounter_, shortTermOutsideCPUTimeCounter_, shortTermOutsideRealTimeCounter_, stAcceptCounters_, stInputCounters_, and stOutputCounters_.

{
  // initialize counters
  disconnectedConsumerTestCounter_ = 0;

  selTableStringSize_ = 0;

  ltInputCounters_.clear();
  stInputCounters_.clear();
  ltAcceptCounters_.clear();
  stAcceptCounters_.clear();
  ltOutputCounters_.clear();
  stOutputCounters_.clear();

  //rateLimiter_.reset(new RateLimiter(maxEventRate, maxDataRate));
  this->maxEventRate_ = maxEventRate;
  this->maxDataRate_ = maxDataRate;

  // 11-Jun-2008, KAB - the fair-share algo needs better requirements AND
  // needs consumer subscriptions to be forwarded from the ProxyServer
  // to the SMs.  So, prevent its use, for now.
  // (To be honest, I'm not sure that we can even support dynamic switching
  // on and off of the FS algo.)
  assert(! runFairShareAlgo);
  this->runFairShareAlgo_ = runFairShareAlgo;

  this->hltOutputSelection_ = hltOutputSelection;
  uLong crc = crc32(0L, Z_NULL, 0);
  Bytef* crcbuf = (Bytef*) hltOutputSelection.data();
  crc = crc32(crc, crcbuf, hltOutputSelection.length());
  this->hltOutputModuleId_ = static_cast<uint32>(crc);

  outsideTimer_.reset();
  insideTimer_.reset();

  // initialize the counters that we use for statistics
  longTermInsideCPUTimeCounter_.reset(new ForeverCounter());
  shortTermInsideCPUTimeCounter_.reset(new RollingIntervalCounter(180,5,20));
  longTermInsideRealTimeCounter_.reset(new ForeverCounter());
  shortTermInsideRealTimeCounter_.reset(new RollingIntervalCounter(180,5,20));
  longTermOutsideCPUTimeCounter_.reset(new ForeverCounter());
  shortTermOutsideCPUTimeCounter_.reset(new RollingIntervalCounter(180,5,20));
  longTermOutsideRealTimeCounter_.reset(new ForeverCounter());
  shortTermOutsideRealTimeCounter_.reset(new RollingIntervalCounter(180,5,20));

  generator_.reset(new boost::uniform_01<boost::mt19937>(baseGenerator_));
}

EventServer::~EventServer

(

)

EventServer destructor.

Definition at line 76 of file EventServer.cc.

References lat::endl(), and FDEBUG.

{
  FDEBUG(5) << "Executing destructor for event server " << std::endl;
}

---

Member Function Documentation

void EventServer::addConsumer

(

boost::shared_ptr< ConsumerPipe >

consumer

)

Adds the specified consumer to the event server.

Definition at line 84 of file EventServer.cc.

References consumerTable_.

{
  uint32 consumerId = consumer->getConsumerId();
  consumerTable_[consumerId] = consumer;

  // add the consumer (by ID) to the rateLimiter instance that we use
  // to provide a fair share of the limited bandwidth to each consumer.
  //rateLimiter_->addConsumer(consumerId);
}

void EventServer::clearQueue

(

)

Definition at line 420 of file EventServer.cc.

References consumerTable_.

{
  std::map< uint32, boost::shared_ptr<ConsumerPipe> >::const_iterator consIter;
  for (consIter = consumerTable_.begin();
       consIter != consumerTable_.end();
       consIter++)
  {
    boost::shared_ptr<ConsumerPipe> consPipe = consIter->second;
    consPipe->clearQueue();
  }
}

boost::shared_ptr< ConsumerPipe > EventServer::getConsumer

(

uint32

consumerId

)

Returns a shared pointer to the consumer pipe with the specified ID or an empty pointer if the ID was not found.

Definition at line 103 of file EventServer.cc.

References consumerTable_.

Referenced by processEvent().

{
  // initial empty pointer
  boost::shared_ptr<ConsumerPipe> consPtr;

  // lookup the consumer
  std::map< uint32, boost::shared_ptr<ConsumerPipe> >::const_iterator consIter;
  consIter = consumerTable_.find(consumerId);
  if (consIter != consumerTable_.end())
  {
    consPtr = consIter->second;
  }

  // return the pointer
  return consPtr;
}

std::map< uint32, boost::shared_ptr< ConsumerPipe > > EventServer::getConsumerTable

(

)

Definition at line 94 of file EventServer.cc.

References consumerTable_.

{
  return(consumerTable_);
}

double EventServer::getDataRate	(	STATS_TIME_FRAME	timeFrame = SHORT_TERM_STATS,
		STATS_SAMPLE_TYPE	sampleType = INPUT_STATS,
		uint32	outputModuleId = 0,
		double	currentTime = ForeverCounter::getCurrentTime()
	)

Returns the data rate for the specified statistics types (short term vs.

long term; input vs. output).

Definition at line 641 of file EventServer.cc.

References INPUT_STATS, ltAcceptCounters_, ltInputCounters_, ltOutputCounters_, SHORT_TERM_STATS, stAcceptCounters_, stInputCounters_, stOutputCounters_, and UNIQUE_ACCEPT_STATS.

{
  boost::shared_ptr<ForeverCounter> ltCounter;
  boost::shared_ptr<RollingIntervalCounter> stCounter;
  std::map<uint32, boost::shared_ptr<ForeverCounter> >::iterator ltIter;
  std::map<uint32, boost::shared_ptr<RollingIntervalCounter> >::iterator stIter;

  if (timeFrame == SHORT_TERM_STATS) {
    if (sampleType == INPUT_STATS) {
      stIter = stInputCounters_.find(outputModuleId);
      if (stIter != stInputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getValueRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      stIter = stAcceptCounters_.find(outputModuleId);
      if (stIter != stAcceptCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getValueRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else {
      stIter = stOutputCounters_.find(outputModuleId);
      if (stIter != stOutputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getValueRate(currentTime);
      }
      else {
        return 0;
      }
    }
  }
  else {
    if (sampleType == INPUT_STATS) {
      ltIter = ltInputCounters_.find(outputModuleId);
      if (ltIter != ltInputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getValueRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      ltIter = ltAcceptCounters_.find(outputModuleId);
      if (ltIter != ltAcceptCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getValueRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else {
      ltIter = ltOutputCounters_.find(outputModuleId);
      if (ltIter != ltOutputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getValueRate(currentTime);
      }
      else {
        return 0;
      }
    }
  }
}

double EventServer::getDuration	(	STATS_TIME_FRAME	timeFrame = SHORT_TERM_STATS,
		STATS_SAMPLE_TYPE	sampleType = INPUT_STATS,
		uint32	outputModuleId = 0,
		double	currentTime = ForeverCounter::getCurrentTime()
	)

Returns the duration (in seconds) for the specified statistics types (short term vs.

long term; input vs. output). "Duration" here means the length of time in which the specified statistics have been collected.

Definition at line 723 of file EventServer.cc.

References INPUT_STATS, ltAcceptCounters_, ltInputCounters_, ltOutputCounters_, SHORT_TERM_STATS, stAcceptCounters_, stInputCounters_, stOutputCounters_, and UNIQUE_ACCEPT_STATS.

{
  boost::shared_ptr<ForeverCounter> ltCounter;
  boost::shared_ptr<RollingIntervalCounter> stCounter;
  std::map<uint32, boost::shared_ptr<ForeverCounter> >::iterator ltIter;
  std::map<uint32, boost::shared_ptr<RollingIntervalCounter> >::iterator stIter;

  if (timeFrame == SHORT_TERM_STATS) {
    if (sampleType == INPUT_STATS) {
      stIter = stInputCounters_.find(outputModuleId);
      if (stIter != stInputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getDuration(currentTime);
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      stIter = stAcceptCounters_.find(outputModuleId);
      if (stIter != stAcceptCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getDuration(currentTime);
      }
      else {
        return 0;
      }
    }
    else {
      stIter = stOutputCounters_.find(outputModuleId);
      if (stIter != stOutputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getDuration(currentTime);
      }
      else {
        return 0;
      }
    }
  }
  else {
    if (sampleType == INPUT_STATS) {
      ltIter = ltInputCounters_.find(outputModuleId);
      if (ltIter != ltInputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getDuration(currentTime);
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      ltIter = ltAcceptCounters_.find(outputModuleId);
      if (ltIter != ltAcceptCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getDuration(currentTime);
      }
      else {
        return 0;
      }
    }
    else {
      ltIter = ltOutputCounters_.find(outputModuleId);
      if (ltIter != ltOutputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getDuration(currentTime);
      }
      else {
        return 0;
      }
    }
  }
}

boost::shared_ptr< std::vector< char > > EventServer::getEvent

(

uint32

consumerId

)

Returns the next event for the specified consumer.

Definition at line 402 of file EventServer.cc.

References consumerTable_.

{
  // initial empty buffer
  boost::shared_ptr< vector<char> > bufPtr;

  // lookup the consumer
  std::map< uint32, boost::shared_ptr<ConsumerPipe> >::const_iterator consIter;
  consIter = consumerTable_.find(consumerId);
  if (consIter != consumerTable_.end())
  {
    boost::shared_ptr<ConsumerPipe> consPipe = consIter->second;
    bufPtr = consPipe->getEvent();
  }

  // return the event buffer
  return bufPtr;
}

long long EventServer::getEventCount	(	STATS_TIME_FRAME	timeFrame = SHORT_TERM_STATS,
		STATS_SAMPLE_TYPE	sampleType = INPUT_STATS,
		uint32	outputModuleId = 0,
		double	currentTime = ForeverCounter::getCurrentTime()
	)

Returns the number of events for the specified statistics types (short term vs.

long term; input vs. output).

Definition at line 481 of file EventServer.cc.

References INPUT_STATS, ltAcceptCounters_, ltInputCounters_, ltOutputCounters_, SHORT_TERM_STATS, stAcceptCounters_, stInputCounters_, stOutputCounters_, and UNIQUE_ACCEPT_STATS.

{
  boost::shared_ptr<ForeverCounter> ltCounter;
  boost::shared_ptr<RollingIntervalCounter> stCounter;
  std::map<uint32, boost::shared_ptr<ForeverCounter> >::iterator ltIter;
  std::map<uint32, boost::shared_ptr<RollingIntervalCounter> >::iterator stIter;

  if (timeFrame == SHORT_TERM_STATS) {
    if (sampleType == INPUT_STATS) {
      stIter = stInputCounters_.find(outputModuleId);
      if (stIter != stInputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getSampleCount(currentTime);
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      stIter = stAcceptCounters_.find(outputModuleId);
      if (stIter != stAcceptCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getSampleCount(currentTime);
      }
      else {
        return 0;
      }
    }
    else {
      stIter = stOutputCounters_.find(outputModuleId);
      if (stIter != stOutputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getSampleCount(currentTime);
      }
      else {
        return 0;
      }
    }
  }
  else {
    if (sampleType == INPUT_STATS) {
      ltIter = ltInputCounters_.find(outputModuleId);
      if (ltIter != ltInputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getSampleCount();
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      ltIter = ltAcceptCounters_.find(outputModuleId);
      if (ltIter != ltAcceptCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getSampleCount();
      }
      else {
        return 0;
      }
    }
    else {
      ltIter = ltOutputCounters_.find(outputModuleId);
      if (ltIter != ltOutputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getSampleCount();
      }
      else {
        return 0;
      }
    }
  }
}

double EventServer::getEventRate	(	STATS_TIME_FRAME	timeFrame = SHORT_TERM_STATS,
		STATS_SAMPLE_TYPE	sampleType = INPUT_STATS,
		uint32	outputModuleId = 0,
		double	currentTime = ForeverCounter::getCurrentTime()
	)

Returns the rate of events for the specified statistics types (short term vs.

long term; input vs. output).

Definition at line 561 of file EventServer.cc.

References INPUT_STATS, ltAcceptCounters_, ltInputCounters_, ltOutputCounters_, SHORT_TERM_STATS, stAcceptCounters_, stInputCounters_, stOutputCounters_, and UNIQUE_ACCEPT_STATS.

{
  boost::shared_ptr<ForeverCounter> ltCounter;
  boost::shared_ptr<RollingIntervalCounter> stCounter;
  std::map<uint32, boost::shared_ptr<ForeverCounter> >::iterator ltIter;
  std::map<uint32, boost::shared_ptr<RollingIntervalCounter> >::iterator stIter;

  if (timeFrame == SHORT_TERM_STATS) {
    if (sampleType == INPUT_STATS) {
      stIter = stInputCounters_.find(outputModuleId);
      if (stIter != stInputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getSampleRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      stIter = stAcceptCounters_.find(outputModuleId);
      if (stIter != stAcceptCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getSampleRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else {
      stIter = stOutputCounters_.find(outputModuleId);
      if (stIter != stOutputCounters_.end()) {
        stCounter = stIter->second;
        return stCounter->getSampleRate(currentTime);
      }
      else {
        return 0;
      }
    }
  }
  else {
    if (sampleType == INPUT_STATS) {
      ltIter = ltInputCounters_.find(outputModuleId);
      if (ltIter != ltInputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getSampleRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else if (sampleType == UNIQUE_ACCEPT_STATS) {
      ltIter = ltAcceptCounters_.find(outputModuleId);
      if (ltIter != ltAcceptCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getSampleRate(currentTime);
      }
      else {
        return 0;
      }
    }
    else {
      ltIter = ltOutputCounters_.find(outputModuleId);
      if (ltIter != ltOutputCounters_.end()) {
        ltCounter = ltIter->second;
        return ltCounter->getSampleRate(currentTime);
      }
      else {
        return 0;
      }
    }
  }
}

std::string stor::EventServer::getHLTOutputSelection

(

)

const [inline]

Definition at line 69 of file EventServer.h.

References hltOutputSelection_.

{ return hltOutputSelection_; }

double EventServer::getInternalTime	(	STATS_TIME_FRAME	timeFrame = SHORT_TERM_STATS,
		STATS_TIMING_TYPE	timingType = CPUTIME,
		double	currentTime = ForeverCounter::getCurrentTime()
	)

Returns the amount of time spent processing events inside the event server for the specified time frame (short or long term) and timing type (CPU time or real time).

Definition at line 804 of file EventServer.cc.

References CPUTIME, longTermInsideCPUTimeCounter_, longTermInsideRealTimeCounter_, SHORT_TERM_STATS, shortTermInsideCPUTimeCounter_, and shortTermInsideRealTimeCounter_.

{
  if (timeFrame == SHORT_TERM_STATS) {
    if (timingType == CPUTIME) {
      return shortTermInsideCPUTimeCounter_->getValueSum(currentTime);
    }
    else {
      return shortTermInsideRealTimeCounter_->getValueSum(currentTime);
    }
  }
  else {
    if (timingType == CPUTIME) {
      return longTermInsideCPUTimeCounter_->getValueSum();
    }
    else {
      return longTermInsideRealTimeCounter_->getValueSum();
    }
  }
}

double stor::EventServer::getMaxDataRate

(

)

const [inline]

Definition at line 68 of file EventServer.h.

References maxDataRate_.

{ return maxDataRate_; }

double stor::EventServer::getMaxEventRate

(

)

const [inline]

Definition at line 67 of file EventServer.h.

References maxEventRate_.

{ return maxEventRate_; }

int stor::EventServer::getSelectionTableStringSize

(

)

[inline]

Definition at line 61 of file EventServer.h.

References selTableStringSize_.

    {
      return selTableStringSize_;
    }

std::map<std::string, Strings> stor::EventServer::getStreamSelectionTable

(

)

[inline]

Definition at line 57 of file EventServer.h.

References streamSelectionTable_.

    {
      return streamSelectionTable_;
    }

double EventServer::getTimeFraction	(	STATS_TIME_FRAME	timeFrame = SHORT_TERM_STATS,
		STATS_TIMING_TYPE	timingType = CPUTIME,
		double	currentTime = ForeverCounter::getCurrentTime()
	)

Returns the fraction of time spent processing events inside the event server for the specified time frame (short or long term) and timing type (CPU time or real time).

Definition at line 874 of file EventServer.cc.

References CPUTIME, longTermInsideCPUTimeCounter_, longTermInsideRealTimeCounter_, longTermOutsideCPUTimeCounter_, longTermOutsideRealTimeCounter_, SHORT_TERM_STATS, shortTermInsideCPUTimeCounter_, shortTermInsideRealTimeCounter_, shortTermOutsideCPUTimeCounter_, and shortTermOutsideRealTimeCounter_.

{
  if (timeFrame == SHORT_TERM_STATS) {
    if (timingType == CPUTIME) {
      double insideTime =
        shortTermInsideCPUTimeCounter_->getValueSum(currentTime);
      double outsideTime =
        shortTermOutsideCPUTimeCounter_->getValueSum(currentTime);
      if (outsideTime > 0.0) {
        return (insideTime / (insideTime + outsideTime));
      }
      else {
        return 0.0;
      }
    }
    else {
      double insideTime =
        shortTermInsideRealTimeCounter_->getValueSum(currentTime);
      double outsideTime =
        shortTermOutsideRealTimeCounter_->getValueSum(currentTime);
      if (outsideTime > 0.0) {
        return (insideTime / (insideTime + outsideTime));
      }
      else {
        return 0.0;
      }
    }
  }
  else {
    if (timingType == CPUTIME) {
      double insideTime =
        longTermInsideCPUTimeCounter_->getValueSum();
      double outsideTime =
        longTermOutsideCPUTimeCounter_->getValueSum();
      if (outsideTime > 0.0) {
        return (insideTime / (insideTime + outsideTime));
      }
      else {
        return 0.0;
      }
    }
    else {
      double insideTime =
        longTermInsideRealTimeCounter_->getValueSum();
      double outsideTime =
        longTermOutsideRealTimeCounter_->getValueSum();
      if (outsideTime > 0.0) {
        return (insideTime / (insideTime + outsideTime));
      }
      else {
        return 0.0;
      }
    }
  }
}

double EventServer::getTotalTime	(	STATS_TIME_FRAME	timeFrame = SHORT_TERM_STATS,
		STATS_TIMING_TYPE	timingType = CPUTIME,
		double	currentTime = ForeverCounter::getCurrentTime()
	)

Returns the total time used by the current process (both inside and outside the event server) for the specified time frame (short or long term) and timing type (CPU time or real time).

Definition at line 831 of file EventServer.cc.

References CPUTIME, longTermInsideCPUTimeCounter_, longTermInsideRealTimeCounter_, longTermOutsideCPUTimeCounter_, longTermOutsideRealTimeCounter_, SHORT_TERM_STATS, shortTermInsideCPUTimeCounter_, shortTermInsideRealTimeCounter_, shortTermOutsideCPUTimeCounter_, and shortTermOutsideRealTimeCounter_.

{
  if (timeFrame == SHORT_TERM_STATS) {
    if (timingType == CPUTIME) {
      double insideTime =
        shortTermInsideCPUTimeCounter_->getValueSum(currentTime);
      double outsideTime =
        shortTermOutsideCPUTimeCounter_->getValueSum(currentTime);
      return (insideTime + outsideTime);
    }
    else {
      double insideTime =
        shortTermInsideRealTimeCounter_->getValueSum(currentTime);
      double outsideTime =
        shortTermOutsideRealTimeCounter_->getValueSum(currentTime);
      return (insideTime + outsideTime);
    }
  }
  else {
    if (timingType == CPUTIME) {
      double insideTime =
        longTermInsideCPUTimeCounter_->getValueSum();
      double outsideTime =
        longTermOutsideCPUTimeCounter_->getValueSum();
      return (insideTime + outsideTime);
    }
    else {
      double insideTime =
        longTermInsideRealTimeCounter_->getValueSum();
      double outsideTime =
        longTermOutsideRealTimeCounter_->getValueSum();
      return (insideTime + outsideTime);
    }
  }
}

void EventServer::processEvent

(

const EventMsgView &

eventView

)

Processes the specified event.

This includes checking whether the event is allowed to be delivered to consumers based on the maximum event rate specified in the constructor, checking if any consumers are ready to receive events, checking if any consumers are interested in this specific event, making a local copy of the event, and saving the event to be delivered to consumers.

Definition at line 128 of file EventServer.cc.

References consumerTable_, edmNew::copy(), edm::CPUTimer::cpuTime(), disconnectedConsumerTestCounter_, lat::endl(), EventMsgView::event(), FDEBUG, getConsumer(), stor::BaseCounter::getCurrentTime(), hltOutputModuleId_, insideTimer_, longTermInsideCPUTimeCounter_, longTermInsideRealTimeCounter_, longTermOutsideCPUTimeCounter_, longTermOutsideRealTimeCounter_, ltAcceptCounters_, ltInputCounters_, ltOutputCounters_, max, maxDataRate_, maxEventRate_, NULL, EventMsgView::outModId(), outsideTimer_, edm::CPUTimer::realTime(), edm::CPUTimer::reset(), runFairShareAlgo_, shortTermInsideCPUTimeCounter_, shortTermInsideRealTimeCounter_, shortTermOutsideCPUTimeCounter_, shortTermOutsideRealTimeCounter_, EventMsgView::size(), source, stAcceptCounters_, edm::CPUTimer::start(), EventMsgView::startAddress(), stInputCounters_, edm::CPUTimer::stop(), stOutputCounters_, and target.

{
  // do nothing if the event is empty
  if (eventView.size() == 0) {return;}

  boost::shared_ptr<ForeverCounter> ltCounter;
  boost::shared_ptr<RollingIntervalCounter> stCounter;
  std::map<uint32, boost::shared_ptr<ForeverCounter> >::iterator ltIter;
  std::map<uint32, boost::shared_ptr<RollingIntervalCounter> >::iterator stIter;

  // stop the timer that we use to measure CPU and real time outside the ES
  outsideTimer_.stop();

  // stop the timer that we use to measure CPU and real time inside the ES
  insideTimer_.start();

  // add the event to our statistics for events that are input to the ES
  double sizeInMB = static_cast<double>(eventView.size()) / 1048576.0;
  double now = BaseCounter::getCurrentTime();
  uint32 outputModuleId = eventView.outModId();
  // fetch (or create) the correct long term counter for the output module
  ltIter = ltInputCounters_.find(outputModuleId);
  if (ltIter == ltInputCounters_.end()) {
    ltCounter.reset(new ForeverCounter());
    ltInputCounters_[outputModuleId] = ltCounter;
  }
  else {
    ltCounter = ltIter->second;
  }
  // fetch (or create) the correct short term counter for the output module
  stIter = stInputCounters_.find(outputModuleId);
  if (stIter == stInputCounters_.end()) {
    stCounter.reset(new RollingIntervalCounter(180,5,20));
    stInputCounters_[outputModuleId] = stCounter;
  }
  else {
    stCounter = stIter->second;
  }
  ltCounter->addSample(sizeInMB);
  stCounter->addSample(sizeInMB, now);

  // the event must be from the correct HLT output module
  if (outputModuleId != hltOutputModuleId_) {
    // track timer statistics and start/stop timers as appropriate
    insideTimer_.stop();
    longTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime());
    shortTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime(), now);
    longTermInsideRealTimeCounter_->addSample(insideTimer_.realTime());
    shortTermInsideRealTimeCounter_->addSample(insideTimer_.realTime(), now);
    longTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime());
    shortTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime(), now);
    longTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime());
    shortTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime(), now);
    outsideTimer_.reset();
    insideTimer_.reset();
    outsideTimer_.start();
    return;
  }

  // if we're not running the fair-share algorithm, 
  // prescale events based on the input event and data rates
  if (! runFairShareAlgo_) {
    double eventRate = stCounter->getSampleRate(now);
    double dataRate = stCounter->getValueRate(now);
    double eventRatePrescale = eventRate / maxEventRate_;
    double dataRatePrescale = dataRate / maxDataRate_;
    double effectivePrescale = std::max(eventRatePrescale, dataRatePrescale);
    if (effectivePrescale > 1.0) {
      double instantRatio = 1.0 / effectivePrescale;
      double randValue = (*generator_)();
      if (randValue > instantRatio) {
        // track timer statistics and start/stop timers as appropriate
        insideTimer_.stop();
        longTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime());
        shortTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime(), now);
        longTermInsideRealTimeCounter_->addSample(insideTimer_.realTime());
        shortTermInsideRealTimeCounter_->addSample(insideTimer_.realTime(), now);
        longTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime());
        shortTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime(), now);
        longTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime());
        shortTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime(), now);
        outsideTimer_.reset();
        insideTimer_.reset();
        outsideTimer_.start();
        return;
      }
    }
  }

  // loop over the consumers in our list, and for each one check whether
  // it is ready for an event and if it wants this specific event.  If so,
  // create a local copy of the event (if not already done) and pass it
  // to the consumer pipe.

  // determine which consumers are interested in the event
  std::vector<uint32> candidateList;
  boost::shared_ptr< vector<char> > bufPtr;
  std::map< uint32, boost::shared_ptr<ConsumerPipe> >::const_iterator consIter;
  for (consIter = consumerTable_.begin();
       consIter != consumerTable_.end();
       consIter++)
  {
    // test if the consumer is ready and wants the event
    boost::shared_ptr<ConsumerPipe> consPipe = consIter->second;
    FDEBUG(5) << "Checking if consumer " << consPipe->getConsumerId() <<
      " wants event " << eventView.event() << std::endl;
    if (consPipe->wantsEvent(eventView) &&
        consPipe->isReadyForEvent(now))
    {
      candidateList.push_back(consPipe->getConsumerId());
      consPipe->wasConsidered(now);
    }
  }

  // do nothing if there are no candidates
  if (candidateList.size() == 0) {
    // track timer statistics and start/stop timers as appropriate
    insideTimer_.stop();
    longTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime());
    shortTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime(), now);
    longTermInsideRealTimeCounter_->addSample(insideTimer_.realTime());
    shortTermInsideRealTimeCounter_->addSample(insideTimer_.realTime(), now);
    longTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime());
    shortTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime(), now);
    longTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime());
    shortTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime(), now);
    outsideTimer_.reset();
    insideTimer_.reset();
    outsideTimer_.start();
    return;
  }

  // determine which of the candidate consumers are allowed
  // to receive another event at this time
  std::vector<uint32> allowedList;
  //if (runFairShareAlgo_) {
  //  allowedList = rateLimiter_->getAllowedConsumersFromList(sizeInMB,
  //                                                          candidateList);
  //}
  //else {
    allowedList = candidateList;
  //}

  // send the event to the allowed consumers
  for (uint32 idx = 0; idx < allowedList.size(); ++idx)
  {
    uint32 consumerId = allowedList[idx];

    // check if we need to make a local copy of the event
    if (bufPtr.get() == NULL)
    {
      FDEBUG(5) << "Creating a buffer for event " <<
        eventView.event() << std::endl;

      // create a local buffer of the appropriate size
      boost::shared_ptr< vector<char> >
        tmpBufPtr(new vector<char>(eventView.size()));

      // copy the data to the local buffer
      unsigned char *target = (unsigned char *) &(*tmpBufPtr)[0];
      unsigned char *source = eventView.startAddress();
      int dataSize = eventView.size();
      std::copy(source, source+dataSize, target);

      // switch buffers
      bufPtr.swap(tmpBufPtr);

      // add the event to our statistics for "unique accept" events
      ltIter = ltAcceptCounters_.find(outputModuleId);
      if (ltIter == ltAcceptCounters_.end()) {
        ltCounter.reset(new ForeverCounter());
        ltAcceptCounters_[outputModuleId] = ltCounter;
      }
      else {
        ltCounter = ltIter->second;
      }
      stIter = stAcceptCounters_.find(outputModuleId);
      if (stIter == stAcceptCounters_.end()) {
        stCounter.reset(new RollingIntervalCounter(180,5,20));
        stAcceptCounters_[outputModuleId] = stCounter;
      }
      else {
        stCounter = stIter->second;
      }
      ltCounter->addSample(sizeInMB);
      stCounter->addSample(sizeInMB, now);
    }

    // add the event to the consumer pipe
    boost::shared_ptr<ConsumerPipe> consPipe = getConsumer(consumerId);
    consPipe->putEvent(bufPtr);

    // add the event to our statistics for "output" events
    // Adding the stats once per consumer is (currently) believed
    // to give a more accurate picture of what is being sent out.
    // (Even though we only have one copy of the event internally,
    // it uses up bandwidth N times for N consumers.)
    ltIter = ltOutputCounters_.find(outputModuleId);
    if (ltIter == ltOutputCounters_.end()) {
      ltCounter.reset(new ForeverCounter());
      ltOutputCounters_[outputModuleId] = ltCounter;
    }
    else {
      ltCounter = ltIter->second;
    }
    stIter = stOutputCounters_.find(outputModuleId);
    if (stIter == stOutputCounters_.end()) {
      stCounter.reset(new RollingIntervalCounter(180,5,20));
      stOutputCounters_[outputModuleId] = stCounter;
    }
    else {
      stCounter = stIter->second;
    }
    ltCounter->addSample(sizeInMB);
    stCounter->addSample(sizeInMB, now);
  }

  // periodically check for disconnected consumers
  disconnectedConsumerTestCounter_++;
  if (disconnectedConsumerTestCounter_ >= 500)
  {
    // reset counter
    disconnectedConsumerTestCounter_ = 0;

    // determine which consumers have disconnected
    std::vector<uint32> disconnectList;
    std::map< uint32, boost::shared_ptr<ConsumerPipe> >::const_iterator consIter;
    for (consIter = consumerTable_.begin();
         consIter != consumerTable_.end();
         consIter++)
    {
      boost::shared_ptr<ConsumerPipe> consPipe = consIter->second;
      FDEBUG(5) << "Checking if consumer " << consPipe->getConsumerId() <<
        " has disconnected " << std::endl;
      if (consPipe->isDisconnected())
      {
        disconnectList.push_back(consIter->first);
      }
    }

    // remove disconnected consumers from the consumer table
    std::vector<uint32>::const_iterator listIter;
    for (listIter = disconnectList.begin();
         listIter != disconnectList.end();
         listIter++)
    {
      uint32 consumerId = *listIter;
      consumerTable_.erase(consumerId);

      // remove the consumer from the rateLimiter instance so that it is
      // no longer considered for a fair share of the allowed bandwidth
      //rateLimiter_->removeConsumer(consumerId);
    }
  }

  // track timer statistics and start/stop timers as appropriate
  now = BaseCounter::getCurrentTime();
  insideTimer_.stop();
  longTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime());
  shortTermInsideCPUTimeCounter_->addSample(insideTimer_.cpuTime(), now);
  longTermInsideRealTimeCounter_->addSample(insideTimer_.realTime());
  shortTermInsideRealTimeCounter_->addSample(insideTimer_.realTime(), now);
  longTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime());
  shortTermOutsideCPUTimeCounter_->addSample(outsideTimer_.cpuTime(), now);
  longTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime());
  shortTermOutsideRealTimeCounter_->addSample(outsideTimer_.realTime(), now);
  outsideTimer_.reset();
  insideTimer_.reset();
  outsideTimer_.start();
}

void EventServer::setStreamSelectionTable

(

std::map< std::string, Strings > const &

selTable

)

Definition at line 432 of file EventServer.cc.

References selTableStringSize_, python::StorageManager_cfg::streamLabel, and streamSelectionTable_.

{
  streamSelectionTable_ = selTable;
  selTableStringSize_ = 0;
  std::map<std::string, Strings>::const_iterator mapIter;
  for (mapIter = selTable.begin(); mapIter != selTable.end(); mapIter++)
  {
    std::string streamLabel = mapIter->first;
    selTableStringSize_ += streamLabel.size();
    Strings selectionList = mapIter->second;
    for (unsigned int idx = 0; idx < selectionList.size(); idx++)
    {
      std::string selection = selectionList[idx];
      selTableStringSize_ += selection.size();
    }
  }
}

Strings EventServer::updateTriggerSelectionForStreams

(

Strings const &

selectionList

)

Definition at line 450 of file EventServer.cc.

References python::StorageManager_cfg::streamLabel, and streamSelectionTable_.

{
  Strings modifiedList;
  for (unsigned int idx = 0; idx < selectionList.size(); idx++) {
    std::string selection = selectionList[idx];
    std::string lcSelection = boost::algorithm::to_lower_copy(selection);
    if (lcSelection.find("stream", 0) == 0) {
      std::string streamLabel = selection.substr(6);
      std::map<std::string, Strings>::const_iterator mapIter =
        streamSelectionTable_.find(streamLabel);
      if (mapIter != streamSelectionTable_.end()) {
        Strings streamSelectionList = mapIter->second;
        for (unsigned int jdx = 0; jdx < streamSelectionList.size(); jdx++) {
          modifiedList.push_back(streamSelectionList.at(jdx));
        }
      }
      else {
        modifiedList.push_back(selection);
      }
    }
    else {
      modifiedList.push_back(selection);
    }
  }
  return modifiedList;
}

---

Member Data Documentation

boost::mt19937 stor::EventServer::baseGenerator_ [private]

Definition at line 137 of file EventServer.h.

Referenced by EventServer().

std::map< uint32, boost::shared_ptr<ConsumerPipe> > stor::EventServer::consumerTable_ [private]

Definition at line 113 of file EventServer.h.

Referenced by addConsumer(), clearQueue(), getConsumer(), getConsumerTable(), getEvent(), and processEvent().

int stor::EventServer::disconnectedConsumerTestCounter_ [private]

Definition at line 110 of file EventServer.h.

Referenced by EventServer(), and processEvent().

boost::shared_ptr< boost::uniform_01<boost::mt19937> > stor::EventServer::generator_ [private]

Definition at line 138 of file EventServer.h.

Referenced by EventServer().

uint32 stor::EventServer::hltOutputModuleId_ [private]

Definition at line 103 of file EventServer.h.

Referenced by EventServer(), and processEvent().

std::string stor::EventServer::hltOutputSelection_ [private]

Definition at line 102 of file EventServer.h.

Referenced by EventServer(), and getHLTOutputSelection().

edm::CPUTimer stor::EventServer::insideTimer_ [private]

Definition at line 127 of file EventServer.h.

Referenced by EventServer(), and processEvent().

boost::shared_ptr<ForeverCounter> stor::EventServer::longTermInsideCPUTimeCounter_ [private]

Definition at line 128 of file EventServer.h.

Referenced by EventServer(), getInternalTime(), getTimeFraction(), getTotalTime(), and processEvent().

boost::shared_ptr<ForeverCounter> stor::EventServer::longTermInsideRealTimeCounter_ [private]

Definition at line 130 of file EventServer.h.

Referenced by EventServer(), getInternalTime(), getTimeFraction(), getTotalTime(), and processEvent().

boost::shared_ptr<ForeverCounter> stor::EventServer::longTermOutsideCPUTimeCounter_ [private]

Definition at line 132 of file EventServer.h.

Referenced by EventServer(), getTimeFraction(), getTotalTime(), and processEvent().

boost::shared_ptr<ForeverCounter> stor::EventServer::longTermOutsideRealTimeCounter_ [private]

Definition at line 134 of file EventServer.h.

Referenced by EventServer(), getTimeFraction(), getTotalTime(), and processEvent().

std::map<uint32, boost::shared_ptr<ForeverCounter> > stor::EventServer::ltAcceptCounters_ [private]

Definition at line 122 of file EventServer.h.

Referenced by EventServer(), getDataRate(), getDuration(), getEventCount(), getEventRate(), and processEvent().

std::map<uint32, boost::shared_ptr<ForeverCounter> > stor::EventServer::ltInputCounters_ [private]

Definition at line 120 of file EventServer.h.

Referenced by EventServer(), getDataRate(), getDuration(), getEventCount(), getEventRate(), and processEvent().

std::map<uint32, boost::shared_ptr<ForeverCounter> > stor::EventServer::ltOutputCounters_ [private]

Definition at line 124 of file EventServer.h.

Referenced by EventServer(), getDataRate(), getDuration(), getEventCount(), getEventRate(), and processEvent().

double stor::EventServer::maxDataRate_ [private]

Definition at line 101 of file EventServer.h.

Referenced by EventServer(), getMaxDataRate(), and processEvent().

double stor::EventServer::maxEventRate_ [private]

Definition at line 100 of file EventServer.h.

Referenced by EventServer(), getMaxEventRate(), and processEvent().

edm::CPUTimer stor::EventServer::outsideTimer_ [private]

Definition at line 126 of file EventServer.h.

Referenced by EventServer(), and processEvent().

boost::shared_ptr<RateLimiter> stor::EventServer::rateLimiter_ [private]

Definition at line 107 of file EventServer.h.

bool stor::EventServer::runFairShareAlgo_ [private]

Definition at line 104 of file EventServer.h.

Referenced by EventServer(), and processEvent().

int stor::EventServer::selTableStringSize_ [private]

Definition at line 117 of file EventServer.h.

Referenced by EventServer(), getSelectionTableStringSize(), and setStreamSelectionTable().

boost::shared_ptr<RollingIntervalCounter> stor::EventServer::shortTermInsideCPUTimeCounter_ [private]

Definition at line 129 of file EventServer.h.

Referenced by EventServer(), getInternalTime(), getTimeFraction(), getTotalTime(), and processEvent().

boost::shared_ptr<RollingIntervalCounter> stor::EventServer::shortTermInsideRealTimeCounter_ [private]

Definition at line 131 of file EventServer.h.

Referenced by EventServer(), getInternalTime(), getTimeFraction(), getTotalTime(), and processEvent().

boost::shared_ptr<RollingIntervalCounter> stor::EventServer::shortTermOutsideCPUTimeCounter_ [private]

Definition at line 133 of file EventServer.h.

Referenced by EventServer(), getTimeFraction(), getTotalTime(), and processEvent().

boost::shared_ptr<RollingIntervalCounter> stor::EventServer::shortTermOutsideRealTimeCounter_ [private]

Definition at line 135 of file EventServer.h.

Referenced by EventServer(), getTimeFraction(), getTotalTime(), and processEvent().

std::map<uint32, boost::shared_ptr<RollingIntervalCounter> > stor::EventServer::stAcceptCounters_ [private]

Definition at line 123 of file EventServer.h.

Referenced by EventServer(), getDataRate(), getDuration(), getEventCount(), getEventRate(), and processEvent().

std::map<uint32, boost::shared_ptr<RollingIntervalCounter> > stor::EventServer::stInputCounters_ [private]

Definition at line 121 of file EventServer.h.

Referenced by EventServer(), getDataRate(), getDuration(), getEventCount(), getEventRate(), and processEvent().

std::map<uint32, boost::shared_ptr<RollingIntervalCounter> > stor::EventServer::stOutputCounters_ [private]

Definition at line 125 of file EventServer.h.

Referenced by EventServer(), getDataRate(), getDuration(), getEventCount(), getEventRate(), and processEvent().

std::map<std::string, Strings> stor::EventServer::streamSelectionTable_ [private]

Definition at line 116 of file EventServer.h.

Referenced by getStreamSelectionTable(), setStreamSelectionTable(), and updateTriggerSelectionForStreams().

---

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

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

---