#include <FastMonitoringService.h>

Inheritance diagram for evf::FastMonitoringService:

Classes
struct	Encoding

Public Member Functions
void	accumulateFileSize (unsigned int lumi, unsigned long fileSize)

	FastMonitoringService (const edm::ParameterSet &, edm::ActivityRegistry &)

unsigned int	getEventsProcessedForLumi (unsigned int lumi)

std::string	getRunDirName () const

void	jobFailure ()

std::string	makeModuleLegenda ()

std::string	makePathLegenda ()

void	postBeginJob ()

void	postEndJob ()

void	postEvent (edm::StreamContext const &)

void	postGlobalBeginRun (edm::GlobalContext const &)

void	postGlobalEndLumi (edm::GlobalContext const &)

void	postModuleEvent (edm::StreamContext const &, edm::ModuleCallingContext const &)

void	postSourceEvent (edm::StreamID)

void	postStreamBeginLumi (edm::StreamContext const &)

void	postStreamEndLumi (edm::StreamContext const &)

void	preallocate (edm::service::SystemBounds const &)

void	preEvent (edm::StreamContext const &)

void	preGlobalBeginLumi (edm::GlobalContext const &)

void	preGlobalEndLumi (edm::GlobalContext const &)

void	preModuleBeginJob (edm::ModuleDescription const &)

void	preModuleEvent (edm::StreamContext const &, edm::ModuleCallingContext const &)

void	prePathEvent (edm::StreamContext const &, edm::PathContext const &)

void	preSourceEvent (edm::StreamID)

void	preStreamBeginLumi (edm::StreamContext const &)

void	preStreamEndLumi (edm::StreamContext const &)

void	reportEventsThisLumiInSource (unsigned int lumi, unsigned int events)

void	setMicroState (MicroStateService::Microstate)

void	setMicroState (edm::StreamID, MicroStateService::Microstate)

void	startedLookingForFile ()

void	stoppedLookingForFile (unsigned int lumi)

	~FastMonitoringService ()

Public Member Functions inherited from evf::MicroStateService
virtual std::string	getMicroState1 ()

virtual std::string const &	getMicroState2 ()

	MicroStateService (const edm::ParameterSet &, edm::ActivityRegistry &)

virtual	~MicroStateService ()

Static Public Attributes
static const std::string	macroStateNames [FastMonitoringThread::MCOUNT]

static const std::string	nopath_ = "NoPath"

Static Public Attributes inherited from evf::MicroStateService
static const edm::ModuleDescription	reservedMicroStateNames [mCOUNT]

Private Member Functions
void	doSnapshot (const unsigned int ls, const bool isGlobalEOL)

void	doStreamEOLSnapshot (const unsigned int ls, const unsigned int streamID)

void	dowork ()

Private Attributes
std::map< unsigned int, unsigned long >	accuSize_

std::map< unsigned int, double >	avgLeadTime_

std::vector< std::atomic< bool > * >	collectedPathList_

Encoding	encModule_

std::vector< Encoding >	encPath_

std::vector< unsigned int >	eventCountForPathInit_

std::string	fastMicrostateDefPath_

unsigned int	fastMonIntervals_

std::string	fastName_

std::string	fastPath_

timeval	fileLookStart_

timeval	fileLookStop_

std::map< unsigned int, unsigned int >	filesProcessedDuringLumi_

std::vector< unsigned long >	firstEventId_

FastMonitoringThread	fmt_

bool	isGlobalLumiTransition_

unsigned int	lastGlobalLumi_

std::queue< unsigned int >	lastGlobalLumisClosed_

std::vector< double >	leadTimes_

unsigned int	lumiFromSource_

std::map< unsigned int, timeval >	lumiStartTime_

FastMonitoringThread::Macrostate	macrostate_

std::vector< const void * >	microstate_

std::string	microstateDefPath_

std::vector< const void * >	ministate_

std::string	moduleLegendFile_

std::atomic< bool >	monInit_

unsigned int	nStreams_

unsigned int	nThreads_

std::string	pathLegendFile_

bool	pathLegendWritten_ = false

std::vector< bool >	pathNamesReady_

std::map< unsigned int, unsigned int >	processedEventsPerLumi_

boost::filesystem::path	runDirectory_

int	sleepTime_

std::string	slowName_

unsigned int	snapCounter_ = 0

std::map< unsigned int, unsigned int >	sourceEventsReport_

std::vector< std::atomic< bool > * >	streamCounterUpdating_

bool	threadIDAvailable_ = false

std::vector< const void * >	threadMicrostate_

std::atomic< unsigned long >	totalEventsProcessed_

boost::filesystem::path	workingDirectory_

Additional Inherited Members
Public Types inherited from evf::MicroStateService
enum	Microstate { mInvalid = 0, mFwkOvh, mIdle, mInput, mInputDone, mDqm, mEoL, mCOUNT }

Static Protected Attributes inherited from evf::MicroStateService
static const std::string	default_return_ ="NotImplemented"

Detailed Description

Definition at line 51 of file FastMonitoringService.h.

Constructor & Destructor Documentation

evf::FastMonitoringService::FastMonitoringService	(	const edm::ParameterSet &	iPS,
		edm::ActivityRegistry &	reg
	)

Definition at line 32 of file FastMonitoringService.cc.

                                                  : 
     MicroStateService(iPS,reg)
     ,encModule_(33)
     ,nStreams_(0)//until initialized
     ,sleepTime_(iPS.getUntrackedParameter<int>("sleepTime", 1))
     ,fastMonIntervals_(iPS.getUntrackedParameter<unsigned int>("fastMonIntervals", 1))
     ,microstateDefPath_(iPS.getUntrackedParameter<std::string> ("microstateDefPath", std::string(getenv("CMSSW_BASE"))+"/src/EventFilter/Utilities/plugins/microstatedef.jsd"))
     ,fastMicrostateDefPath_(iPS.getUntrackedParameter<std::string>("fastMicrostateDefPath", microstateDefPath_))
     ,fastName_(iPS.getUntrackedParameter<std::string>("fastName", "fastmoni"))
     ,slowName_(iPS.getUntrackedParameter<std::string>("slowName", "slowmoni"))
     ,totalEventsProcessed_(0)
   {
     reg.watchPreallocate(this, &FastMonitoringService::preallocate);//receiving information on number of threads
     reg.watchJobFailure(this,&FastMonitoringService::jobFailure);//global
 
     reg.watchPreModuleBeginJob(this,&FastMonitoringService::preModuleBeginJob);//global
     reg.watchPostBeginJob(this,&FastMonitoringService::postBeginJob);
     reg.watchPostEndJob(this,&FastMonitoringService::postEndJob);
 
     reg.watchPreGlobalBeginLumi(this,&FastMonitoringService::preGlobalBeginLumi);//global lumi
     reg.watchPreGlobalEndLumi(this,&FastMonitoringService::preGlobalEndLumi);
     reg.watchPostGlobalEndLumi(this,&FastMonitoringService::postGlobalEndLumi);
 
     reg.watchPreStreamBeginLumi(this,&FastMonitoringService::preStreamBeginLumi);//stream lumi
     reg.watchPostStreamBeginLumi(this,&FastMonitoringService::postStreamBeginLumi);
     reg.watchPreStreamEndLumi(this,&FastMonitoringService::preStreamEndLumi);
     reg.watchPostStreamEndLumi(this,&FastMonitoringService::postStreamEndLumi);
 
     reg.watchPrePathEvent(this,&FastMonitoringService::prePathEvent);
 
     reg.watchPreEvent(this,&FastMonitoringService::preEvent);//stream
     reg.watchPostEvent(this,&FastMonitoringService::postEvent);
 
     reg.watchPreSourceEvent(this,&FastMonitoringService::preSourceEvent);//source (with streamID of requestor)
     reg.watchPostSourceEvent(this,&FastMonitoringService::postSourceEvent);
   
     reg.watchPreModuleEvent(this,&FastMonitoringService::preModuleEvent);//should be stream
     reg.watchPostModuleEvent(this,&FastMonitoringService::postModuleEvent);//
 
   }

evf::FastMonitoringService::~FastMonitoringService ( )

Definition at line 75 of file FastMonitoringService.cc.

76 {

77 }

Member Function Documentation

void evf::FastMonitoringService::accumulateFileSize	(	unsigned int	lumi,
		unsigned long	fileSize
	)

Definition at line 496 of file FastMonitoringService.cc.

References accuSize_, filesProcessedDuringLumi_, fmt_, fff_deletion::lock(), fjr2json::lumi, and evf::FastMonitoringThread::monlock_.

Referenced by evf::EvFDaqDirector::bumpFile().

                                                                                           {
         std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
     if (accuSize_.find(lumi)==accuSize_.end()) accuSize_[lumi] = fileSize;
     else accuSize_[lumi] += fileSize;
 
     if (filesProcessedDuringLumi_.find(lumi)==filesProcessedDuringLumi_.end())
       filesProcessedDuringLumi_[lumi] = 1;
     else
       filesProcessedDuringLumi_[lumi]++;
   }

void evf::FastMonitoringService::doSnapshot	(	const unsigned int	ls,
		const bool	isGlobalEOL
	)

private

Definition at line 558 of file FastMonitoringService.cc.

Referenced by dowork(), and preGlobalEndLumi().

                                                                                       {
     // update macrostate
     fmt_.m_data.fastMacrostateJ_ = macrostate_;
 
     //update these unless in the midst of a global transition
     if (!isGlobalLumiTransition_) {
 
       auto itd = avgLeadTime_.find(ls);
       if (itd != avgLeadTime_.end()) 
     fmt_.m_data.fastAvgLeadTimeJ_ = itd->second;
       else fmt_.m_data.fastAvgLeadTimeJ_=0.;
 
       auto iti = filesProcessedDuringLumi_.find(ls);
       if (iti != filesProcessedDuringLumi_.end())
     fmt_.m_data.fastFilesProcessedJ_ = iti->second;
       else fmt_.m_data.fastFilesProcessedJ_=0;
     }
     else return;
 
     //capture latest mini/microstate of streams
     for (unsigned int i=0;i<nStreams_;i++) {
       fmt_.m_data.ministateEncoded_[i] = encPath_[i].encode(ministate_[i]);
       fmt_.m_data.microstateEncoded_[i] = encModule_.encode(microstate_[i]);
     }
     //for (unsigned int i=0;i<nThreads_;i++)
     //  fmt_.m_data.threadMicrostateEncoded_[i] = encModule_.encode(threadMicrostate_[i]);
     
     if (isGlobalEOL)
     {//only update global variables
       fmt_.jsonMonitor_->snapGlobal(ls);
     }
     else
       fmt_.jsonMonitor_->snap(ls);
   }

void evf::FastMonitoringService::doStreamEOLSnapshot	(	const unsigned int	ls,
		const unsigned int	streamID
	)

inlineprivate

Definition at line 156 of file FastMonitoringService.h.

References fmt_, and evf::FastMonitoringThread::jsonMonitor_.

Referenced by preStreamEndLumi().

                                                                                    {
     //pick up only event count here
     fmt_.jsonMonitor_->snapStreamAtomic(ls,streamID);
       }

void evf::FastMonitoringService::dowork ( )

inlineprivate

Definition at line 161 of file FastMonitoringService.h.

References doSnapshot(), encModule_, evf::FastMonitoringService::Encoding::encode(), encPath_, evf::FastMonitoringThread::MonitorData::fastMacrostateJ_, fastMonIntervals_, fastPath_, fmt_, evf::FastMonitoringThread::jsonMonitor_, lastGlobalLumi_, fff_deletion::lock(), evf::FastMonitoringThread::m_data, evf::FastMonitoringThread::m_stoprequest, microstate_, ministate_, monInit_, evf::FastMonitoringThread::monlock_, sleepTime_, snapCounter_, AlCaHLTBitMon_QueryRunRegistry::string, and jsoncollector::IntJ::value().

Referenced by preallocate().

                     { // the function to be called in the thread. Thread completes when function returns.
         monInit_.exchange(true,std::memory_order_acquire);
     while (!fmt_.m_stoprequest) {
       edm::LogInfo("FastMonitoringService") << "Current states: Ms=" << fmt_.m_data.fastMacrostateJ_.value()
                 << " ms=" << encPath_[0].encode(ministate_[0])
                 << " us=" << encModule_.encode(microstate_[0]) << std::endl;
 
       {
             std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
             doSnapshot(lastGlobalLumi_,false);
 
             if (fastMonIntervals_ && (snapCounter_%fastMonIntervals_)==0) {
               std::string CSV = fmt_.jsonMonitor_->getCSVString();
               //release mutex before writing out fast path file
               fmt_.monlock_.unlock();
               if (CSV.size())
                 fmt_.jsonMonitor_->outputCSV(fastPath_,CSV);
             }
 
             snapCounter_++;
             
           }
       ::sleep(sleepTime_);
     }
       }

unsigned int evf::FastMonitoringService::getEventsProcessedForLumi ( unsigned int lumi )

Definition at line 543 of file FastMonitoringService.cc.

References edm::hlt::Exception, fmt_, fff_deletion::lock(), fjr2json::lumi, evf::FastMonitoringThread::monlock_, proc, and processedEventsPerLumi_.

Referenced by DQMFileSaver::fillJson(), and DQMFileSaver::globalEndLuminosityBlock().

                                                                                  {
     std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
     auto it = processedEventsPerLumi_.find(lumi);
     if (it!=processedEventsPerLumi_.end()) {
       unsigned int proc = it->second;
       return proc;
     }
     else {
       throw cms::Exception("FastMonitoringService") << "output module wants already deleted (or never reported by SOURCE) lumisection event count for LUMI -: "<<lumi;
       return 0;
     }
   }

std::string evf::FastMonitoringService::getRunDirName ( ) const

inline

Definition at line 150 of file FastMonitoringService.h.

References runDirectory_.

150 { return runDirectory_.stem().string(); }

evf::FastMonitoringService::runDirectory_

boost::filesystem::path runDirectory_

Definition: FastMonitoringService.h:239

void evf::FastMonitoringService::jobFailure ( )

Definition at line 209 of file FastMonitoringService.cc.

References macrostate_, and evf::FastMonitoringThread::sError.

Referenced by FastMonitoringService().

   {
     macrostate_ = FastMonitoringThread::sError;
   }

std::string evf::FastMonitoringService::makeModuleLegenda ( )

Definition at line 91 of file FastMonitoringService.cc.

References evf::FastMonitoringService::Encoding::current_, evf::FastMonitoringService::Encoding::decode(), encModule_, and i.

Referenced by postBeginJob().

   {  
     std::ostringstream ost;
     for(int i = 0; i < encModule_.current_; i++)
       ost<<i<<"="<<((const edm::ModuleDescription *)(encModule_.decode(i)))->moduleLabel()<<" ";
     return ost.str();
   }

std::string evf::FastMonitoringService::makePathLegenda ( )

Definition at line 80 of file FastMonitoringService.cc.

References edm::decode(), encPath_, i, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by prePathEvent().

                                                   {
     //taken from first stream
     std::ostringstream ost;
     for(int i = 0;
     i < encPath_[0].current_;
     i++)
       ost<<i<<"="<<*((std::string *)(encPath_[0].decode(i)))<<" ";
     return ost.str();
   }

void evf::FastMonitoringService::postBeginJob ( )

Definition at line 229 of file FastMonitoringService.cc.

References encModule_, fmt_, fff_deletion::lock(), evf::FastMonitoringThread::m_data, macrostate_, makeModuleLegenda(), evf::FastMonitoringThread::MonitorData::microstateBins_, moduleLegendFile_, evf::FastMonitoringThread::monlock_, evf::FastMonitoringThread::sJobReady, AlCaHLTBitMon_QueryRunRegistry::string, and evf::FastMonitoringService::Encoding::vecsize().

Referenced by FastMonitoringService().

   {
     std::string && moduleLegStr = makeModuleLegenda();
     FileIO::writeStringToFile(moduleLegendFile_, moduleLegStr);
 
     macrostate_ = FastMonitoringThread::sJobReady;
 
     //update number of entries in module histogram
     std::lock_guard<std::mutex> lock(fmt_.monlock_);
     fmt_.m_data.microstateBins_ = encModule_.vecsize();
   }

void evf::FastMonitoringService::postEndJob ( )

Definition at line 241 of file FastMonitoringService.cc.

References fmt_, macrostate_, evf::FastMonitoringThread::sJobEnded, and evf::FastMonitoringThread::stop().

Referenced by FastMonitoringService().

   {
     macrostate_ = FastMonitoringThread::sJobEnded;
     fmt_.stop();
   }

void evf::FastMonitoringService::postEvent ( edm::StreamContext const & sc )

Definition at line 431 of file FastMonitoringService.cc.

References eventCountForPathInit_, evf::FastMonitoringThread::MonitorData::fastPathProcessedJ_, fmt_, evf::FastMonitoringThread::m_data, microstate_, evf::MicroStateService::mIdle, ministate_, nopath_, evf::FastMonitoringThread::MonitorData::processed_, evf::MicroStateService::reservedMicroStateNames, streamCounterUpdating_, edm::StreamContext::streamID(), and totalEventsProcessed_.

Referenced by FastMonitoringService().

   {
     microstate_[sc.streamID()] = &reservedMicroStateNames[mIdle];
 
     ministate_[sc.streamID()] = &nopath_;
 
     #if ATOMIC_LEVEL>=2
     //use atomic flag to make sure end of lumi sees this
     streamCounterUpdating_[sc.streamID()]->store(true,std::memory_order_release);
     fmt_.m_data.processed_[sc.streamID()]->fetch_add(1,std::memory_order_release);
     streamCounterUpdating_[sc.streamID()]->store(false,std::memory_order_release);
 
     #elif ATOMIC_LEVEL==1
     //writes are atomic, we assume writes propagate to memory before stream EOL snap
     fmt_.m_data.processed_[sc.streamID()]->fetch_add(1,std::memory_order_relaxed);
 
     #elif ATOMIC_LEVEL==0 //default
     (*(fmt_.m_data.processed_[sc.streamID()]))++;
     #endif
     eventCountForPathInit_[sc.streamID()]++;
 
     //fast path counter (events accumulated in a run)
     unsigned long res = totalEventsProcessed_.fetch_add(1,std::memory_order_relaxed);
     fmt_.m_data.fastPathProcessedJ_ = res+1; 
     //fmt_.m_data.fastPathProcessedJ_ = totalEventsProcessed_.load(std::memory_order_relaxed);
   }

void evf::FastMonitoringService::postGlobalBeginRun ( edm::GlobalContext const & gc )

Definition at line 247 of file FastMonitoringService.cc.

References macrostate_, and evf::FastMonitoringThread::sRunning.

   {
     macrostate_ = FastMonitoringThread::sRunning;
   }

void evf::FastMonitoringService::postGlobalEndLumi ( edm::GlobalContext const & gc )

Definition at line 348 of file FastMonitoringService.cc.

References lastGlobalLumisClosed_, edm::LuminosityBlockID::luminosityBlock(), and edm::GlobalContext::luminosityBlockID().

Referenced by FastMonitoringService().

   {
     //mark closed lumis (still keep map entries until next one)
     lastGlobalLumisClosed_.push(gc.luminosityBlockID().luminosityBlock());
   }

void evf::FastMonitoringService::postModuleEvent	(	edm::StreamContext const &	sc,
		edm::ModuleCallingContext const &	mcc
	)

Definition at line 473 of file FastMonitoringService.cc.

References evf::MicroStateService::mFwkOvh, microstate_, evf::MicroStateService::reservedMicroStateNames, edm::StreamContext::streamID(), and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     //microstate_[sc.streamID().value()] = (void*)(mcc.moduleDescription());
     microstate_[sc.streamID().value()] = &reservedMicroStateNames[mFwkOvh];
   }

void evf::FastMonitoringService::postSourceEvent ( edm::StreamID sid )

Definition at line 463 of file FastMonitoringService.cc.

References evf::MicroStateService::mFwkOvh, microstate_, evf::MicroStateService::reservedMicroStateNames, and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     microstate_[sid.value()] = &reservedMicroStateNames[mFwkOvh];
   }

void evf::FastMonitoringService::postStreamBeginLumi ( edm::StreamContext const & sc )

Definition at line 367 of file FastMonitoringService.cc.

References microstate_, evf::MicroStateService::mIdle, evf::MicroStateService::reservedMicroStateNames, edm::StreamContext::streamID(), and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     microstate_[sc.streamID().value()]=&reservedMicroStateNames[mIdle];
   }

void evf::FastMonitoringService::postStreamEndLumi ( edm::StreamContext const & sc )

Definition at line 388 of file FastMonitoringService.cc.

References evf::MicroStateService::mFwkOvh, microstate_, evf::MicroStateService::reservedMicroStateNames, edm::StreamContext::streamID(), and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     microstate_[sc.streamID().value()]=&reservedMicroStateNames[mFwkOvh];
   }

void evf::FastMonitoringService::preallocate ( edm::service::SystemBounds const & bounds )

Definition at line 100 of file FastMonitoringService.cc.

Referenced by FastMonitoringService().

   {
 
     // FIND RUN DIRECTORY
     // The run dir should be set via the configuration of EvFDaqDirector
     
     if (edm::Service<evf::EvFDaqDirector>().operator->()==nullptr)
     {
       throw cms::Exception("FastMonitoringService") << "EvFDaqDirector is not present";
     
     }
     boost::filesystem::path runDirectory(edm::Service<evf::EvFDaqDirector>()->baseRunDir());
     workingDirectory_ = runDirectory_ = runDirectory;
     workingDirectory_ /= "mon";
 
     if ( !boost::filesystem::is_directory(workingDirectory_)) {
         LogDebug("FastMonitoringService") << "<MON> DIR NOT FOUND! Trying to create -: " << workingDirectory_.string() ;
         boost::filesystem::create_directories(workingDirectory_);
         if ( !boost::filesystem::is_directory(workingDirectory_))
           edm::LogWarning("FastMonitoringService") << "Unable to create <MON> DIR -: " << workingDirectory_.string()
                                                    << ". No monitoring data will be written.";
     }
 
     std::ostringstream fastFileName;
 
     fastFileName << fastName_ << "_pid" << std::setfill('0') << std::setw(5) << getpid() << ".fast";
     boost::filesystem::path fast = workingDirectory_;
     fast /= fastFileName.str();
     fastPath_ = fast.string();
 
     std::ostringstream moduleLegFile;
     moduleLegFile << "microstatelegend_pid" << std::setfill('0') << std::setw(5) << getpid() << ".leg";
     moduleLegendFile_  = (workingDirectory_/moduleLegFile.str()).string();
 
     std::ostringstream pathLegFile;
     pathLegFile << "pathlegend_pid" << std::setfill('0') << std::setw(5) << getpid() << ".leg";
     pathLegendFile_  = (workingDirectory_/pathLegFile.str()).string();
 
     LogDebug("FastMonitoringService") << "Initializing FastMonitor with microstate def path -: "
                               << microstateDefPath_;
                               //<< encPath_.current_ + 1 << " " << encModule_.current_ + 1
 
     nStreams_=bounds.maxNumberOfStreams();
     nThreads_=bounds.maxNumberOfThreads();
 
     //this should already be >=1
     if (nStreams_==0) nStreams_=1;
     if (nThreads_==0) nThreads_=1;
 
     /*
      * initialize the fast monitor with:
      * vector of pointers to monitorable parameters
      * path to definition
      *
      */
 
     macrostate_=FastMonitoringThread::sInit;
 
     for(unsigned int i = 0; i < (mCOUNT); i++)
       encModule_.updateReserved((void*)(reservedMicroStateNames+i));
     encModule_.completeReservedWithDummies();
 
     for (unsigned int i=0;i<nStreams_;i++) {
        ministate_.push_back(&nopath_);
        microstate_.push_back(&reservedMicroStateNames[mInvalid]);
 
        //for synchronization
        streamCounterUpdating_.push_back(new std::atomic<bool>(0));
 
        //path (mini) state
        encPath_.emplace_back(0);
        encPath_[i].update((void*)&nopath_);
        eventCountForPathInit_.push_back(0);
        firstEventId_.push_back(0);
        collectedPathList_.push_back(new std::atomic<bool>(0));
 
     }
     //for (unsigned int i=0;i<nThreads_;i++)
     //  threadMicrostate_.push_back(&reservedMicroStateNames[mInvalid]);
 
     //initial size until we detect number of bins
     fmt_.m_data.macrostateBins_=FastMonitoringThread::MCOUNT;
     fmt_.m_data.ministateBins_=0;
     fmt_.m_data.microstateBins_ = 0; 
  
     lastGlobalLumi_=0; 
     isGlobalLumiTransition_=true;
     lumiFromSource_=0;
 
     //startup monitoring
     fmt_.resetFastMonitor(microstateDefPath_,fastMicrostateDefPath_);
     fmt_.jsonMonitor_->setNStreams(nStreams_);
     fmt_.m_data.registerVariables(fmt_.jsonMonitor_.get(), nStreams_, threadIDAvailable_ ? nThreads_:0);
     monInit_.store(false,std::memory_order_release);
     fmt_.start(&FastMonitoringService::dowork,this);
 
    //this definition needs: #include "tbb/compat/thread"
    //however this would results in TBB imeplementation replacing std::thread
    //(both supposedly call pthread_self())
    //number of threads created in process could be obtained from /proc,
    //assuming that all posix threads are true kernel threads capable of running in parallel
 
    //#if TBB_IMPLEMENT_CPP0X
    //threadIDAvailable_=true;
    //#endif
 
   }

void evf::FastMonitoringService::preEvent ( edm::StreamContext const & sc )

Definition at line 427 of file FastMonitoringService.cc.

Referenced by FastMonitoringService().

428 {

429 }

void evf::FastMonitoringService::preGlobalBeginLumi ( edm::GlobalContext const & gc )

Definition at line 252 of file FastMonitoringService.cc.

References accuSize_, avgLeadTime_, filesProcessedDuringLumi_, fmt_, isGlobalLumiTransition_, lastGlobalLumi_, lastGlobalLumisClosed_, fff_deletion::lock(), edm::LuminosityBlockID::luminosityBlock(), edm::GlobalContext::luminosityBlockID(), lumiStartTime_, evf::FastMonitoringThread::monlock_, and processedEventsPerLumi_.

Referenced by FastMonitoringService().

   {
 
       timeval lumiStartTime;
       gettimeofday(&lumiStartTime, 0);
       unsigned int newLumi = gc.luminosityBlockID().luminosityBlock();
 
           std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
       lumiStartTime_[newLumi]=lumiStartTime;
       while (!lastGlobalLumisClosed_.empty()) {
           //wipe out old map entries as they aren't needed and slow down access
           unsigned int oldLumi = lastGlobalLumisClosed_.back();
           lastGlobalLumisClosed_.pop();
           lumiStartTime_.erase(oldLumi);
           avgLeadTime_.erase(oldLumi);
           filesProcessedDuringLumi_.erase(oldLumi);
           accuSize_.erase(oldLumi);
           processedEventsPerLumi_.erase(oldLumi);
       }
       lastGlobalLumi_= newLumi;
       isGlobalLumiTransition_=false;
   }

void evf::FastMonitoringService::preGlobalEndLumi ( edm::GlobalContext const & gc )

Definition at line 276 of file FastMonitoringService.cc.

References accuSize_, doSnapshot(), edm::hlt::Exception, evf::FastMonitoringThread::MonitorData::fastThroughputJ_, fmt_, isGlobalLumiTransition_, evf::FastMonitoringThread::jsonMonitor_, fff_deletion::lock(), LogDebug, fjr2json::lumi, edm::LuminosityBlockID::luminosityBlock(), edm::GlobalContext::luminosityBlockID(), lumiStartTime_, evf::FastMonitoringThread::m_data, evf::FastMonitoringThread::monlock_, cmsHarvester::path, processedEventsPerLumi_, edm::shutdown_flag, slowName_, sourceEventsReport_, throughputFactor(), jsoncollector::IntJ::value(), jsoncollector::DoubleJ::value(), and workingDirectory_.

Referenced by FastMonitoringService().

   {
       unsigned int lumi = gc.luminosityBlockID().luminosityBlock();
           LogDebug("FastMonitoringService") << "Lumi ended. Writing JSON information. LUMI -: "
                                                 << lumi;
       timeval lumiStopTime;
       gettimeofday(&lumiStopTime, 0);
 
           std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
       // Compute throughput
       timeval stt = lumiStartTime_[lumi];
       unsigned long usecondsForLumi = (lumiStopTime.tv_sec - stt.tv_sec)*1000000
                           + (lumiStopTime.tv_usec - stt.tv_usec);
       unsigned long accuSize = accuSize_.find(lumi)==accuSize_.end() ? 0 : accuSize_[lumi];
       double throughput = throughputFactor()* double(accuSize) / double(usecondsForLumi);
       //store to registered variable
       fmt_.m_data.fastThroughputJ_.value() = throughput;
 
       //update
       doSnapshot(lumi,true);
 
       // create file name for slow monitoring file
       std::stringstream slowFileName;
       slowFileName << slowName_ << "_ls" << std::setfill('0') << std::setw(4)
             << lumi << "_pid" << std::setfill('0')
             << std::setw(5) << getpid() << ".jsn";
       boost::filesystem::path slow = workingDirectory_;
       slow /= slowFileName.str();
 
       //retrieve one result we need (todo: sanity check if it's found)
       IntJ *lumiProcessedJptr = dynamic_cast<IntJ*>(fmt_.jsonMonitor_->getMergedIntJForLumi("Processed",lumi));
           if (!lumiProcessedJptr)
               throw cms::Exception("FastMonitoringService") << "Internal error: got null pointer from FastMonitor";
       processedEventsPerLumi_[lumi] = lumiProcessedJptr->value();
 
       {
         auto itr = sourceEventsReport_.find(lumi);
         if (itr==sourceEventsReport_.end()) {
               //do not throw exception in case of signal termination
               if (edm::shutdown_flag) {
                 edm::LogInfo("FastMonitoringService") << "Run interrupted. Skip writing EoL information -: "
                                                       << processedEventsPerLumi_[lumi] << " events were processed in LUMI " << lumi;
                 //this will prevent output modules from producing json file for possibly incomplete lumi
                 processedEventsPerLumi_[lumi]=0;
                 return;
               }
               //disable this exception, so service can be used standalone (will be thrown if output module asks for this information)
               //throw cms::Exception("FastMonitoringService") << "SOURCE did not send update for lumi block. LUMI -:" << lumi;
         }
         else {
           if (itr->second!=processedEventsPerLumi_[lumi]) {
         throw cms::Exception("FastMonitoringService") << "MISMATCH with SOURCE update. LUMI -: "
                                                               << lumi
                                                               << ", events(processed):" << processedEventsPerLumi_[lumi]
                                                               << " events(source):" << itr->second;
           }
           sourceEventsReport_.erase(itr);
         }
       }
       edm::LogInfo("FastMonitoringService") << "Statistics for lumisection -: lumi = " << lumi << " events = "
                                     << lumiProcessedJptr->value() << " time = " << usecondsForLumi/1000000
                                     << " size = " << accuSize << " thr = " << throughput;
       delete lumiProcessedJptr;
 
       //full global and stream merge&output for this lumi
       fmt_.jsonMonitor_->outputFullJSON(slow.string(),lumi);//full global and stream merge and JSON write for this lumi
       fmt_.jsonMonitor_->discardCollected(lumi);//we don't do further updates for this lumi
 
       isGlobalLumiTransition_=true;
   }

void evf::FastMonitoringService::preModuleBeginJob ( edm::ModuleDescription const & desc )

Definition at line 215 of file FastMonitoringService.cc.

References encModule_, fmt_, fff_deletion::lock(), edm::ModuleDescription::moduleName(), evf::FastMonitoringThread::monlock_, evf::FastMonitoringService::Encoding::update(), and evf::FastMonitoringService::Encoding::updateReserved().

Referenced by FastMonitoringService().

   {
     std::lock_guard<std::mutex> lock(fmt_.monlock_);
     //std::cout << " Pre module Begin Job module: " << desc.moduleName() << std::endl;
 
     //build a map of modules keyed by their module description address
     //here we need to treat output modules in a special way so they can be easily singled out
     if(desc.moduleName() == "Stream" || desc.moduleName() == "ShmStreamConsumer" ||
        desc.moduleName() == "EventStreamFileWriter" || desc.moduleName() == "PoolOutputModule")
       encModule_.updateReserved((void*)&desc);
     else
       encModule_.update((void*)&desc);
   }

void evf::FastMonitoringService::preModuleEvent	(	edm::StreamContext const &	sc,
		edm::ModuleCallingContext const &	mcc
	)

Definition at line 468 of file FastMonitoringService.cc.

References microstate_, edm::ModuleCallingContext::moduleDescription(), edm::StreamContext::streamID(), and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     microstate_[sc.streamID().value()] = (void*)(mcc.moduleDescription());
   }

void evf::FastMonitoringService::prePathEvent	(	edm::StreamContext const &	sc,
		edm::PathContext const &	pc
	)

Definition at line 394 of file FastMonitoringService.cc.

References collectedPathList_, encPath_, edm::EventID::event(), eventCountForPathInit_, edm::StreamContext::eventID(), firstEventId_, fmt_, fff_deletion::lock(), evf::FastMonitoringThread::m_data, makePathLegenda(), ministate_, evf::FastMonitoringThread::MonitorData::ministateBins_, evf::FastMonitoringThread::monlock_, pathLegendFile_, pathLegendWritten_, edm::PathContext::pathName(), edm::StreamContext::streamID(), AlCaHLTBitMon_QueryRunRegistry::string, and unlikely.

Referenced by FastMonitoringService().

   {
     //make sure that all path names are retrieved before allowing ministate to change
     //hack: assume memory is synchronized after ~50 events seen by each stream
     if (unlikely(eventCountForPathInit_[sc.streamID()]<50) && false==collectedPathList_[sc.streamID()]->load(std::memory_order_acquire))
     {
       //protection between stream threads, as well as the service monitoring thread
       std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
       if (firstEventId_[sc.streamID()]==0) 
     firstEventId_[sc.streamID()]=sc.eventID().event();
       if (sc.eventID().event()==firstEventId_[sc.streamID()])
       {
     encPath_[sc.streamID()].update((void*)&pc.pathName());
     return;
       }
       else {
     //finished collecting path names
     collectedPathList_[sc.streamID()]->store(true,std::memory_order_seq_cst);
     fmt_.m_data.ministateBins_=encPath_[sc.streamID()].vecsize();
     if (!pathLegendWritten_) {
       std::string pathLegendStr =  makePathLegenda();
       FileIO::writeStringToFile(pathLegendFile_, pathLegendStr);
       pathLegendWritten_=true;
     }
       }
     }
     else {
       ministate_[sc.streamID()] = &(pc.pathName());
     }
   }

void evf::FastMonitoringService::preSourceEvent ( edm::StreamID sid )

Definition at line 458 of file FastMonitoringService.cc.

References microstate_, evf::MicroStateService::mInput, evf::MicroStateService::reservedMicroStateNames, and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     microstate_[sid.value()] = &reservedMicroStateNames[mInput];
   }

void evf::FastMonitoringService::preStreamBeginLumi ( edm::StreamContext const & sc )

Definition at line 354 of file FastMonitoringService.cc.

References edm::StreamContext::eventID(), fmt_, fff_deletion::lock(), edm::EventID::luminosityBlock(), evf::FastMonitoringThread::m_data, evf::MicroStateService::mFwkOvh, microstate_, ministate_, evf::FastMonitoringThread::monlock_, nopath_, evf::FastMonitoringThread::MonitorData::processed_, evf::MicroStateService::reservedMicroStateNames, edm::StreamContext::streamID(), evf::FastMonitoringThread::MonitorData::streamLumi_, and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     unsigned int sid = sc.streamID().value();
     std::lock_guard<std::mutex> lock(fmt_.monlock_);
     fmt_.m_data.streamLumi_[sid] = sc.eventID().luminosityBlock();
 
     //reset collected values for this stream
     *(fmt_.m_data.processed_[sid])=0;
 
     ministate_[sid]=&nopath_;
     microstate_[sid]=&reservedMicroStateNames[mFwkOvh];
   }

void evf::FastMonitoringService::preStreamEndLumi ( edm::StreamContext const & sc )

Definition at line 372 of file FastMonitoringService.cc.

References doStreamEOLSnapshot(), edm::StreamContext::eventID(), fmt_, svgfig::load(), fff_deletion::lock(), edm::EventID::luminosityBlock(), evf::MicroStateService::mEoL, microstate_, ministate_, evf::FastMonitoringThread::monlock_, nopath_, evf::MicroStateService::reservedMicroStateNames, streamCounterUpdating_, edm::StreamContext::streamID(), and edm::StreamID::value().

Referenced by FastMonitoringService().

   {
     unsigned int sid = sc.streamID().value();
     std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
     #if ATOMIC_LEVEL>=2
     //spinlock to make sure we are not still updating event counter somewhere
     while (streamCounterUpdating_[sid]->load(std::memory_order_acquire)) {}
     #endif
 
     //update processed count to be complete at this time
     doStreamEOLSnapshot(sc.eventID().luminosityBlock(),sid);
     //reset this in case stream does not get notified of next lumi (we keep processed events only)
     ministate_[sid]=&nopath_;
     microstate_[sid]=&reservedMicroStateNames[mEoL];
   }

void evf::FastMonitoringService::reportEventsThisLumiInSource	(	unsigned int	lumi,
		unsigned int	events
	)

Definition at line 593 of file FastMonitoringService.cc.

References fmt_, fff_deletion::lock(), evf::FastMonitoringThread::monlock_, and sourceEventsReport_.

Referenced by FedRawDataInputSource::checkNextEvent(), and FedRawDataInputSource::getNextEvent().

   {
 
     std::lock_guard<std::mutex> lock(fmt_.monlock_);
     auto itr = sourceEventsReport_.find(lumi);
     if (itr!=sourceEventsReport_.end())
       itr->second+=events;
     else 
       sourceEventsReport_[lumi]=events;
 
   }

void evf::FastMonitoringService::setMicroState ( MicroStateService::Microstate m )

virtual

Implements evf::MicroStateService.

Definition at line 483 of file FastMonitoringService.cc.

References i, microstate_, nStreams_, and evf::MicroStateService::reservedMicroStateNames.

   {
     for (unsigned int i=0;i<nStreams_;i++)
       microstate_[i] = &reservedMicroStateNames[m];
   }

void evf::FastMonitoringService::setMicroState	(	edm::StreamID	sid,
		MicroStateService::Microstate	m
	)

virtual

Implements evf::MicroStateService.

Definition at line 490 of file FastMonitoringService.cc.

References m, microstate_, and evf::MicroStateService::reservedMicroStateNames.

   {
     microstate_[sid] = &reservedMicroStateNames[m];
   }

void evf::FastMonitoringService::startedLookingForFile ( )

Definition at line 508 of file FastMonitoringService.cc.

References fileLookStart_.

Referenced by FedRawDataInputSource::readSupervisor().

                                                     {
       gettimeofday(&fileLookStart_, 0);
       /*
      std::cout << "Started looking for .raw file at: s=" << fileLookStart_.tv_sec << ": ms = "
      << fileLookStart_.tv_usec / 1000.0 << std::endl;
      */
   }

void evf::FastMonitoringService::stoppedLookingForFile ( unsigned int lumi )

Definition at line 516 of file FastMonitoringService.cc.

References avgLeadTime_, fileLookStart_, fileLookStop_, fmt_, i, leadTimes_, fff_deletion::lock(), fjr2json::lumi, lumiFromSource_, and evf::FastMonitoringThread::monlock_.

Referenced by FedRawDataInputSource::readSupervisor().

                                                                      {
       gettimeofday(&fileLookStop_, 0);
       /*
      std::cout << "Stopped looking for .raw file at: s=" << fileLookStop_.tv_sec << ": ms = "
      << fileLookStop_.tv_usec / 1000.0 << std::endl;
      */
           std::lock_guard<std::mutex> lock(fmt_.monlock_);
 
       if (lumi>lumiFromSource_) {
           lumiFromSource_=lumi;
           leadTimes_.clear();
       }
       unsigned long elapsedTime = (fileLookStop_.tv_sec - fileLookStart_.tv_sec) * 1000000 // sec to us
                                   + (fileLookStop_.tv_usec - fileLookStart_.tv_usec); // us
       // add this to lead times for this lumi
       leadTimes_.push_back((double)elapsedTime);
 
       // recompute average lead time for this lumi
       if (leadTimes_.size() == 1) avgLeadTime_[lumi] = leadTimes_[0];
       else {
           double totTime = 0;
           for (unsigned int i = 0; i < leadTimes_.size(); i++) totTime += leadTimes_[i];
           avgLeadTime_[lumi] = 0.001*(totTime / leadTimes_.size());
       }
   }

Member Data Documentation

std::map<unsigned int, unsigned long> evf::FastMonitoringService::accuSize_

private

Definition at line 224 of file FastMonitoringService.h.

Referenced by accumulateFileSize(), preGlobalBeginLumi(), and preGlobalEndLumi().

std::map<unsigned int, double> evf::FastMonitoringService::avgLeadTime_

private

Definition at line 221 of file FastMonitoringService.h.

Referenced by doSnapshot(), preGlobalBeginLumi(), and stoppedLookingForFile().

std::vector<std::atomic<bool>*> evf::FastMonitoringService::collectedPathList_

private

Definition at line 235 of file FastMonitoringService.h.

Referenced by preallocate(), and prePathEvent().

Encoding evf::FastMonitoringService::encModule_

private

Definition at line 190 of file FastMonitoringService.h.

Referenced by doSnapshot(), dowork(), makeModuleLegenda(), postBeginJob(), preallocate(), and preModuleBeginJob().

std::vector<Encoding> evf::FastMonitoringService::encPath_

private

Definition at line 191 of file FastMonitoringService.h.

Referenced by doSnapshot(), dowork(), makePathLegenda(), preallocate(), and prePathEvent().

std::vector<unsigned int> evf::FastMonitoringService::eventCountForPathInit_

private

Definition at line 236 of file FastMonitoringService.h.

Referenced by postEvent(), preallocate(), and prePathEvent().

std::string evf::FastMonitoringService::fastMicrostateDefPath_

private

Definition at line 198 of file FastMonitoringService.h.

Referenced by preallocate().

unsigned int evf::FastMonitoringService::fastMonIntervals_

private

Definition at line 196 of file FastMonitoringService.h.

Referenced by dowork().

std::string evf::FastMonitoringService::fastName_

private

Definition at line 199 of file FastMonitoringService.h.

Referenced by preallocate().

std::string evf::FastMonitoringService::fastPath_

private

Definition at line 199 of file FastMonitoringService.h.

Referenced by dowork(), and preallocate().

timeval evf::FastMonitoringService::fileLookStart_

private

Definition at line 204 of file FastMonitoringService.h.

Referenced by startedLookingForFile(), and stoppedLookingForFile().

timeval evf::FastMonitoringService::fileLookStop_

private

Definition at line 204 of file FastMonitoringService.h.

Referenced by stoppedLookingForFile().

std::map<unsigned int, unsigned int> evf::FastMonitoringService::filesProcessedDuringLumi_

private

Definition at line 222 of file FastMonitoringService.h.

Referenced by accumulateFileSize(), doSnapshot(), and preGlobalBeginLumi().

std::vector<unsigned long> evf::FastMonitoringService::firstEventId_

private

Definition at line 234 of file FastMonitoringService.h.

Referenced by preallocate(), and prePathEvent().

FastMonitoringThread evf::FastMonitoringService::fmt_

private

Definition at line 189 of file FastMonitoringService.h.

Referenced by accumulateFileSize(), doSnapshot(), doStreamEOLSnapshot(), dowork(), getEventsProcessedForLumi(), postBeginJob(), postEndJob(), postEvent(), preallocate(), preGlobalBeginLumi(), preGlobalEndLumi(), preModuleBeginJob(), prePathEvent(), preStreamBeginLumi(), preStreamEndLumi(), reportEventsThisLumiInSource(), and stoppedLookingForFile().

bool evf::FastMonitoringService::isGlobalLumiTransition_

private

Definition at line 208 of file FastMonitoringService.h.

Referenced by doSnapshot(), preallocate(), preGlobalBeginLumi(), and preGlobalEndLumi().

unsigned int evf::FastMonitoringService::lastGlobalLumi_

private

Definition at line 206 of file FastMonitoringService.h.

Referenced by dowork(), preallocate(), and preGlobalBeginLumi().

std::queue<unsigned int> evf::FastMonitoringService::lastGlobalLumisClosed_

private

Definition at line 207 of file FastMonitoringService.h.

Referenced by postGlobalEndLumi(), and preGlobalBeginLumi().

std::vector<double> evf::FastMonitoringService::leadTimes_

private

Definition at line 225 of file FastMonitoringService.h.

Referenced by stoppedLookingForFile().

unsigned int evf::FastMonitoringService::lumiFromSource_

private

Definition at line 209 of file FastMonitoringService.h.

Referenced by preallocate(), and stoppedLookingForFile().

std::map<unsigned int, timeval> evf::FastMonitoringService::lumiStartTime_

private

Definition at line 203 of file FastMonitoringService.h.

Referenced by preGlobalBeginLumi(), and preGlobalEndLumi().

FastMonitoringThread::Macrostate evf::FastMonitoringService::macrostate_

private

Definition at line 212 of file FastMonitoringService.h.

Referenced by doSnapshot(), jobFailure(), postBeginJob(), postEndJob(), postGlobalBeginRun(), and preallocate().

const std::string evf::FastMonitoringService::macroStateNames

static

Initial value:

= 
    {"Init","JobReady","RunGiven","Running",
     "Stopping","Done","JobEnded","Error","ErrorEnded","End",
     "Invalid"}

Definition at line 108 of file FastMonitoringService.h.

std::vector<const void*> evf::FastMonitoringService::microstate_

private

Definition at line 216 of file FastMonitoringService.h.

Referenced by doSnapshot(), dowork(), postEvent(), postModuleEvent(), postSourceEvent(), postStreamBeginLumi(), postStreamEndLumi(), preallocate(), preModuleEvent(), preSourceEvent(), preStreamBeginLumi(), preStreamEndLumi(), and setMicroState().

std::string evf::FastMonitoringService::microstateDefPath_

private

Definition at line 198 of file FastMonitoringService.h.

Referenced by preallocate().

std::vector<const void*> evf::FastMonitoringService::ministate_

private

Definition at line 215 of file FastMonitoringService.h.

Referenced by doSnapshot(), dowork(), postEvent(), preallocate(), prePathEvent(), preStreamBeginLumi(), and preStreamEndLumi().

std::string evf::FastMonitoringService::moduleLegendFile_

private

Definition at line 247 of file FastMonitoringService.h.

Referenced by postBeginJob(), and preallocate().

std::atomic<bool> evf::FastMonitoringService::monInit_

private

Definition at line 251 of file FastMonitoringService.h.

Referenced by dowork(), and preallocate().

const std::string evf::FastMonitoringService::nopath_ = "NoPath"

static

Definition at line 111 of file FastMonitoringService.h.

Referenced by postEvent(), preallocate(), preStreamBeginLumi(), and preStreamEndLumi().

unsigned int evf::FastMonitoringService::nStreams_

private

Definition at line 193 of file FastMonitoringService.h.

Referenced by doSnapshot(), preallocate(), and setMicroState().

unsigned int evf::FastMonitoringService::nThreads_

private

Definition at line 194 of file FastMonitoringService.h.

Referenced by preallocate().

std::string evf::FastMonitoringService::pathLegendFile_

private

Definition at line 248 of file FastMonitoringService.h.

Referenced by preallocate(), and prePathEvent().

bool evf::FastMonitoringService::pathLegendWritten_ = false

private

Definition at line 249 of file FastMonitoringService.h.

Referenced by prePathEvent().

std::vector<bool> evf::FastMonitoringService::pathNamesReady_

private

Definition at line 237 of file FastMonitoringService.h.

std::map<unsigned int, unsigned int> evf::FastMonitoringService::processedEventsPerLumi_

private

Definition at line 228 of file FastMonitoringService.h.

Referenced by getEventsProcessedForLumi(), preGlobalBeginLumi(), and preGlobalEndLumi().

boost::filesystem::path evf::FastMonitoringService::runDirectory_

private

Definition at line 239 of file FastMonitoringService.h.

Referenced by getRunDirName(), and preallocate().

int evf::FastMonitoringService::sleepTime_

private

Definition at line 195 of file FastMonitoringService.h.

Referenced by dowork().

std::string evf::FastMonitoringService::slowName_

private

Definition at line 199 of file FastMonitoringService.h.

Referenced by preGlobalEndLumi().

unsigned int evf::FastMonitoringService::snapCounter_ = 0

private

Definition at line 197 of file FastMonitoringService.h.

Referenced by dowork().

std::map<unsigned int,unsigned int> evf::FastMonitoringService::sourceEventsReport_

private

Definition at line 241 of file FastMonitoringService.h.

Referenced by preGlobalEndLumi(), and reportEventsThisLumiInSource().

std::vector<std::atomic<bool>*> evf::FastMonitoringService::streamCounterUpdating_

private

Definition at line 232 of file FastMonitoringService.h.

Referenced by postEvent(), preallocate(), and preStreamEndLumi().

bool evf::FastMonitoringService::threadIDAvailable_ = false

private

Definition at line 243 of file FastMonitoringService.h.

Referenced by preallocate().

std::vector<const void*> evf::FastMonitoringService::threadMicrostate_

private

Definition at line 217 of file FastMonitoringService.h.

std::atomic<unsigned long> evf::FastMonitoringService::totalEventsProcessed_

private

Definition at line 245 of file FastMonitoringService.h.

Referenced by postEvent().

boost::filesystem::path evf::FastMonitoringService::workingDirectory_

private

Definition at line 239 of file FastMonitoringService.h.

Referenced by preallocate(), and preGlobalEndLumi().

Classes

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation