edm::PrincipalCache Class Reference

#include <PrincipalCache.h>

Public Types
enum	ProcessBlockType { ProcessBlockType::New, ProcessBlockType::Input }

Public Member Functions
void	adjustEventsToNewProductRegistry (std::shared_ptr< ProductRegistry const >)
void	adjustIndexesAfterProductRegistryAddition ()
EventPrincipal &	eventPrincipal (unsigned int iStreamIndex) const
std::shared_ptr< LuminosityBlockPrincipal >	getAvailableLumiPrincipalPtr ()
std::shared_ptr< RunPrincipal >	getAvailableRunPrincipalPtr ()
ProcessBlockPrincipal &	inputProcessBlockPrincipal () const
void	insert (std::unique_ptr< ProcessBlockPrincipal >)
void	insert (std::unique_ptr< RunPrincipal >)
void	insert (std::unique_ptr< LuminosityBlockPrincipal >)
void	insert (std::shared_ptr< EventPrincipal >)
void	insertForInput (std::unique_ptr< ProcessBlockPrincipal >)
	PrincipalCache ()
	PrincipalCache (PrincipalCache &&)=default
ProcessBlockPrincipal &	processBlockPrincipal () const
ProcessBlockPrincipal &	processBlockPrincipal (ProcessBlockType processBlockType) const
void	setNumberOfConcurrentPrincipals (PreallocationConfiguration const &)
	~PrincipalCache ()

Private Attributes
std::vector< std::shared_ptr< EventPrincipal > >	eventPrincipals_
std::unique_ptr< ProcessBlockPrincipal >	inputProcessBlockPrincipal_
edm::ReusableObjectHolder< LuminosityBlockPrincipal >	lumiHolder_
std::unique_ptr< ProcessBlockPrincipal >	processBlockPrincipal_
edm::ReusableObjectHolder< RunPrincipal >	runHolder_

Detailed Description

Definition at line 28 of file PrincipalCache.h.

Member Enumeration Documentation

ProcessBlockType

enum edm::PrincipalCache::ProcessBlockType

strong

Enumerator
New
Input

Definition at line 37 of file PrincipalCache.h.

{ New, Input };

Constructor & Destructor Documentation

PrincipalCache() [1/2]

edm::PrincipalCache::PrincipalCache

(

)

Definition at line 13 of file PrincipalCache.cc.

{}

~PrincipalCache()

edm::PrincipalCache::~PrincipalCache

(

)

Definition at line 15 of file PrincipalCache.cc.

{}

PrincipalCache() [2/2]

edm::PrincipalCache::PrincipalCache ( PrincipalCache &&  )

default

Member Function Documentation

adjustEventsToNewProductRegistry()

void edm::PrincipalCache::adjustEventsToNewProductRegistry

(

std::shared_ptr< ProductRegistry const >

reg

)

Definition at line 43 of file PrincipalCache.cc.

References edm::Principal::adjustIndexesAfterProductRegistryAddition(), edm::Principal::adjustToNewProductRegistry(), cms::cuda::assert(), eventPrincipal(), and eventPrincipals_.

Referenced by edm::EventProcessor::readFile().

                                                                                                {
    for (auto& eventPrincipal : eventPrincipals_) {
      if (eventPrincipal) {
        eventPrincipal->adjustIndexesAfterProductRegistryAddition();
        bool eventOK = eventPrincipal->adjustToNewProductRegistry(*reg);
        assert(eventOK);
      }
    }
  }

adjustIndexesAfterProductRegistryAddition()

void edm::PrincipalCache::adjustIndexesAfterProductRegistryAddition

(

)

Definition at line 53 of file PrincipalCache.cc.

References lumiHolder_, eostools::move(), AlCaHLTBitMon_ParallelJobs::p, and runHolder_.

Referenced by edm::EventProcessor::readFile().

                                                                 {
    //Need to temporarily hold all the runs to clear out the runHolder_
    std::vector<std::shared_ptr<RunPrincipal>> tempRunPrincipals;
    while (auto p = runHolder_.tryToGet()) {
      p->adjustIndexesAfterProductRegistryAddition();
      tempRunPrincipals.emplace_back(std::move(p));
    }
    //Need to temporarily hold all the lumis to clear out the lumiHolder_
    std::vector<std::shared_ptr<LuminosityBlockPrincipal>> tempLumiPrincipals;
    while (auto p = lumiHolder_.tryToGet()) {
      p->adjustIndexesAfterProductRegistryAddition();
      tempLumiPrincipals.emplace_back(std::move(p));
    }
  }

eventPrincipal()

EventPrincipal& edm::PrincipalCache::eventPrincipal ( unsigned int  iStreamIndex ) const

inline

Definition at line 45 of file PrincipalCache.h.

References eventPrincipals_.

Referenced by adjustEventsToNewProductRegistry(), edm::EventProcessor::beginLumiAsync(), edm::test::TestProcessor::event(), edm::SubProcess::processAsync(), edm::EventProcessor::processEventAsyncImpl(), edm::EventProcessor::readEvent(), and edm::test::TestProcessor::testImpl().

{ return *(eventPrincipals_[iStreamIndex]); }

getAvailableLumiPrincipalPtr()

std::shared_ptr< LuminosityBlockPrincipal > edm::PrincipalCache::getAvailableLumiPrincipalPtr

(

)

Definition at line 19 of file PrincipalCache.cc.

References lumiHolder_.

Referenced by edm::test::TestProcessor::beginLuminosityBlock(), edm::SubProcess::doBeginLuminosityBlockAsync(), and edm::EventProcessor::readLuminosityBlock().

                                                                                       {
    return lumiHolder_.tryToGet();
  }

getAvailableRunPrincipalPtr()

std::shared_ptr< RunPrincipal > edm::PrincipalCache::getAvailableRunPrincipalPtr

(

)

Definition at line 17 of file PrincipalCache.cc.

References runHolder_.

Referenced by edm::test::TestProcessor::beginRun(), edm::SubProcess::doBeginRunAsync(), and edm::EventProcessor::readRun().

{ return runHolder_.tryToGet(); }

inputProcessBlockPrincipal()

ProcessBlockPrincipal& edm::PrincipalCache::inputProcessBlockPrincipal ( ) const

inline

Definition at line 35 of file PrincipalCache.h.

References inputProcessBlockPrincipal_.

Referenced by edm::SubProcess::doBeginProcessBlockAsync(), edm::SubProcess::doEndProcessBlockAsync(), and edm::EventProcessor::inputProcessBlocks().

{ return *inputProcessBlockPrincipal_; }

insert() [1/4]

void edm::PrincipalCache::insert

(

std::unique_ptr< ProcessBlockPrincipal >

pb

)

Definition at line 27 of file PrincipalCache.cc.

References eostools::move(), and processBlockPrincipal_.

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly(), edm::EventProcessor::init(), edm::SubProcess::SubProcess(), and edm::test::TestProcessor::TestProcessor().

{ processBlockPrincipal_ = std::move(pb); }

insert() [2/4]

void edm::PrincipalCache::insert

(

std::unique_ptr< RunPrincipal >

rp

)

Definition at line 33 of file PrincipalCache.cc.

References eostools::move(), and runHolder_.

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly().

{ runHolder_.add(std::move(rp)); }

insert() [3/4]

void edm::PrincipalCache::insert

(

std::unique_ptr< LuminosityBlockPrincipal >

lbp

)

Definition at line 35 of file PrincipalCache.cc.

References lumiHolder_, and eostools::move().

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly().

{ lumiHolder_.add(std::move(lbp)); }

insert() [4/4]

void edm::PrincipalCache::insert

(

std::shared_ptr< EventPrincipal >

ep

)

Definition at line 37 of file PrincipalCache.cc.

References cms::cuda::assert(), SiStripBadComponentsDQMServiceTemplate_cfg::ep, and eventPrincipals_.

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly().

                                                              {
    unsigned int iStreamIndex = ep->streamID().value();
    assert(iStreamIndex < eventPrincipals_.size());
    eventPrincipals_[iStreamIndex] = ep;
  }

insertForInput()

void edm::PrincipalCache::insertForInput

(

std::unique_ptr< ProcessBlockPrincipal >

pb

)

Definition at line 29 of file PrincipalCache.cc.

References inputProcessBlockPrincipal_, and eostools::move().

Referenced by edm::EventProcessor::init(), and edm::SubProcess::SubProcess().

                                                                             {
    inputProcessBlockPrincipal_ = std::move(pb);
  }

processBlockPrincipal() [1/2]

ProcessBlockPrincipal& edm::PrincipalCache::processBlockPrincipal ( ) const

inline

Definition at line 34 of file PrincipalCache.h.

References processBlockPrincipal_.

Referenced by edm::EventProcessor::beginProcessBlock(), edm::test::TestProcessor::beginProcessBlock(), edm::SubProcess::clearProcessBlockPrincipal(), edm::SubProcess::doBeginProcessBlockAsync(), edm::SubProcess::doEndProcessBlockAsync(), edm::EventProcessor::endProcessBlock(), edm::test::TestProcessor::endProcessBlock(), edm::test::TestProcessor::testBeginProcessBlockImpl(), edm::SubProcess::writeProcessBlockAsync(), and edm::EventProcessor::writeProcessBlockAsync().

{ return *processBlockPrincipal_; }

processBlockPrincipal() [2/2]

ProcessBlockPrincipal& edm::PrincipalCache::processBlockPrincipal ( ProcessBlockType  processBlockType ) const

inline

Definition at line 38 of file PrincipalCache.h.

References Input, inputProcessBlockPrincipal_, and processBlockPrincipal_.

                                                                                          {
      return processBlockType == ProcessBlockType::Input ? *inputProcessBlockPrincipal_ : *processBlockPrincipal_;
    }

setNumberOfConcurrentPrincipals()

void edm::PrincipalCache::setNumberOfConcurrentPrincipals

(

PreallocationConfiguration const &

iConfig

)

Definition at line 23 of file PrincipalCache.cc.

References eventPrincipals_, and edm::PreallocationConfiguration::numberOfStreams().

Referenced by edm::EventProcessor::init(), edm::SubProcess::SubProcess(), and edm::test::TestProcessor::TestProcessor().

                                                                                                {
    eventPrincipals_.resize(iConfig.numberOfStreams());
  }

Member Data Documentation

eventPrincipals_

std::vector<std::shared_ptr<EventPrincipal> > edm::PrincipalCache::eventPrincipals_

private

Definition at line 63 of file PrincipalCache.h.

Referenced by adjustEventsToNewProductRegistry(), eventPrincipal(), insert(), and setNumberOfConcurrentPrincipals().

inputProcessBlockPrincipal_

std::unique_ptr<ProcessBlockPrincipal> edm::PrincipalCache::inputProcessBlockPrincipal_

private

Definition at line 60 of file PrincipalCache.h.

Referenced by inputProcessBlockPrincipal(), insertForInput(), and processBlockPrincipal().

lumiHolder_

edm::ReusableObjectHolder<LuminosityBlockPrincipal> edm::PrincipalCache::lumiHolder_

private

Definition at line 62 of file PrincipalCache.h.

Referenced by adjustIndexesAfterProductRegistryAddition(), getAvailableLumiPrincipalPtr(), and insert().

processBlockPrincipal_

std::unique_ptr<ProcessBlockPrincipal> edm::PrincipalCache::processBlockPrincipal_

private

Definition at line 59 of file PrincipalCache.h.

Referenced by insert(), and processBlockPrincipal().

runHolder_

edm::ReusableObjectHolder<RunPrincipal> edm::PrincipalCache::runHolder_

private

Definition at line 61 of file PrincipalCache.h.

Referenced by adjustIndexesAfterProductRegistryAddition(), getAvailableRunPrincipalPtr(), and insert().