---

edm::EventProcessor Class Reference

#include <FWCore/Framework/interface/EventProcessor.h>

Inheritance diagram for edm::EventProcessor:

List of all members.

Public Member Functions
virtual bool	alreadyHandlingException () const
void	beginJob ()
	This should be called before the first call to 'run' If this is not called in time, it will automatically be called the first time 'run' is called.
virtual void	beginLumi (int run, int lumi)
virtual void	beginRun (int run)
void	clearCounters ()
	Clears counters used by trigger report.
virtual void	closeInputFile ()
virtual void	closeOutputFiles ()
char const *	currentStateName () const
	Member functions to support asynchronous interface.
void	declareRunNumber (RunNumber_t runNumber)
virtual void	deleteLumiFromCache (int run, int lumi)
virtual void	deleteRunFromCache (int run)
virtual void	doErrorStuff ()
void	enableEndPaths (bool active)
	Turn end_paths "off" if "active" is false; turn end_paths "on" if "active" is true.
void	endJob ()
	This should be called before the EventProcessor is destroyed throws if any module's endJob throws an exception.
virtual void	endLumi (int run, int lumi)
virtual bool	endOfLoop ()
bool	endPathsEnabled () const
	Return true if end_paths are active, and false if they are inactive.
virtual void	endRun (int run)
	EventProcessor (std::string const &config, bool isPython)
	meant for unit tests
	EventProcessor (boost::shared_ptr< edm::ProcessDesc > &processDesc, ServiceToken const &token, serviceregistry::ServiceLegacy legacy)
	EventProcessor (std::string const &config, std::vector< std::string > const &defaultServices, std::vector< std::string > const &forcedServices=std::vector< std::string >())
	EventProcessor (std::string const &config, ServiceToken const &token=ServiceToken(), serviceregistry::ServiceLegacy=serviceregistry::kOverlapIsError, std::vector< std::string > const &defaultServices=std::vector< std::string >(), std::vector< std::string > const &forcedServices=std::vector< std::string >())
std::vector< ModuleDescription const * >	getAllModuleDescriptions () const
	Return a vector allowing const access to all the ModuleDescriptions for this EventProccessor.
event_processor::State	getState () const
ServiceToken	getToken ()
void	getTriggerReport (TriggerReport &rep) const
	Return the trigger report information on paths, modules-in-path, modules-in-endpath, and modules.
char const *	msgName (event_processor::Msg m) const
virtual void	openOutputFiles ()
ActivityRegistry::PostProcessEvent &	postProcessEventSignal ()
	signal is emitted after all modules have finished processing the Event
virtual void	prepareForNextLoop ()
ActivityRegistry::PreProcessEvent &	preProcessEventSignal ()
	signal is emitted after the Event has been created by the InputSource but before any modules have seen the Event
virtual void	processEvent ()
virtual int	readAndCacheLumi ()
virtual int	readAndCacheRun ()
virtual void	readEvent ()
virtual void	readFile ()
virtual void	respondToCloseInputFile ()
virtual void	respondToCloseOutputFiles ()
virtual void	respondToOpenInputFile ()
virtual void	respondToOpenOutputFiles ()
void	rewind ()
virtual void	rewindInput ()
StatusCode	run (EventID const &id)
StatusCode	run ()
StatusCode	run (int numberEventsToProcess, bool repeatable=true)
void	runAsync ()
virtual StatusCode	runEventCount (int numberOfEventsToProcess)
virtual StatusCode	runToCompletion (bool onlineStateTransitions)
virtual void	setExceptionMessageFiles (std::string &message)
virtual void	setExceptionMessageLumis (std::string &message)
virtual void	setExceptionMessageRuns (std::string &message)
void	setRunNumber (RunNumber_t runNumber)
virtual bool	shouldWeCloseOutput () const
virtual bool	shouldWeStop () const
StatusCode	shutdownAsync (unsigned int timeout_secs=60 *2)
StatusCode	skip (int numberToSkip)
virtual void	startingNewLoop ()
char const *	stateName (event_processor::State s) const
StatusCode	statusAsync () const
StatusCode	stopAsync (unsigned int timeout_secs=60 *2)
int	totalEvents () const
	Return the number of events this EventProcessor has tried to process (inclues both successes and failures, including failures due to exceptions during processing).
int	totalEventsFailed () const
	Return the number of events that have not passed any trigger.
int	totalEventsPassed () const
	Return the number of events processed by this EventProcessor which have been passed by one or more trigger paths.
StatusCode	waitTillDoneAsync (unsigned int timeout_seconds=0)
virtual void	writeLumi (int run, int lumi)
virtual void	writeLumiCache ()
virtual void	writeRun (int run)
virtual void	writeRunCache ()
	~EventProcessor ()
Private Member Functions
void	changeState (event_processor::Msg)
void	connectSigs (EventProcessor *ep)
StatusCode	doneAsync (event_processor::Msg m)
std::auto_ptr< EventPrincipal >	doOneEvent (EventID const &id)
void	errorState ()
void	init (boost::shared_ptr< edm::ProcessDesc > &processDesc, ServiceToken const &token, serviceregistry::ServiceLegacy)
void	procOneEvent (EventPrincipal *pep)
StatusCode	runCommon (bool onlineStateTransitions, int numberOfEventsToProcess)
void	setupSignal ()
void	terminateMachine ()
StatusCode	waitForAsyncCompletion (unsigned int timeout_seconds)
Static Private Member Functions
static void	asyncRun (EventProcessor *)
Private Attributes
ActionTable	act_table_
boost::shared_ptr < ActivityRegistry >	actReg_
bool	alreadyHandlingException_
std::auto_ptr < eventsetup::EventSetupProvider >	esp_
boost::shared_ptr< boost::thread >	event_loop_
volatile pthread_t	event_loop_id_
std::string	exceptionMessageFiles_
std::string	exceptionMessageLumis_
std::string	exceptionMessageRuns_
boost::shared_ptr< FileBlock >	fb_
std::string	fileMode_
bool	forceLooperToEnd_
bool	handleEmptyLumis_
bool	handleEmptyRuns_
volatile bool	id_set_
boost::shared_ptr< InputSource >	input_
std::string	last_error_text_
volatile Status	last_rc_
boost::shared_ptr< EDLooper >	looper_
std::auto_ptr < statemachine::Machine >	machine_
ParameterSet	maxEventsPset_
ParameterSet	maxLumisPset_
int	my_sig_num_
ActivityRegistry::PostProcessEvent	postProcessEventSignal_
SignallingProductRegistry	preg_
ActivityRegistry::PreProcessEvent	preProcessEventSignal_
PrincipalCache	principalCache_
std::auto_ptr< Schedule >	schedule_
ServiceToken	serviceToken_
bool	shouldWeStop_
std::auto_ptr< EventPrincipal >	sm_evp_
boost::condition	starter_
volatile event_processor::State	state_
boost::mutex	state_lock_
bool	stateMachineWasInErrorState_
volatile int	stop_count_
boost::mutex	stop_lock_
boost::condition	stopper_
WorkerRegistry	wreg_
Friends
class	event_processor::StateSentry
Classes
struct	CommonParams

---

Detailed Description

Definition at line 65 of file EventProcessor.h.

---

Constructor & Destructor Documentation

edm::EventProcessor::EventProcessor	(	std::string const &	config,
		ServiceToken const &	token = ServiceToken(),
		serviceregistry::ServiceLegacy	iLegacy = serviceregistry::kOverlapIsError,
		std::vector< std::string > const &	defaultServices = std::vector<std::string>(),
		std::vector< std::string > const &	forcedServices = std::vector<std::string>()
	)			[explicit]

Definition at line 411 of file EventProcessor.cc.

References init().

                                                                            :
    preProcessEventSignal_(),
    postProcessEventSignal_(),
    maxEventsPset_(),
    maxLumisPset_(),
    actReg_(new ActivityRegistry),
    wreg_(actReg_),
    preg_(),
    serviceToken_(),
    input_(),
    schedule_(),
    esp_(),
    act_table_(),
    state_(sInit),
    event_loop_(),
    state_lock_(),
    stop_lock_(),
    stopper_(),
    stop_count_(-1),
    last_rc_(epSuccess),
    last_error_text_(),
    id_set_(false),
    event_loop_id_(),
    my_sig_num_(getSigNum()),
    fb_(),
    looper_(),
    shouldWeStop_(false),
    alreadyHandlingException_(false),
    forceLooperToEnd_(false)
  {
    boost::shared_ptr<edm::ProcessDesc> processDesc(new edm::ProcessDesc(config));
    processDesc->addServices(defaultServices, forcedServices);
    init(processDesc, iToken, iLegacy);
  }

edm::EventProcessor::EventProcessor	(	std::string const &	config,
		std::vector< std::string > const &	defaultServices,
		std::vector< std::string > const &	forcedServices = std::vector<std::string>()
	)

Definition at line 450 of file EventProcessor.cc.

References init(), and edm::serviceregistry::kOverlapIsError.

                                                                            :
    preProcessEventSignal_(),
    postProcessEventSignal_(),
    maxEventsPset_(),
    maxLumisPset_(),
    actReg_(new ActivityRegistry),
    wreg_(actReg_),
    preg_(),
    serviceToken_(),
    input_(),
    schedule_(),
    esp_(),
    act_table_(),
    state_(sInit),
    event_loop_(),
    state_lock_(),
    stop_lock_(),
    stopper_(),
    stop_count_(-1),
    last_rc_(epSuccess),
    last_error_text_(),
    id_set_(false),
    event_loop_id_(),
    my_sig_num_(getSigNum()),
    fb_(),
    looper_(),
    shouldWeStop_(false),
    alreadyHandlingException_(false),
    forceLooperToEnd_(false)
  {
    boost::shared_ptr<edm::ProcessDesc> processDesc(new edm::ProcessDesc(config));
    processDesc->addServices(defaultServices, forcedServices);
    init(processDesc, ServiceToken(), serviceregistry::kOverlapIsError);
  }

edm::EventProcessor::EventProcessor	(	boost::shared_ptr< edm::ProcessDesc > &	processDesc,
		ServiceToken const &	token,
		serviceregistry::ServiceLegacy	legacy
	)

Definition at line 487 of file EventProcessor.cc.

References init().

                                                      :
    preProcessEventSignal_(),
    postProcessEventSignal_(),
    maxEventsPset_(),
    maxLumisPset_(),
    actReg_(new ActivityRegistry),
    wreg_(actReg_),
    preg_(),
    serviceToken_(),
    input_(),
    schedule_(),
    esp_(),
    act_table_(),
    state_(sInit),
    event_loop_(),
    state_lock_(),
    stop_lock_(),
    stopper_(),
    stop_count_(-1),
    last_rc_(epSuccess),
    last_error_text_(),
    id_set_(false),
    event_loop_id_(),
    my_sig_num_(getSigNum()),
    fb_(),
    looper_(),
    shouldWeStop_(false),
    alreadyHandlingException_(false),
    forceLooperToEnd_(false)
  {
    init(processDesc, token, legacy);
  }

edm::EventProcessor::EventProcessor	(	std::string const &	config,
		bool	isPython
	)

meant for unit tests

Definition at line 523 of file EventProcessor.cc.

References init(), and edm::serviceregistry::kOverlapIsError.

                                                                      :
    preProcessEventSignal_(),
    postProcessEventSignal_(),
    maxEventsPset_(),
    maxLumisPset_(),
    actReg_(new ActivityRegistry),
    wreg_(actReg_),
    preg_(),
    serviceToken_(),
    input_(),
    schedule_(),
    esp_(),
    act_table_(),
    state_(sInit),
    event_loop_(),
    state_lock_(),
    stop_lock_(),
    stopper_(),
    stop_count_(-1),
    last_rc_(epSuccess),
    last_error_text_(),
    id_set_(false),
    event_loop_id_(),
    my_sig_num_(getSigNum()),
    fb_(),
    looper_(),
    shouldWeStop_(false),
    alreadyHandlingException_(false),
    forceLooperToEnd_(false)
  {
    if(isPython)
    {
      boost::shared_ptr<edm::ProcessDesc> processDesc = PythonProcessDesc(config).processDesc();
      init(processDesc, ServiceToken(), serviceregistry::kOverlapIsError);
    }
    else
    {
      boost::shared_ptr<edm::ProcessDesc> processDesc(new edm::ProcessDesc(config));
      init(processDesc, ServiceToken(), serviceregistry::kOverlapIsError);
    }
  }

edm::EventProcessor::~EventProcessor

(

)

Definition at line 646 of file EventProcessor.cc.

References actReg_, changeState(), edm::WorkerRegistry::clear(), e, esp_, cms::Exception::explainSelf(), getToken(), input_, looper_, edm::event_processor::mDtor, schedule_, terminateMachine(), and wreg_.

  {
    // Make the services available while everything is being deleted.
    ServiceToken token = getToken();
    ServiceRegistry::Operate op(token); 

    // The state machine should have already been cleaned up
    // and destroyed at this point by a call to EndJob or
    // earlier when it completed processing events, but if it
    // has not been we'll take care of it here at the last moment.
    // This could cause problems if we are already handling an
    // exception and another one is thrown here ...  For a critical
    // executable the solution to this problem is for the code using
    // the EventProcessor to explicitly call EndJob or use runToCompletion,
    // then the next line of code is never executed.
    terminateMachine();

    try {
      changeState(mDtor);
    }
    catch(cms::Exception& e)
      {
        LogError("System")
          << e.explainSelf() << "\n";
      }

    // manually destroy all these thing that may need the services around
    esp_.reset();
    schedule_.reset();
    input_.reset();
    looper_.reset();
    wreg_.clear();
    actReg_.reset();
  }

---

Member Function Documentation

bool edm::EventProcessor::alreadyHandlingException

(

)

const [virtual]

Implements edm::IEventProcessor.

Definition at line 1643 of file EventProcessor.cc.

References alreadyHandlingException_.

                                                      {
    return alreadyHandlingException_;
  }

void edm::EventProcessor::asyncRun

(

EventProcessor *

me

)

[static, private]

Definition at line 1112 of file EventProcessor.cc.

References e, edm::IEventProcessor::epException, edm::IEventProcessor::epOther, event_loop_id_, exception, cms::Exception::explainSelf(), FDEBUG, id_set_, last_error_text_, last_rc_, runToCompletion(), sl, starter_, stop_count_, stop_lock_, and stopper_.

Referenced by runAsync().

  {
    // set up signals to allow for interruptions
    // ignore all other signals
    // make sure no exceptions escape out

    // temporary hack until we modify the input source to allow
    // wakeup calls from other threads.  This mimics the solution
    // in EventFilter/Processor, which I do not like.
    // allowing cancels means that the thread just disappears at
    // certain points.  This is bad for C++ stack variables.
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,0);
    //pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,0);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,0);
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,0);

    {
      boost::mutex::scoped_lock(me->stop_lock_);
      me->event_loop_id_ = pthread_self();
      me->id_set_ = true;
      me->starter_.notify_all();
    }

    Status rc = epException;
    FDEBUG(2) << "asyncRun starting ......................\n";

    try {
      bool onlineStateTransitions = true;
      rc = me->runToCompletion(onlineStateTransitions);
    }
    catch (cms::Exception& e) {
      edm::LogError("FwkJob") << "cms::Exception caught in "
                              << "EventProcessor::asyncRun" 
                              << "\n"
                              << e.explainSelf();
      me->last_error_text_ = e.explainSelf();
    }
    catch (std::exception& e) {
      edm::LogError("FwkJob") << "Standard library exception caught in " 
                              << "EventProcessor::asyncRun" 
                              << "\n"
                              << e.what();
      me->last_error_text_ = e.what();
    }
    catch (...) {
      edm::LogError("FwkJob") << "Unknown exception caught in "
                              << "EventProcessor::asyncRun" 
                              << "\n";
      me->last_error_text_ = "Unknown exception caught";
      rc = epOther;
    }

    me->last_rc_ = rc;

    {
      // notify anyone waiting for exit that we are doing so now
      boost::mutex::scoped_lock sl(me->stop_lock_);
      ++me->stop_count_;
      me->stopper_.notify_all();
    }
    FDEBUG(2) << "asyncRun ending ......................\n";
  }

void edm::EventProcessor::beginJob

(

void

)

This should be called before the first call to 'run' If this is not called in time, it will automatically be called the first time 'run' is called.

Definition at line 772 of file EventProcessor.cc.

References actReg_, bk::beginJob(), edm::IOVSyncValue::beginOfTime(), changeState(), e, esp_, exception, input_, looper_, edm::event_processor::mBeginJob, schedule_, serviceToken_, edm::event_processor::sInit, and state_.

Referenced by evf::FUEventProcessor::configuring(), declareRunNumber(), stor::EPRunner::dowork(), evf::FUEventProcessor::monitoring(), rewind(), run(), runAsync(), runCommon(), setRunNumber(), and skip().

  {
    if(state_ != sInit) return;
    bk::beginJob();
    // can only be run if in the initial state
    changeState(mBeginJob);

    // StateSentry toerror(this); // should we add this ? 
    //make the services available
    ServiceRegistry::Operate operate(serviceToken_);
    
    //NOTE:  This implementation assumes 'Job' means one call 
    // the EventProcessor::run
    // If it really means once per 'application' then this code will
    // have to be changed.
    // Also have to deal with case where have 'run' then new Module 
    // added and do 'run'
    // again.  In that case the newly added Module needs its 'beginJob'
    // to be called.
    EventSetup const& es =
      esp_->eventSetupForInstance(IOVSyncValue::beginOfTime());
    if(looper_) {
       looper_->beginOfJob(es);
    }
    try {
      input_->doBeginJob(es);
    } catch(cms::Exception& e) {
      LogError("BeginJob") << "A cms::Exception happened while processing the beginJob of the 'source'\n";
      e << "A cms::Exception happened while processing the beginJob of the 'source'\n";
      throw;
    } catch(std::exception& e) {
      LogError("BeginJob") << "A std::exception happened while processing the beginJob of the 'source'\n";
      throw;
    } catch(...) {
      LogError("BeginJob") << "An unknown exception happened while processing the beginJob of the 'source'\n";
      throw;
    }
    schedule_->beginJob(es);
    actReg_->postBeginJobSignal_();
    // toerror.succeeded(); // should we add this?
  }

void edm::EventProcessor::beginLumi	(	int	run,
		int	lumi
	)			[virtual]

Implements edm::IEventProcessor.

Definition at line 1552 of file EventProcessor.cc.

References edm::LuminosityBlockPrincipal::beginTime(), esp_, FDEBUG, edm::LuminosityBlockPrincipal::luminosityBlock(), edm::PrincipalCache::lumiPrincipal(), principalCache_, edm::LuminosityBlockPrincipal::run(), and schedule_.

                                                  {
    LuminosityBlockPrincipal& lumiPrincipal = principalCache_.lumiPrincipal(run, lumi);
    // NOTE: Using 0 as the event number for the begin of a lumi block is a bad idea
    // lumi blocks know their start and end times why not also start and end events?
    IOVSyncValue ts(EventID(lumiPrincipal.run(),0), lumiPrincipal.luminosityBlock(), lumiPrincipal.beginTime());
    EventSetup const& es = esp_->eventSetupForInstance(ts);
    schedule_->processOneOccurrence<OccurrenceTraits<LuminosityBlockPrincipal, BranchActionBegin> >(lumiPrincipal, es);
    FDEBUG(1) << "\tbeginLumi " << run << "/" << lumi << "\n";
  }

void edm::EventProcessor::beginRun

(

int

run

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1531 of file EventProcessor.cc.

References edm::RunPrincipal::beginTime(), esp_, FDEBUG, principalCache_, edm::RunPrincipal::run(), edm::PrincipalCache::runPrincipal(), and schedule_.

                                       {
    RunPrincipal& runPrincipal = principalCache_.runPrincipal(run);
    IOVSyncValue ts(EventID(runPrincipal.run(),0),
                    0,
                    runPrincipal.beginTime());
    EventSetup const& es = esp_->eventSetupForInstance(ts);
    schedule_->processOneOccurrence<OccurrenceTraits<RunPrincipal, BranchActionBegin> >(runPrincipal, es);
    FDEBUG(1) << "\tbeginRun " << run << "\n";
  }

void edm::EventProcessor::changeState

(

event_processor::Msg

msg

)

[private]

Definition at line 1053 of file EventProcessor.cc.

References edm::TransEntry::current, Exception, FDEBUG, edm::TransEntry::final, edm::event_processor::mAny, edm::TransEntry::message, msgName(), edm::event_processor::sInvalid, sl, state_, state_lock_, stateName(), and edm::table.

Referenced by beginJob(), declareRunNumber(), doneAsync(), endJob(), rewind(), run(), runAsync(), runCommon(), setRunNumber(), shutdownAsync(), skip(), stopAsync(), waitTillDoneAsync(), ~EventProcessor(), and edm::event_processor::StateSentry::~StateSentry().

  {
    // most likely need to serialize access to this routine

    boost::mutex::scoped_lock sl(state_lock_);
    State curr = state_;
    int rc;
    // found if(not end of table) and 
    // (state == table.state && (msg == table.message || msg == any))
    for(rc = 0;
        table[rc].current != sInvalid && 
          (curr != table[rc].current || 
           (curr == table[rc].current && 
             msg != table[rc].message && table[rc].message != mAny));
        ++rc);

    if(table[rc].current == sInvalid)
      throw cms::Exception("BadState")
        << "A member function of EventProcessor has been called in an"
        << " inappropriate order.\n"
        << "Bad transition from " << stateName(curr) << " "
        << "using message " << msgName(msg) << "\n"
        << "No where to go from here.\n";

    FDEBUG(1) << "changeState: current=" << stateName(curr)
              << ", message=" << msgName(msg) 
              << " -> new=" << stateName(table[rc].final) << "\n";

    state_ = table[rc].final;
  }

void edm::EventProcessor::clearCounters

(

)

Clears counters used by trigger report.

Definition at line 897 of file EventProcessor.cc.

References schedule_.

Referenced by evf::FUEventProcessor::enabling().

  {
    schedule_->clearCounters();
  }

void edm::EventProcessor::closeInputFile

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1435 of file EventProcessor.cc.

References FDEBUG, and input_.

                                      {
    input_->closeFile();
    FDEBUG(1) << "\tcloseInputFile\n";
  }

void edm::EventProcessor::closeOutputFiles

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1445 of file EventProcessor.cc.

References FDEBUG, and schedule_.

                                        {
    schedule_->closeOutputFiles();
    FDEBUG(1) << "\tcloseOutputFiles\n";
  }

void edm::EventProcessor::connectSigs

(

EventProcessor *

ep

)

[private]

Definition at line 845 of file EventProcessor.cc.

References actReg_, postProcessEventSignal_, and preProcessEventSignal_.

Referenced by init().

  {
    // When the FwkImpl signals are given, pass them to the
    // appropriate EventProcessor signals so that the outside world
    // can see the signal.
    actReg_->preProcessEventSignal_.connect(ep->preProcessEventSignal_);
    actReg_->postProcessEventSignal_.connect(ep->postProcessEventSignal_);
  }

char const * edm::EventProcessor::currentStateName

(

)

const

Member functions to support asynchronous interface.

Definition at line 903 of file EventProcessor.cc.

References getState(), and stateName().

Referenced by evf::FUEventProcessor::microState(), evf::FUEventProcessor::monitoring(), and evf::FUEventProcessor::stopping().

  {
    return stateName(getState());
  }

void edm::EventProcessor::declareRunNumber

(

RunNumber_t

runNumber

)

Definition at line 949 of file EventProcessor.cc.

References beginJob(), changeState(), and edm::event_processor::mSetRun.

Referenced by evf::FUEventProcessor::enabling(), and evf::FUEventProcessor::monitoring().

  {
    // inside of beginJob there is a check to see if it has been called before
    beginJob();
    changeState(mSetRun);

    // interface not correct yet - wait for Bill to be done with run/lumi loop stuff 21-Jun-2007
    //input_->declareRunNumber(runNumber);
  }

void edm::EventProcessor::deleteLumiFromCache	(	int	run,
		int	lumi
	)			[virtual]

Implements edm::IEventProcessor.

Definition at line 1602 of file EventProcessor.cc.

References edm::PrincipalCache::deleteLumi(), FDEBUG, and principalCache_.

                                                            {
    principalCache_.deleteLumi(run, lumi);
    FDEBUG(1) << "\tdeleteLumiFromCache " << run << "/" << lumi << "\n";
  }

void edm::EventProcessor::deleteRunFromCache

(

int

run

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1592 of file EventProcessor.cc.

References edm::PrincipalCache::deleteRun(), FDEBUG, and principalCache_.

                                                 {
    principalCache_.deleteRun(run);
    FDEBUG(1) << "\tdeleteRunFromCache " << run << "\n";
  }

void edm::EventProcessor::doErrorStuff

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1520 of file EventProcessor.cc.

References FDEBUG, and stateMachineWasInErrorState_.

                                    {
    FDEBUG(1) << "\tdoErrorStuff\n";
    edm::LogError("StateMachine")
      << "The EventProcessor state machine encountered an unexpected event\n"
      << "and went to the error state\n"
      << "Will attempt to terminate processing normally\n"
      << "(IF using the looper the next loop will be attempted)\n"
      << "This likely indicates a bug in an input module or corrupted input or both\n";
    stateMachineWasInErrorState_ = true;
  }

EventProcessor::StatusCode edm::EventProcessor::doneAsync

(

event_processor::Msg

m

)

[private]

Definition at line 1044 of file EventProcessor.cc.

References changeState(), and waitForAsyncCompletion().

  {
    // make sure to include a timeout here so we don't wait forever
    // I suspect there are still timing issues with thread startup
    // and the setting of the various control variables (stop_count,id_set)
    changeState(m);
    return waitForAsyncCompletion(60*2);
  }

std::auto_ptr< EventPrincipal > edm::EventProcessor::doOneEvent

(

EventID const &

id

)

[private]

Definition at line 704 of file EventProcessor.cc.

References input_, and procOneEvent().

Referenced by run().

                                              {
    std::auto_ptr<EventPrincipal> pep;
    {
      pep = input_->readEvent(id);
    }
    procOneEvent(pep.get());
    return pep;
  }

void edm::EventProcessor::enableEndPaths

(

bool

active

)

Turn end_paths "off" if "active" is false; turn end_paths "on" if "active" is true.

Definition at line 879 of file EventProcessor.cc.

References schedule_.

Referenced by evf::FUEventProcessor::actionPerformed(), and evf::FUEventProcessor::initEventProcessor().

  {
    schedule_->enableEndPaths(active);
  }

void edm::EventProcessor::endJob

(

void

)

This should be called before the EventProcessor is destroyed throws if any module's endJob throws an exception.

Definition at line 815 of file EventProcessor.cc.

References actReg_, c, edm::ExceptionCollector::call(), changeState(), edm::InputSource::doEndJob(), edm::Schedule::endJob(), edm::EDLooper::endOfJob(), edm::ExceptionCollector::hasThrown(), input_, looper_, edm::event_processor::mEndJob, edm::ExceptionCollector::rethrow(), schedule_, serviceToken_, and terminateMachine().

Referenced by stor::EPRunner::dowork(), and evf::FUEventProcessor::halting().

  {
    // Collects exceptions, so we don't throw before all operations are performed.
    ExceptionCollector c;

    // only allowed to run if state is sIdle,sJobReady,sRunGiven
    c.call(boost::bind(&EventProcessor::changeState, this, mEndJob));

    //make the services available
    ServiceRegistry::Operate operate(serviceToken_);  

    c.call(boost::bind(&EventProcessor::terminateMachine, this));
    c.call(boost::bind(&Schedule::endJob, schedule_.get()));
    c.call(boost::bind(&InputSource::doEndJob, input_));
    if (looper_) {
      c.call(boost::bind(&EDLooper::endOfJob, looper_));
    }
    c.call(boost::bind(&ActivityRegistry::PostEndJob::operator(), &actReg_->postEndJobSignal_));
    if (c.hasThrown()) {
      c.rethrow();
    }
  }

void edm::EventProcessor::endLumi	(	int	run,
		int	lumi
	)			[virtual]

Implements edm::IEventProcessor.

Definition at line 1562 of file EventProcessor.cc.

References edm::LuminosityBlockPrincipal::endTime(), esp_, FDEBUG, input_, edm::LuminosityBlockPrincipal::luminosityBlock(), edm::PrincipalCache::lumiPrincipal(), edm::EventID::maxEventNumber(), principalCache_, edm::LuminosityBlockPrincipal::run(), and schedule_.

                                                {
    LuminosityBlockPrincipal& lumiPrincipal = principalCache_.lumiPrincipal(run, lumi);
    input_->doEndLumi(lumiPrincipal);
    //NOTE: Using the max event number for the end of a lumi block is a bad idea
    // lumi blocks know their start and end times why not also start and end events?
    IOVSyncValue ts(EventID(lumiPrincipal.run(),EventID::maxEventNumber()),
                    lumiPrincipal.luminosityBlock(),
                    lumiPrincipal.endTime());
    EventSetup const& es = esp_->eventSetupForInstance(ts);
    schedule_->processOneOccurrence<OccurrenceTraits<LuminosityBlockPrincipal, BranchActionEnd> >(lumiPrincipal, es);
    FDEBUG(1) << "\tendLumi " << run << "/" << lumi << "\n";
  }

bool edm::EventProcessor::endOfLoop

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1478 of file EventProcessor.cc.

References esp_, FDEBUG, forceLooperToEnd_, edm::EDLooper::kContinue, looper_, and StDecayID::status.

                                 {
    if (looper_) {
      EDLooper::Status status = looper_->doEndOfLoop(esp_->eventSetup());
      if (status != EDLooper::kContinue || forceLooperToEnd_) return true;
      else return false;
    }
    FDEBUG(1) << "\tendOfLoop\n";
    return true;
  }

bool edm::EventProcessor::endPathsEnabled

(

)

const

Return true if end_paths are active, and false if they are inactive.

Definition at line 885 of file EventProcessor.cc.

References schedule_.

  {
    return schedule_->endPathsEnabled();
  }

void edm::EventProcessor::endRun

(

int

run

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1541 of file EventProcessor.cc.

References edm::RunPrincipal::endTime(), esp_, FDEBUG, input_, edm::EventID::maxEventNumber(), edm::LuminosityBlockID::maxLuminosityBlockNumber(), principalCache_, edm::RunPrincipal::run(), edm::PrincipalCache::runPrincipal(), and schedule_.

                                     {
    RunPrincipal& runPrincipal = principalCache_.runPrincipal(run);
    input_->doEndRun(runPrincipal);
    IOVSyncValue ts(EventID(runPrincipal.run(),EventID::maxEventNumber()),
                    LuminosityBlockID::maxLuminosityBlockNumber(),
                    runPrincipal.endTime());
    EventSetup const& es = esp_->eventSetupForInstance(ts);
    schedule_->processOneOccurrence<OccurrenceTraits<RunPrincipal, BranchActionEnd> >(runPrincipal, es);
    FDEBUG(1) << "\tendRun " << run << "\n";
  }

void edm::EventProcessor::errorState

(

)

[private]

Definition at line 1038 of file EventProcessor.cc.

References edm::event_processor::sError, and state_.

Referenced by shutdownAsync(), stopAsync(), and waitTillDoneAsync().

  {
    state_ = sError;
  }

std::vector< ModuleDescription const * > edm::EventProcessor::getAllModuleDescriptions

(

)

const

Return a vector allowing const access to all the ModuleDescriptions for this EventProccessor.

*** N.B. *** Ownership of the ModuleDescriptions is *not* passed to the caller. Do not call delete on these pointers!

Definition at line 855 of file EventProcessor.cc.

References schedule_.

Referenced by evf::FUEventProcessor::initEventProcessor().

  {
    return schedule_->getAllModuleDescriptions();
  }

State edm::EventProcessor::getState

(

)

const

Definition at line 918 of file EventProcessor.cc.

References state_.

Referenced by currentStateName(), evf::FUEventProcessor::enabling(), evf::FUEventProcessor::halting(), evf::FUEventProcessor::microState(), evf::FUEventProcessor::monitoring(), evf::FUEventProcessor::scalers(), and evf::FUEventProcessor::stopEventProcessor().

  {
    return state_;
  }

ServiceToken edm::EventProcessor::getToken

(

)

Definition at line 839 of file EventProcessor.cc.

References serviceToken_.

Referenced by evf::FUEventProcessor::attachDqmToShm(), evf::FUEventProcessor::defaultWebPage(), evf::FUEventProcessor::detachDqmFromShm(), stor::EPRunner::getToken(), evf::FUEventProcessor::moduleWeb(), evf::FUEventProcessor::serviceWeb(), and ~EventProcessor().

  {
    return serviceToken_;
  }

void edm::EventProcessor::getTriggerReport

(

TriggerReport &

rep

)

const

Return the trigger report information on paths, modules-in-path, modules-in-endpath, and modules.

Definition at line 891 of file EventProcessor.cc.

References schedule_.

Referenced by evf::FUEventProcessor::getTriggerReport(), evf::FUEventProcessor::monitoring(), and evf::FUEventProcessor::spotlightWebPage().

  {
    schedule_->getTriggerReport(rep);
  }

void edm::EventProcessor::init	(	boost::shared_ptr< edm::ProcessDesc > &	processDesc,
		ServiceToken const &	token,
		serviceregistry::ServiceLegacy	iLegacy
	)			[private]

Definition at line 566 of file EventProcessor.cc.

References act_table_, actReg_, connectSigs(), edm::ServiceToken::copySlotsTo(), edm::ServiceRegistry::createContaining(), edm::ServiceRegistry::createSet(), lat::endl(), esp_, FDEBUG, fileMode_, edm::fillEventSetupProvider(), edm::fillLooper(), edm::getPassID(), edm::getReleaseVersion(), edm::ParameterSet::getUntrackedParameter(), handleEmptyLumis_, handleEmptyRuns_, input_, edm::ServiceRegistry::instance(), edm::serviceregistry::kOverlapIsError, looper_, edm::makeEventSetupProvider(), edm::makeInput(), maxEventsPset_, maxLumisPset_, preg_, schedule_, serviceToken_, and wreg_.

Referenced by EventProcessor().

                                                              {
    // TODO: Fix const-correctness. The ParameterSets that are
    // returned here should be const, so that we can be sure they are
    // not modified.

    shared_ptr<ParameterSet> parameterSet = processDesc->getProcessPSet();

    ParameterSet optionsPset(parameterSet->getUntrackedParameter<ParameterSet>("options", ParameterSet()));
    fileMode_ = optionsPset.getUntrackedParameter<std::string>("fileMode", "");
    handleEmptyRuns_ = optionsPset.getUntrackedParameter<bool>("handleEmptyRuns", true);
    handleEmptyLumis_ = optionsPset.getUntrackedParameter<bool>("handleEmptyLumis", true);

    maxEventsPset_ = parameterSet->getUntrackedParameter<ParameterSet>("maxEvents", ParameterSet());
    maxLumisPset_ = parameterSet->getUntrackedParameter<ParameterSet>("maxLuminosityBlocks", ParameterSet());

    shared_ptr<std::vector<ParameterSet> > pServiceSets = processDesc->getServicesPSets();
    //makeParameterSets(config, parameterSet, pServiceSets);

    //create the services
    ServiceToken tempToken(ServiceRegistry::createSet(*pServiceSets, iToken, iLegacy));

    // Copy slots that hold all the registered callback functions like
    // PostBeginJob into an ActivityRegistry that is owned by EventProcessor
    tempToken.copySlotsTo(*actReg_); 
    
    //add the ProductRegistry as a service ONLY for the construction phase
    typedef serviceregistry::ServiceWrapper<ConstProductRegistry> w_CPR;
    shared_ptr<w_CPR>
      reg(new w_CPR(std::auto_ptr<ConstProductRegistry>(new ConstProductRegistry(preg_))));
    ServiceToken tempToken2(ServiceRegistry::createContaining(reg, 
                                                              tempToken, 
                                                              kOverlapIsError));

    // the next thing is ugly: pull out the trigger path pset and 
    // create a service and extra token for it
    std::string processName = parameterSet->getParameter<std::string>("@process_name");

    typedef edm::service::TriggerNamesService TNS;
    typedef serviceregistry::ServiceWrapper<TNS> w_TNS;

    shared_ptr<w_TNS> tnsptr
      (new w_TNS(std::auto_ptr<TNS>(new TNS(*parameterSet))));

    serviceToken_ = ServiceRegistry::createContaining(tnsptr, 
                                                    tempToken2, 
                                                    kOverlapIsError);

    //make the services available
    ServiceRegistry::Operate operate(serviceToken_);
     
    //parameterSet = builder.getProcessPSet();
    act_table_ = ActionTable(*parameterSet);
    CommonParams common = CommonParams(processName,
                           getReleaseVersion(),
                           getPassID(),
                           maxEventsPset_.getUntrackedParameter<int>("input", -1),
                           maxLumisPset_.getUntrackedParameter<int>("input", -1));

    esp_ = makeEventSetupProvider(*parameterSet);
    fillEventSetupProvider(*esp_, *parameterSet, common);

    looper_ = fillLooper(*esp_, *parameterSet, common);
    if (looper_) looper_->setActionTable(&act_table_);
    
    input_= makeInput(*parameterSet, common, preg_, actReg_);
    schedule_ = std::auto_ptr<Schedule>
      (new Schedule(*parameterSet,
                    ServiceRegistry::instance().get<TNS>(),
                    wreg_,
                    preg_,
                    act_table_,
                    actReg_));

    //   initialize(iToken,iLegacy);
    FDEBUG(2) << parameterSet->toString() << std::endl;
    connectSigs(this);
  }

char const * edm::EventProcessor::msgName

(

event_processor::Msg

m

)

const

Definition at line 913 of file EventProcessor.cc.

References edm::msgNames.

Referenced by changeState().

  {
    return msgNames[m];
  }

void edm::EventProcessor::openOutputFiles

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1440 of file EventProcessor.cc.

References fb_, FDEBUG, and schedule_.

                                       {
    schedule_->openOutputFiles(*fb_);
    FDEBUG(1) << "\topenOutputFiles\n";
  }

ActivityRegistry::PostProcessEvent& edm::EventProcessor::postProcessEventSignal

(

)

[inline]

signal is emitted after all modules have finished processing the Event

Definition at line 219 of file EventProcessor.h.

References postProcessEventSignal_.

{return postProcessEventSignal_;}

void edm::EventProcessor::prepareForNextLoop

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1494 of file EventProcessor.cc.

References esp_, FDEBUG, and looper_.

                                          {
    looper_->prepareForNextLoop(esp_.get());
    FDEBUG(1) << "\tprepareForNextLoop\n";
  }

ActivityRegistry::PreProcessEvent& edm::EventProcessor::preProcessEventSignal

(

)

[inline]

signal is emitted after the Event has been created by the InputSource but before any modules have seen the Event

Definition at line 214 of file EventProcessor.h.

References preProcessEventSignal_.

{return preProcessEventSignal_;}

void edm::EventProcessor::processEvent

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1612 of file EventProcessor.cc.

References esp_, FDEBUG, edm::EDLooper::kContinue, looper_, schedule_, shouldWeStop_, sm_evp_, and StDecayID::status.

                                    {
    IOVSyncValue ts(sm_evp_->id(), sm_evp_->luminosityBlock(), sm_evp_->time());
    EventSetup const& es = esp_->eventSetupForInstance(ts);
    schedule_->processOneOccurrence<OccurrenceTraits<EventPrincipal, BranchActionBegin> >(*sm_evp_, es);
 
    if (looper_) {
      EDLooper::Status status = looper_->doDuringLoop(*sm_evp_, esp_->eventSetup());
      if (status != EDLooper::kContinue) shouldWeStop_ = true;
    }

    FDEBUG(1) << "\tprocessEvent\n";
  }

void edm::EventProcessor::procOneEvent

(

EventPrincipal *

pep

)

[private]

Definition at line 714 of file EventProcessor.cc.

References esp_, edm::EventPrincipal::id(), edm::EventPrincipal::luminosityBlock(), schedule_, and edm::EventPrincipal::time().

Referenced by doOneEvent().

                                                  {
    if(0 != pep) {
      IOVSyncValue ts(pep->id(), pep->luminosityBlock(), pep->time());
      EventSetup const& es = esp_->eventSetupForInstance(ts);
      schedule_->processOneOccurrence<OccurrenceTraits<EventPrincipal, BranchActionBegin> >(*pep, es);
    }
  }

int edm::EventProcessor::readAndCacheLumi

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1581 of file EventProcessor.cc.

References FDEBUG, input_, edm::PrincipalCache::insert(), edm::LuminosityBlockPrincipal::luminosityBlock(), edm::PrincipalCache::lumiPrincipal(), principalCache_, and edm::PrincipalCache::runPrincipalPtr().

                                       {
    principalCache_.insert(input_->readLuminosityBlock(principalCache_.runPrincipalPtr()));
    FDEBUG(1) << "\treadAndCacheLumi " << "\n";
    return principalCache_.lumiPrincipal().luminosityBlock();
  }

int edm::EventProcessor::readAndCacheRun

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1575 of file EventProcessor.cc.

References FDEBUG, input_, edm::PrincipalCache::insert(), principalCache_, edm::RunPrincipal::run(), and edm::PrincipalCache::runPrincipal().

                                      {
    principalCache_.insert(input_->readRun());
    FDEBUG(1) << "\treadAndCacheRun " << "\n";
    return principalCache_.runPrincipal().run();
  }

void edm::EventProcessor::readEvent

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1607 of file EventProcessor.cc.

References FDEBUG, input_, edm::PrincipalCache::lumiPrincipalPtr(), principalCache_, and sm_evp_.

                                 {
    sm_evp_ = input_->readEvent(principalCache_.lumiPrincipalPtr());
    FDEBUG(1) << "\treadEvent\n";
  }

void edm::EventProcessor::readFile

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1430 of file EventProcessor.cc.

References fb_, FDEBUG, and input_.

                                {
    FDEBUG(1) << " \treadFile\n";
    fb_ = input_->readFile();
  }

void edm::EventProcessor::respondToCloseInputFile

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1455 of file EventProcessor.cc.

References fb_, FDEBUG, and schedule_.

                                               {
    schedule_->respondToCloseInputFile(*fb_);
    FDEBUG(1) << "\trespondToCloseInputFile\n";
  }

void edm::EventProcessor::respondToCloseOutputFiles

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1465 of file EventProcessor.cc.

References fb_, FDEBUG, and schedule_.

                                                 {
    schedule_->respondToCloseOutputFiles(*fb_);
    FDEBUG(1) << "\trespondToCloseOutputFiles\n";
  }

void edm::EventProcessor::respondToOpenInputFile

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1450 of file EventProcessor.cc.

References fb_, FDEBUG, and schedule_.

                                              {
    schedule_->respondToOpenInputFile(*fb_);
    FDEBUG(1) << "\trespondToOpenInputFile\n";
  }

void edm::EventProcessor::respondToOpenOutputFiles

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1460 of file EventProcessor.cc.

References fb_, FDEBUG, and schedule_.

                                                {
    schedule_->respondToOpenOutputFiles(*fb_);
    FDEBUG(1) << "\trespondToOpenOutputFiles\n";
  }

void edm::EventProcessor::rewind

(

)

Definition at line 682 of file EventProcessor.cc.

References beginJob(), changeState(), input_, edm::event_processor::mCountComplete, edm::event_processor::mFinished, edm::event_processor::mInputRewind, edm::event_processor::mStopAsync, serviceToken_, and edm::event_processor::StateSentry::succeeded().

  {
    beginJob(); //make sure this was called
    changeState(mStopAsync);
    changeState(mInputRewind);
    {
      StateSentry toerror(this);

      //make the services available
      ServiceRegistry::Operate operate(serviceToken_);
      
      {
        input_->repeat();
        input_->rewind();
      }
      changeState(mCountComplete);
      toerror.succeeded();
    }
    changeState(mFinished);
  }

void edm::EventProcessor::rewindInput

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1488 of file EventProcessor.cc.

References FDEBUG, and input_.

                                   {
    input_->repeat();
    input_->rewind();
    FDEBUG(1) << "\trewind\n";
  }

EventProcessor::StatusCode edm::EventProcessor::run

(

EventID const &

id

)

Definition at line 729 of file EventProcessor.cc.

References beginJob(), changeState(), doOneEvent(), edm::IEventProcessor::epInputComplete, edm::IEventProcessor::epSuccess, edm::event_processor::mCountComplete, edm::event_processor::mFinished, edm::event_processor::mInputExhausted, edm::event_processor::mRunID, serviceToken_, and edm::event_processor::StateSentry::succeeded().

  {
    beginJob(); //make sure this was called
    changeState(mRunID);
    StateSentry toerror(this);
    Status rc = epSuccess;

    //make the services available
    ServiceRegistry::Operate operate(serviceToken_);

    if(doOneEvent(id).get() == 0) {
      changeState(mInputExhausted);
    } else {
      changeState(mCountComplete);
      rc = epInputComplete;
    }
    toerror.succeeded();
    changeState(mFinished);
    return rc;
  }

EventProcessor::StatusCode edm::EventProcessor::run

(

void

)

[inline]

Definition at line 432 of file EventProcessor.h.

                      {
    return run(-1, false);
  }

EventProcessor::StatusCode edm::EventProcessor::run	(	int	numberEventsToProcess,
		bool	repeatable = true
	)

Definition at line 723 of file EventProcessor.cc.

References runEventCount().

Referenced by stor::EPRunner::dowork().

  {
    return runEventCount(numberEventsToProcess);
  }

void edm::EventProcessor::runAsync

(

)

Definition at line 1084 of file EventProcessor.cc.

References asyncRun(), beginJob(), changeState(), edm::IEventProcessor::epSuccess, err, event_loop_, Exception, id_set_, last_rc_, edm::event_processor::mRunAsync, sl, starter_, stop_count_, stop_lock_, thread, and lhef::timeout().

Referenced by evf::FUEventProcessor::enabling(), and evf::FUEventProcessor::monitoring().

  {
    using boost::thread;
    beginJob();
    {
      boost::mutex::scoped_lock sl(stop_lock_);
      if(id_set_==true) {
          std::string err("runAsync called while async event loop already running\n");
          edm::LogError("FwkJob") << err;
          throw cms::Exception("BadState") << err;
      }

      changeState(mRunAsync);

      stop_count_=0;
      last_rc_=epSuccess; // forget the last value!
      event_loop_.reset(new thread(boost::bind(EventProcessor::asyncRun,this)));
      boost::xtime timeout;
      boost::xtime_get(&timeout, boost::TIME_UTC); 
      timeout.sec += 60; // 60 seconds to start!!!!
      if(starter_.timed_wait(sl,timeout)==false) {
          // yikes - the thread did not start
          throw cms::Exception("BadState")
            << "Async run thread did not start in 60 seconds\n";
      }
    }
  }

edm::EventProcessor::StatusCode edm::EventProcessor::runCommon	(	bool	onlineStateTransitions,
		int	numberOfEventsToProcess
	)			[private]

Definition at line 1209 of file EventProcessor.cc.

References alreadyHandlingException_, beginJob(), changeState(), edm::errors::Configuration, e, edm::IEventProcessor::epCountComplete, edm::IEventProcessor::epSignal, edm::IEventProcessor::epSuccess, exception, Exception, exceptionMessageFiles_, exceptionMessageLumis_, exceptionMessageRuns_, FDEBUG, harvestingCosmics_cfg::fileMode, fileMode_, forceLooperToEnd_, statemachine::FULLLUMIMERGE, statemachine::FULLMERGE, handleEmptyLumis_, handleEmptyRuns_, input_, edm::InputSource::IsEvent, edm::InputSource::IsFile, edm::InputSource::IsLumi, edm::InputSource::IsRun, edm::InputSource::IsStop, edm::errors::LogicError, machine_, statemachine::MERGE, edm::event_processor::mFinished, edm::event_processor::mInputExhausted, edm::event_processor::mRunCount, edm::event_processor::mShutdownSignal, statemachine::NOMERGE, serviceToken_, edm::shutdown_flag, sl, edm::event_processor::sShuttingDown, edm::event_processor::sStopping, state_, stateMachineWasInErrorState_, terminateMachine(), and edm::usr2_lock.

Referenced by runEventCount(), and runToCompletion().

                                                                                    {

    beginJob(); //make sure this was called

    if (!onlineStateTransitions) changeState(mRunCount);

    StatusCode returnCode = epSuccess;
    stateMachineWasInErrorState_ = false;

    // make the services available
    ServiceRegistry::Operate operate(serviceToken_);

    if (machine_.get() == 0) {
 
      statemachine::FileMode fileMode;
      if (fileMode_.empty()) fileMode = statemachine::FULLMERGE;
      else if (fileMode_ == std::string("MERGE")) fileMode = statemachine::MERGE;
      else if (fileMode_ == std::string("NOMERGE")) fileMode = statemachine::NOMERGE;
      else if (fileMode_ == std::string("FULLMERGE")) fileMode = statemachine::FULLMERGE;
      else if (fileMode_ == std::string("FULLLUMIMERGE")) fileMode = statemachine::FULLLUMIMERGE;
      else {
        throw edm::Exception(errors::Configuration, "Illegal fileMode parameter value: ")
            << fileMode_ << ".\n"
            << "Legal values are 'MERGE', 'NOMERGE', 'FULLMERGE', and 'FULLLUMIMERGE'.\n";
      }

      machine_.reset(new statemachine::Machine(this,
                                               fileMode,
                                               handleEmptyRuns_,
                                               handleEmptyLumis_));

      machine_->initiate();
    }

    try {

      InputSource::ItemType itemType;

      int iEvents = 0;

      while (true) {

        itemType = input_->nextItemType();

        FDEBUG(1) << "itemType = " << itemType << "\n";

        // These are used for asynchronous running only and
        // and are checking to see if stopAsync or shutdownAsync
        // were called from another thread.  In the future, we
        // may need to do something better than polling the state.
        // With the current code this is the simplest thing and
        // it should always work.  If the interaction between
        // threads becomes more complex this may cause problems.
        if (state_ == sStopping) {
          FDEBUG(1) << "In main processing loop, encountered sStopping state\n";
          forceLooperToEnd_ = true;
          machine_->process_event(statemachine::Stop());
          forceLooperToEnd_ = false;
          break;
        }
        else if (state_ == sShuttingDown) {
          FDEBUG(1) << "In main processing loop, encountered sShuttingDown state\n";
          forceLooperToEnd_ = true;
          machine_->process_event(statemachine::Stop());
          forceLooperToEnd_ = false;
          break;
        }

        // Look for a shutdown signal
        {
          boost::mutex::scoped_lock sl(usr2_lock);
          if (edm::shutdown_flag) {
            changeState(mShutdownSignal);
            returnCode = epSignal;
            forceLooperToEnd_ = true;
            machine_->process_event(statemachine::Stop());
            forceLooperToEnd_ = false;
            break;
          }
        }

        if (itemType == InputSource::IsStop) {
          machine_->process_event(statemachine::Stop());
        }
        else if (itemType == InputSource::IsFile) {
          machine_->process_event(statemachine::File());
        }
        else if (itemType == InputSource::IsRun) {
          machine_->process_event(statemachine::Run(input_->run()));
        }
        else if (itemType == InputSource::IsLumi) {
          machine_->process_event(statemachine::Lumi(input_->luminosityBlock()));
        }
        else if (itemType == InputSource::IsEvent) {
          machine_->process_event(statemachine::Event());
          ++iEvents;
          if (numberOfEventsToProcess > 0 && iEvents >= numberOfEventsToProcess) {
            returnCode = epCountComplete;            
            changeState(mInputExhausted);
            FDEBUG(1) << "Event count complete, pausing event loop\n";
            break;
          }
        }
        // This should be impossible
        else {
          throw edm::Exception(errors::LogicError)
            << "Unknown next item type passed to EventProcessor\n"
            << "Please report this error to the Framework group\n";
        }

        if (machine_->terminated()) {
          changeState(mInputExhausted);
          break;
        }
      }  // End of loop over state machine events
    } // Try block 

    // Some comments on exception handling related to the boost state machine:
    //
    // Some states used in the machine are special because they
    // perform actions while the machine is being terminated, actions
    // such as close files, call endRun, call endLumi etc ...  Each of these
    // states has two functions that perform these actions.  The functions
    // are almost identical.  The major difference is that one version
    // catches all exceptions and the other lets exceptions pass through.
    // The destructor catches them and the other function named "exit" lets
    // them pass through.  On a normal termination, boost will always call
    // "exit" and then the state destructor.  In our state classes, the
    // the destructors do nothing if the exit function already took
    // care of things.  Here's the interesting part.  When boost is
    // handling an exception the "exit" function is not called (a boost
    // feature).
    //
    // If an exception occurs while the boost machine is in control
    // (which usually means inside a process_event call), then
    // the boost state machine destroys its states and "terminates" itself.
    // This already done before we hit the catch blocks below. In this case
    // the call to terminateMachine below only destroys an already
    // terminated state machine.  Because exit is not called, the state destructors
    // handle cleaning up lumis, runs, and files.  The destructors swallow
    // all exceptions and only pass through the exceptions messages which
    // are tacked onto the original exception below.
    // 
    // If an exception occurs when the boost state machine is not
    // in control (outside the process_event functions), then boost
    // cannot destroy its own states.  The terminateMachine function
    // below takes care of that.  The flag "alreadyHandlingException"
    // is set true so that the state exit functions do nothing (and
    // cannot throw more exceptions while handling the first).  Then the
    // state destructors take care of this because exit did nothing.
    //
    // In both cases above, the EventProcessor::endOfLoop function is
    // not called because it can throw exceptions.
    //
    // One tricky aspect of the state machine is that things which can
    // throw should not be invoked by the state machine while another
    // exception is being handled.
    // Another tricky aspect is that it appears to be important to 
    // terminate the state machine before invoking its destructor.
    // We've seen crashes which are not understood when that is not
    // done.  Maintainers of this code should be careful about this.

    catch (cms::Exception& e) {
      alreadyHandlingException_ = true;
      terminateMachine();
      alreadyHandlingException_ = false;
      e << "cms::Exception caught in EventProcessor and rethrown\n";
      e << exceptionMessageLumis_;
      e << exceptionMessageRuns_;
      e << exceptionMessageFiles_;
      throw e;
    }
    catch (std::bad_alloc& e) {
      alreadyHandlingException_ = true;
      terminateMachine();
      alreadyHandlingException_ = false;
      throw cms::Exception("std::bad_alloc")
        << "The EventProcessor caught a std::bad_alloc exception and converted it to a cms::Exception\n"
        << "The job has probably exhausted the virtual memory available to the process.\n"
        << exceptionMessageLumis_
        << exceptionMessageRuns_
        << exceptionMessageFiles_;
    }
    catch (std::exception& e) {
      alreadyHandlingException_ = true;
      terminateMachine();
      alreadyHandlingException_ = false;
      throw cms::Exception("StdException")
        << "The EventProcessor caught a std::exception and converted it to a cms::Exception\n"
        << "Previous information:\n" << e.what() << "\n"
        << exceptionMessageLumis_
        << exceptionMessageRuns_
        << exceptionMessageFiles_;
    }
    catch (...) {
      alreadyHandlingException_ = true;
      terminateMachine();
      alreadyHandlingException_ = false;
      throw cms::Exception("Unknown")
        << "The EventProcessor caught an unknown exception type and converted it to a cms::Exception\n"
        << exceptionMessageLumis_
        << exceptionMessageRuns_
        << exceptionMessageFiles_;
    }

    if (machine_->terminated()) {
      FDEBUG(1) << "The state machine reports it has been terminated\n";
      machine_.reset();
    }

    if (!onlineStateTransitions) changeState(mFinished);

    if (stateMachineWasInErrorState_) {
      throw cms::Exception("BadState")
        << "The boost state machine in the EventProcessor exited after\n"
        << "entering the Error state.\n";
    }

    return returnCode;
  }

edm::EventProcessor::StatusCode edm::EventProcessor::runEventCount

(

int

numberOfEventsToProcess

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1196 of file EventProcessor.cc.

References runCommon(), and edm::event_processor::StateSentry::succeeded().

Referenced by run().

                                                           {

    StateSentry toerror(this);

    bool onlineStateTransitions = false;
    StatusCode returnCode = runCommon(onlineStateTransitions, numberOfEventsToProcess);

    toerror.succeeded();

    return returnCode;
  }

edm::EventProcessor::StatusCode edm::EventProcessor::runToCompletion

(

bool

onlineStateTransitions

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1177 of file EventProcessor.cc.

References edm::errors::LogicError, machine_, runCommon(), and edm::event_processor::StateSentry::succeeded().

Referenced by asyncRun().

                                                             {

    StateSentry toerror(this);

    int numberOfEventsToProcess = -1;
    StatusCode returnCode = runCommon(onlineStateTransitions, numberOfEventsToProcess);

    if (machine_.get() != 0) {
      throw edm::Exception(errors::LogicError)
        << "State machine not destroyed on exit from EventProcessor::runToCompletion\n"
        << "Please report this error to the Framework group\n";
    }

    toerror.succeeded();

    return returnCode;
  }

void edm::EventProcessor::setExceptionMessageFiles

(

std::string &

message

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1631 of file EventProcessor.cc.

References exceptionMessageFiles_.

                                                                  {
    exceptionMessageFiles_ = message;
  }

void edm::EventProcessor::setExceptionMessageLumis

(

std::string &

message

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1639 of file EventProcessor.cc.

References exceptionMessageLumis_.

                                                                  {
    exceptionMessageLumis_ = message;
  }

void edm::EventProcessor::setExceptionMessageRuns

(

std::string &

message

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1635 of file EventProcessor.cc.

References exceptionMessageRuns_.

                                                                 {
    exceptionMessageRuns_ = message;
  }

void edm::EventProcessor::setRunNumber

(

RunNumber_t

runNumber

)

Definition at line 931 of file EventProcessor.cc.

References beginJob(), changeState(), input_, and edm::event_processor::mSetRun.

Referenced by evf::FUEventProcessor::enabling(), and evf::FUEventProcessor::monitoring().

  {
    if (runNumber == 0) {
      runNumber = 1;
      LogWarning("Invalid Run")
        << "EventProcessor::setRunNumber was called with an invalid run number (0)\n"
        << "Run number was set to 1 instead\n";
    }

    // inside of beginJob there is a check to see if it has been called before
    beginJob();
    changeState(mSetRun);

    // interface not correct yet
    input_->setRunNumber(runNumber);
  }

void edm::EventProcessor::setupSignal

(

)

[private]

bool edm::EventProcessor::shouldWeCloseOutput

(

)

const [virtual]

Implements edm::IEventProcessor.

Definition at line 1515 of file EventProcessor.cc.

References FDEBUG, and schedule_.

                                                 {
    FDEBUG(1) << "\tshouldWeCloseOutput\n";
    return schedule_->shouldWeCloseOutput();
  }

bool edm::EventProcessor::shouldWeStop

(

)

const [virtual]

Implements edm::IEventProcessor.

Definition at line 1625 of file EventProcessor.cc.

References FDEBUG, schedule_, and shouldWeStop_.

                                          {
    FDEBUG(1) << "\tshouldWeStop\n";
    if (shouldWeStop_) return true;
    return schedule_->terminate();
  }

EventProcessor::StatusCode edm::EventProcessor::shutdownAsync

(

unsigned int

timeout_secs = 60*2

)

Definition at line 1029 of file EventProcessor.cc.

References changeState(), edm::IEventProcessor::epTimedOut, errorState(), edm::event_processor::mFinished, edm::event_processor::mShutdownAsync, and waitForAsyncCompletion().

  {
    changeState(mShutdownAsync);
    StatusCode rc = waitForAsyncCompletion(secs);
    if(rc!=epTimedOut) changeState(mFinished);
    else errorState();
    return rc;
  }

EventProcessor::StatusCode edm::EventProcessor::skip

(

int

numberToSkip

)

Definition at line 751 of file EventProcessor.cc.

References beginJob(), changeState(), edm::IEventProcessor::epSuccess, input_, edm::event_processor::mCountComplete, edm::event_processor::mFinished, edm::event_processor::mSkip, serviceToken_, and edm::event_processor::StateSentry::succeeded().

  {
    beginJob(); //make sure this was called
    changeState(mSkip);
    {
      StateSentry toerror(this);

      //make the services available
      ServiceRegistry::Operate operate(serviceToken_);
      
      {
        input_->skipEvents(numberToSkip);
      }
      changeState(mCountComplete);
      toerror.succeeded();
    }
    changeState(mFinished);
    return epSuccess;
  }

void edm::EventProcessor::startingNewLoop

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1470 of file EventProcessor.cc.

References FDEBUG, looper_, and shouldWeStop_.

                                       {
    shouldWeStop_ = false;
    if (looper_) {
      looper_->doStartingNewLoop();
    }
    FDEBUG(1) << "\tstartingNewLoop\n";
  }

char const * edm::EventProcessor::stateName

(

event_processor::State

s

)

const

Definition at line 908 of file EventProcessor.cc.

References edm::stateNames.

Referenced by changeState(), currentStateName(), evf::FUEventProcessor::initEventProcessor(), and evf::FUEventProcessor::stopEventProcessor().

  {
    return stateNames[s];
  }

EventProcessor::StatusCode edm::EventProcessor::statusAsync

(

)

const

Definition at line 923 of file EventProcessor.cc.

References last_rc_.

Referenced by evf::FUEventProcessor::enabling(), and evf::FUEventProcessor::monitoring().

  {
    // the thread will record exception/error status in the event processor
    // for us to look at and report here
    return last_rc_;
  }

EventProcessor::StatusCode edm::EventProcessor::stopAsync

(

unsigned int

timeout_secs = 60*2

)

Definition at line 1020 of file EventProcessor.cc.

References changeState(), edm::IEventProcessor::epTimedOut, errorState(), edm::event_processor::mFinished, edm::event_processor::mStopAsync, and waitForAsyncCompletion().

  {
    changeState(mStopAsync);
    StatusCode rc = waitForAsyncCompletion(secs);
    if(rc!=epTimedOut) changeState(mFinished);
    else errorState();
    return rc;
  }

void edm::EventProcessor::terminateMachine

(

)

[private]

Definition at line 1647 of file EventProcessor.cc.

References FDEBUG, forceLooperToEnd_, and machine_.

Referenced by endJob(), runCommon(), and ~EventProcessor().

                                        {
    if (machine_.get() != 0) {
      if (!machine_->terminated()) {
        forceLooperToEnd_ = true;
        machine_->process_event(statemachine::Stop());
        forceLooperToEnd_ = false;
      }
      else {
        FDEBUG(1) << "EventProcess::terminateMachine  The state machine was already terminated \n";
      }
      if (machine_->terminated()) {
        FDEBUG(1) << "The state machine reports it has been terminated (3)\n";
      }
      machine_.reset();
    }
  }

int edm::EventProcessor::totalEvents

(

)

const

Return the number of events this EventProcessor has tried to process (inclues both successes and failures, including failures due to exceptions during processing).

Definition at line 861 of file EventProcessor.cc.

References schedule_.

Referenced by evf::FUEventProcessor::getTriggerReport(), and evf::FUEventProcessor::monitoring().

  {
    return schedule_->totalEvents();
  }

int edm::EventProcessor::totalEventsFailed

(

)

const

Return the number of events that have not passed any trigger.

(N.B. totalEventsFailed() + totalEventsPassed() == totalEvents()

Definition at line 873 of file EventProcessor.cc.

References schedule_.

  {
    return schedule_->totalEventsFailed();
  }

int edm::EventProcessor::totalEventsPassed

(

)

const

Return the number of events processed by this EventProcessor which have been passed by one or more trigger paths.

Definition at line 867 of file EventProcessor.cc.

References schedule_.

Referenced by evf::FUEventProcessor::monitoring().

  {
    return schedule_->totalEventsPassed();
  }

EventProcessor::StatusCode edm::EventProcessor::waitForAsyncCompletion

(

unsigned int

timeout_seconds

)

[private]

Definition at line 960 of file EventProcessor.cc.

References edm::IEventProcessor::epTimedOut, event_loop_, event_loop_id_, id_set_, last_rc_, sl, stop_count_, stop_lock_, stopper_, and lhef::timeout().

Referenced by doneAsync(), shutdownAsync(), stopAsync(), and waitTillDoneAsync().

  {
    bool rc = true;
    boost::xtime timeout;
    boost::xtime_get(&timeout, boost::TIME_UTC); 
    timeout.sec += timeout_seconds;

    // make sure to include a timeout here so we don't wait forever
    // I suspect there are still timing issues with thread startup
    // and the setting of the various control variables (stop_count,id_set)
    {
      boost::mutex::scoped_lock sl(stop_lock_);

      // look here - if runAsync not active, just return the last return code
      if(stop_count_ < 0) return last_rc_;

      if(timeout_seconds==0)
        while(stop_count_==0) stopper_.wait(sl);
      else
        while(stop_count_==0 &&
              (rc = stopper_.timed_wait(sl,timeout)) == true);
      
      if(rc == false)
        {
          // timeout occurred
          // if(id_set_) pthread_kill(event_loop_id_,my_sig_num_);
          // this is a temporary hack until we get the input source
          // upgraded to allow blocking input sources to be unblocked

          // the next line is dangerous and causes all sorts of trouble
          if(id_set_) pthread_cancel(event_loop_id_);

          // we will not do anything yet
          LogWarning("timeout")
            << "An asynchronous request was made to shut down "
            << "the event loop "
            << "and the event loop did not shutdown after "
            << timeout_seconds << " seconds\n";
        }
      else
        {
          event_loop_->join();
          event_loop_.reset();
          id_set_ = false;
          stop_count_ = -1;
        }
    }
    return rc==false?epTimedOut:last_rc_;
  }

EventProcessor::StatusCode edm::EventProcessor::waitTillDoneAsync

(

unsigned int

timeout_seconds = 0

)

Definition at line 1011 of file EventProcessor.cc.

References changeState(), edm::IEventProcessor::epTimedOut, errorState(), edm::event_processor::mCountComplete, and waitForAsyncCompletion().

Referenced by evf::FUEventProcessor::stopEventProcessor().

  {
    StatusCode rc = waitForAsyncCompletion(timeout_value_secs);
    if(rc!=epTimedOut) changeState(mCountComplete);
    else errorState();
    return rc;
  }

void edm::EventProcessor::writeLumi	(	int	run,
		int	lumi
	)			[virtual]

Implements edm::IEventProcessor.

Definition at line 1597 of file EventProcessor.cc.

References FDEBUG, edm::PrincipalCache::lumiPrincipal(), principalCache_, and schedule_.

                                                  {
    schedule_->writeLumi(principalCache_.lumiPrincipal(run, lumi));
    FDEBUG(1) << "\twriteLumi " << run << "/" << lumi << "\n";
  }

void edm::EventProcessor::writeLumiCache

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1499 of file EventProcessor.cc.

References edm::PrincipalCache::deleteLowestLumi(), FDEBUG, edm::PrincipalCache::lowestLumi(), edm::PrincipalCache::noMoreLumis(), principalCache_, and schedule_.

                                      {
    while (!principalCache_.noMoreLumis()) {
      schedule_->writeLumi(principalCache_.lowestLumi());
      principalCache_.deleteLowestLumi();      
    }
    FDEBUG(1) << "\twriteLumiCache\n";
  }

void edm::EventProcessor::writeRun

(

int

run

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1587 of file EventProcessor.cc.

References FDEBUG, principalCache_, edm::PrincipalCache::runPrincipal(), and schedule_.

                                       {
    schedule_->writeRun(principalCache_.runPrincipal(run));
    FDEBUG(1) << "\twriteRun " << run << "\n";
  }

void edm::EventProcessor::writeRunCache

(

)

[virtual]

Implements edm::IEventProcessor.

Definition at line 1507 of file EventProcessor.cc.

References edm::PrincipalCache::deleteLowestRun(), FDEBUG, edm::PrincipalCache::lowestRun(), edm::PrincipalCache::noMoreRuns(), principalCache_, and schedule_.

                                     {
    while (!principalCache_.noMoreRuns()) {
      schedule_->writeRun(principalCache_.lowestRun());
      principalCache_.deleteLowestRun();      
    }
    FDEBUG(1) << "\twriteRunCache\n";
  }

---

Friends And Related Function Documentation

friend class event_processor::StateSentry [friend]

Definition at line 425 of file EventProcessor.h.

---

Member Data Documentation

ActionTable edm::EventProcessor::act_table_ [private]

Definition at line 393 of file EventProcessor.h.

Referenced by init().

boost::shared_ptr<ActivityRegistry> edm::EventProcessor::actReg_ [private]

Definition at line 386 of file EventProcessor.h.

Referenced by beginJob(), connectSigs(), endJob(), init(), and ~EventProcessor().

bool edm::EventProcessor::alreadyHandlingException_ [private]

Definition at line 422 of file EventProcessor.h.

Referenced by alreadyHandlingException(), and runCommon().

std::auto_ptr<eventsetup::EventSetupProvider> edm::EventProcessor::esp_ [private]

Definition at line 392 of file EventProcessor.h.

Referenced by beginJob(), beginLumi(), beginRun(), endLumi(), endOfLoop(), endRun(), init(), prepareForNextLoop(), processEvent(), procOneEvent(), and ~EventProcessor().

boost::shared_ptr<boost::thread> edm::EventProcessor::event_loop_ [private]

Definition at line 396 of file EventProcessor.h.

Referenced by runAsync(), and waitForAsyncCompletion().

volatile pthread_t edm::EventProcessor::event_loop_id_ [private]

Definition at line 406 of file EventProcessor.h.

Referenced by asyncRun(), and waitForAsyncCompletion().

std::string edm::EventProcessor::exceptionMessageFiles_ [private]

Definition at line 419 of file EventProcessor.h.

Referenced by runCommon(), and setExceptionMessageFiles().

std::string edm::EventProcessor::exceptionMessageLumis_ [private]

Definition at line 421 of file EventProcessor.h.

Referenced by runCommon(), and setExceptionMessageLumis().

std::string edm::EventProcessor::exceptionMessageRuns_ [private]

Definition at line 420 of file EventProcessor.h.

Referenced by runCommon(), and setExceptionMessageRuns().

boost::shared_ptr<FileBlock> edm::EventProcessor::fb_ [private]

Definition at line 408 of file EventProcessor.h.

Referenced by openOutputFiles(), readFile(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), and respondToOpenOutputFiles().

std::string edm::EventProcessor::fileMode_ [private]

Definition at line 416 of file EventProcessor.h.

Referenced by init(), and runCommon().

bool edm::EventProcessor::forceLooperToEnd_ [private]

Definition at line 423 of file EventProcessor.h.

Referenced by endOfLoop(), runCommon(), and terminateMachine().

bool edm::EventProcessor::handleEmptyLumis_ [private]

Definition at line 418 of file EventProcessor.h.

Referenced by init(), and runCommon().

bool edm::EventProcessor::handleEmptyRuns_ [private]

Definition at line 417 of file EventProcessor.h.

Referenced by init(), and runCommon().

volatile bool edm::EventProcessor::id_set_ [private]

Definition at line 405 of file EventProcessor.h.

Referenced by asyncRun(), runAsync(), and waitForAsyncCompletion().

boost::shared_ptr<InputSource> edm::EventProcessor::input_ [private]

Definition at line 390 of file EventProcessor.h.

Referenced by beginJob(), closeInputFile(), doOneEvent(), endJob(), endLumi(), endRun(), init(), readAndCacheLumi(), readAndCacheRun(), readEvent(), readFile(), rewind(), rewindInput(), runCommon(), setRunNumber(), skip(), and ~EventProcessor().

std::string edm::EventProcessor::last_error_text_ [private]

Definition at line 404 of file EventProcessor.h.

Referenced by asyncRun().

volatile Status edm::EventProcessor::last_rc_ [private]

Definition at line 403 of file EventProcessor.h.

Referenced by asyncRun(), runAsync(), statusAsync(), and waitForAsyncCompletion().

boost::shared_ptr<EDLooper> edm::EventProcessor::looper_ [private]

Definition at line 409 of file EventProcessor.h.

Referenced by beginJob(), endJob(), endOfLoop(), init(), prepareForNextLoop(), processEvent(), startingNewLoop(), and ~EventProcessor().

std::auto_ptr<statemachine::Machine> edm::EventProcessor::machine_ [private]

Definition at line 411 of file EventProcessor.h.

Referenced by runCommon(), runToCompletion(), and terminateMachine().

ParameterSet edm::EventProcessor::maxEventsPset_ [private]

Definition at line 384 of file EventProcessor.h.

Referenced by init().

ParameterSet edm::EventProcessor::maxLumisPset_ [private]

Definition at line 385 of file EventProcessor.h.

Referenced by init().

int edm::EventProcessor::my_sig_num_ [private]

Definition at line 407 of file EventProcessor.h.

ActivityRegistry::PostProcessEvent edm::EventProcessor::postProcessEventSignal_ [private]

Definition at line 383 of file EventProcessor.h.

Referenced by connectSigs(), and postProcessEventSignal().

SignallingProductRegistry edm::EventProcessor::preg_ [private]

Definition at line 388 of file EventProcessor.h.

Referenced by init().

ActivityRegistry::PreProcessEvent edm::EventProcessor::preProcessEventSignal_ [private]

Definition at line 382 of file EventProcessor.h.

Referenced by connectSigs(), and preProcessEventSignal().

PrincipalCache edm::EventProcessor::principalCache_ [private]

Definition at line 412 of file EventProcessor.h.

Referenced by beginLumi(), beginRun(), deleteLumiFromCache(), deleteRunFromCache(), endLumi(), endRun(), readAndCacheLumi(), readAndCacheRun(), readEvent(), writeLumi(), writeLumiCache(), writeRun(), and writeRunCache().

std::auto_ptr<Schedule> edm::EventProcessor::schedule_ [private]

Definition at line 391 of file EventProcessor.h.

Referenced by beginJob(), beginLumi(), beginRun(), clearCounters(), closeOutputFiles(), enableEndPaths(), endJob(), endLumi(), endPathsEnabled(), endRun(), getAllModuleDescriptions(), getTriggerReport(), init(), openOutputFiles(), processEvent(), procOneEvent(), respondToCloseInputFile(), respondToCloseOutputFiles(), respondToOpenInputFile(), respondToOpenOutputFiles(), shouldWeCloseOutput(), shouldWeStop(), totalEvents(), totalEventsFailed(), totalEventsPassed(), writeLumi(), writeLumiCache(), writeRun(), writeRunCache(), and ~EventProcessor().

ServiceToken edm::EventProcessor::serviceToken_ [private]

Definition at line 389 of file EventProcessor.h.

Referenced by beginJob(), endJob(), getToken(), init(), rewind(), run(), runCommon(), and skip().

bool edm::EventProcessor::shouldWeStop_ [private]

Definition at line 414 of file EventProcessor.h.

Referenced by processEvent(), shouldWeStop(), and startingNewLoop().

std::auto_ptr<EventPrincipal> edm::EventProcessor::sm_evp_ [private]

Definition at line 413 of file EventProcessor.h.

Referenced by processEvent(), and readEvent().

boost::condition edm::EventProcessor::starter_ [private]

Definition at line 401 of file EventProcessor.h.

Referenced by asyncRun(), and runAsync().

volatile event_processor::State edm::EventProcessor::state_ [private]

Definition at line 395 of file EventProcessor.h.

Referenced by beginJob(), changeState(), errorState(), getState(), and runCommon().

boost::mutex edm::EventProcessor::state_lock_ [private]

Definition at line 398 of file EventProcessor.h.

Referenced by changeState().

bool edm::EventProcessor::stateMachineWasInErrorState_ [private]

Definition at line 415 of file EventProcessor.h.

Referenced by doErrorStuff(), and runCommon().

volatile int edm::EventProcessor::stop_count_ [private]

Definition at line 402 of file EventProcessor.h.

Referenced by asyncRun(), runAsync(), and waitForAsyncCompletion().

boost::mutex edm::EventProcessor::stop_lock_ [private]

Definition at line 399 of file EventProcessor.h.

Referenced by asyncRun(), runAsync(), and waitForAsyncCompletion().

boost::condition edm::EventProcessor::stopper_ [private]

Definition at line 400 of file EventProcessor.h.

Referenced by asyncRun(), and waitForAsyncCompletion().

WorkerRegistry edm::EventProcessor::wreg_ [private]

Definition at line 387 of file EventProcessor.h.

Referenced by init(), and ~EventProcessor().

---

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

• FWCore/Framework/interface/EventProcessor.h
• FWCore/Framework/src/EventProcessor.cc

---