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 > reg)
void	adjustIndexesAfterProductRegistryAddition ()
void	deleteRun (ProcessHistoryID const &phid, RunNumber_t run)
EventPrincipal &	eventPrincipal (unsigned int iStreamIndex) const
std::shared_ptr< LuminosityBlockPrincipal >	getAvailableLumiPrincipalPtr ()
bool	hasRunPrincipal () const
ProcessBlockPrincipal &	inputProcessBlockPrincipal () const
void	insert (std::shared_ptr< EventPrincipal > ep)
void	insert (std::shared_ptr< RunPrincipal > rp)
void	insert (std::unique_ptr< LuminosityBlockPrincipal > lbp)
void	insert (std::unique_ptr< ProcessBlockPrincipal >)
void	insertForInput (std::unique_ptr< ProcessBlockPrincipal >)
void	merge (std::shared_ptr< RunAuxiliary > aux, std::shared_ptr< ProductRegistry const > reg)
void	preReadFile ()
	PrincipalCache ()
	PrincipalCache (PrincipalCache &&)=default
ProcessBlockPrincipal &	processBlockPrincipal () const
ProcessBlockPrincipal &	processBlockPrincipal (ProcessBlockType processBlockType) const
RunPrincipal &	runPrincipal () const
RunPrincipal &	runPrincipal (ProcessHistoryID const &phid, RunNumber_t run) const
std::shared_ptr< RunPrincipal > const &	runPrincipalPtr () const
std::shared_ptr< RunPrincipal > const &	runPrincipalPtr (ProcessHistoryID const &phid, RunNumber_t run) const
void	setNumberOfConcurrentPrincipals (PreallocationConfiguration const &)
void	setProcessHistoryRegistry (ProcessHistoryRegistry const &phr)
	~PrincipalCache ()

Private Member Functions
void	throwLumiMissing () const
void	throwRunMissing () const

Private Attributes
std::vector< std::shared_ptr< EventPrincipal > >	eventPrincipals_
std::unique_ptr< ProcessBlockPrincipal >	inputProcessBlockPrincipal_
ProcessHistoryID	inputProcessHistoryID_
LuminosityBlockNumber_t	lumi_
edm::ReusableObjectHolder< LuminosityBlockPrincipal >	lumiHolder_
std::unique_ptr< ProcessBlockPrincipal >	processBlockPrincipal_
ProcessHistoryRegistry const *	processHistoryRegistry_
ProcessHistoryID	reducedInputProcessHistoryID_
RunNumber_t	run_
std::shared_ptr< RunPrincipal >	runPrincipal_

Detailed Description

Definition at line 48 of file PrincipalCache.h.

Member Enumeration Documentation

ProcessBlockType

enum edm::PrincipalCache::ProcessBlockType

strong

Enumerator
New
Input

Definition at line 57 of file PrincipalCache.h.

{ New, Input };

Constructor & Destructor Documentation

PrincipalCache() [1/2]

edm::PrincipalCache::PrincipalCache

(

)

Definition at line 13 of file PrincipalCache.cc.

: run_(0U), lumi_(0U) {}

~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 127 of file PrincipalCache.cc.

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

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

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

adjustIndexesAfterProductRegistryAddition()

void edm::PrincipalCache::adjustIndexesAfterProductRegistryAddition

(

)

Definition at line 137 of file PrincipalCache.cc.

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

References lumiHolder_, eostools::move(), AlCaHLTBitMon_ParallelJobs::p, runPrincipal_, and groupFilesInBlocks::temp.

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

deleteRun()

void edm::PrincipalCache::deleteRun	(	ProcessHistoryID const &	phid,
		RunNumber_t	run
	)

Definition at line 110 of file PrincipalCache.cc.

                                                                              {
    if (runPrincipal_.get() == nullptr) {
      throw edm::Exception(edm::errors::LogicError) << "PrincipalCache::deleteRun\n"
                                                    << "Illegal attempt to delete run from cache\n"
                                                    << "There is no run in cache to delete\n"
                                                    << "Contact a Framework Developer\n";
    }
    if (reducedInputProcessHistoryID_ != phid || run != run_) {
      throw edm::Exception(edm::errors::LogicError)
          << "PrincipalCache::deleteRun\n"
          << "Illegal attempt to delete run from cache\n"
          << "Run number or reduced ProcessHistoryID inconsistent with those in cache\n"
          << "Contact a Framework Developer\n";
    }
    runPrincipal_.reset();
  }

References Exception, edm::errors::LogicError, reducedInputProcessHistoryID_, writedatasetfile::run, run_, and runPrincipal_.

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

eventPrincipal()

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

inline

Definition at line 70 of file PrincipalCache.h.

{ return *(eventPrincipals_[iStreamIndex]); }

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().

getAvailableLumiPrincipalPtr()

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

(

)

Definition at line 50 of file PrincipalCache.cc.

                                                                                       {
    return lumiHolder_.tryToGet();
  }

References lumiHolder_.

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

hasRunPrincipal()

bool edm::PrincipalCache::hasRunPrincipal ( ) const

inline

Definition at line 66 of file PrincipalCache.h.

{ return bool(runPrincipal_); }

References electrons_cff::bool, and runPrincipal_.

Referenced by edm::EventProcessor::readLuminosityBlock(), and edm::EventProcessor::readRun().

inputProcessBlockPrincipal()

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

inline

Definition at line 55 of file PrincipalCache.h.

{ return *inputProcessBlockPrincipal_; }

References inputProcessBlockPrincipal_.

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

insert() [1/4]

void edm::PrincipalCache::insert

(

std::shared_ptr< EventPrincipal >

ep

)

Definition at line 104 of file PrincipalCache.cc.

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

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

insert() [2/4]

void edm::PrincipalCache::insert

(

std::shared_ptr< RunPrincipal >

rp

)

Definition at line 82 of file PrincipalCache.cc.

                                                            {
    if (runPrincipal_.get() != nullptr) {
      throw edm::Exception(edm::errors::LogicError) << "PrincipalCache::insert\n"
                                                    << "Illegal attempt to insert run into cache\n"
                                                    << "Contact a Framework Developer\n";
    }
    if (inputProcessHistoryID_ != rp->aux().processHistoryID()) {
      reducedInputProcessHistoryID_ = processHistoryRegistry_->reducedProcessHistoryID(rp->aux().processHistoryID());
      inputProcessHistoryID_ = rp->aux().processHistoryID();
    }
    run_ = rp->run();
    runPrincipal_ = rp;
  }

References Exception, inputProcessHistoryID_, edm::errors::LogicError, processHistoryRegistry_, reducedInputProcessHistoryID_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), run_, and runPrincipal_.

insert() [3/4]

void edm::PrincipalCache::insert

(

std::unique_ptr< LuminosityBlockPrincipal >

lbp

)

Definition at line 102 of file PrincipalCache.cc.

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

References lumiHolder_, and eostools::move().

insert() [4/4]

void edm::PrincipalCache::insert

(

std::unique_ptr< ProcessBlockPrincipal >

pb

)

Definition at line 96 of file PrincipalCache.cc.

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

References eostools::move(), and processBlockPrincipal_.

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

insertForInput()

void edm::PrincipalCache::insertForInput

(

std::unique_ptr< ProcessBlockPrincipal >

pb

)

Definition at line 98 of file PrincipalCache.cc.

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

References inputProcessBlockPrincipal_, and eostools::move().

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

merge()

void edm::PrincipalCache::merge	(	std::shared_ptr< RunAuxiliary >	aux,
		std::shared_ptr< ProductRegistry const >	reg
	)

Definition at line 54 of file PrincipalCache.cc.

                                                                                                      {
    if (runPrincipal_.get() == nullptr) {
      throw edm::Exception(edm::errors::LogicError) << "PrincipalCache::merge\n"
                                                    << "Illegal attempt to merge run into cache\n"
                                                    << "There is no run in cache to merge with\n"
                                                    << "Contact a Framework Developer\n";
    }
    if (inputProcessHistoryID_ != aux->processHistoryID()) {
      if (reducedInputProcessHistoryID_ != processHistoryRegistry_->reducedProcessHistoryID(aux->processHistoryID())) {
        throw edm::Exception(edm::errors::LogicError)
            << "PrincipalCache::merge\n"
            << "Illegal attempt to merge run into cache\n"
            << "Reduced ProcessHistoryID inconsistent with the one already in cache\n"
            << "Contact a Framework Developer\n";
      }
      inputProcessHistoryID_ = aux->processHistoryID();
    }
    if (aux->run() != run_) {
      throw edm::Exception(edm::errors::LogicError) << "PrincipalCache::merge\n"
                                                    << "Illegal attempt to merge run into cache\n"
                                                    << "Run number inconsistent with run number already in cache\n"
                                                    << "Contact a Framework Developer\n";
    }
    bool runOK = runPrincipal_->adjustToNewProductRegistry(*reg);
    assert(runOK);
    runPrincipal_->mergeAuxiliary(*aux);
  }

References cms::cuda::assert(), printConversionInfo::aux, Exception, inputProcessHistoryID_, edm::errors::LogicError, processHistoryRegistry_, reducedInputProcessHistoryID_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), run_, and runPrincipal_.

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

preReadFile()

void edm::PrincipalCache::preReadFile

(

)

Definition at line 149 of file PrincipalCache.cc.

                                   {
    if (runPrincipal_) {
      runPrincipal_->preReadFile();
    }
  }

References runPrincipal_.

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

processBlockPrincipal() [1/2]

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

inline

Definition at line 54 of file PrincipalCache.h.

{ return *processBlockPrincipal_; }

References processBlockPrincipal_.

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

processBlockPrincipal() [2/2]

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

inline

Definition at line 58 of file PrincipalCache.h.

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

References Input, inputProcessBlockPrincipal_, and processBlockPrincipal_.

runPrincipal() [1/2]

RunPrincipal & edm::PrincipalCache::runPrincipal

(

)

const

Definition at line 36 of file PrincipalCache.cc.

                                                   {
    if (runPrincipal_.get() == nullptr) {
      throwRunMissing();
    }
    return *runPrincipal_.get();
  }

References runPrincipal_, and throwRunMissing().

runPrincipal() [2/2]

RunPrincipal & edm::PrincipalCache::runPrincipal	(	ProcessHistoryID const &	phid,
		RunNumber_t	run
	)		const

Definition at line 21 of file PrincipalCache.cc.

                                                                                                {
    if (phid != reducedInputProcessHistoryID_ || run != run_ || runPrincipal_.get() == nullptr) {
      throwRunMissing();
    }
    return *runPrincipal_.get();
  }

References reducedInputProcessHistoryID_, writedatasetfile::run, run_, runPrincipal_, and throwRunMissing().

Referenced by edm::EventProcessor::beginRun(), edm::test::TestProcessor::beginRun(), edm::EventProcessor::endRun(), edm::EventProcessor::endUnfinishedRun(), edm::SubProcess::writeRunAsync(), and edm::EventProcessor::writeRunAsync().

runPrincipalPtr() [1/2]

std::shared_ptr< RunPrincipal > const & edm::PrincipalCache::runPrincipalPtr

(

)

const

Definition at line 43 of file PrincipalCache.cc.

                                                                           {
    if (runPrincipal_.get() == nullptr) {
      throwRunMissing();
    }
    return runPrincipal_;
  }

References runPrincipal_, and throwRunMissing().

runPrincipalPtr() [2/2]

std::shared_ptr< RunPrincipal > const & edm::PrincipalCache::runPrincipalPtr	(	ProcessHistoryID const &	phid,
		RunNumber_t	run
	)		const

Definition at line 28 of file PrincipalCache.cc.

                                                                                              {
    if (phid != reducedInputProcessHistoryID_ || run != run_ || runPrincipal_.get() == nullptr) {
      throwRunMissing();
    }
    return runPrincipal_;
  }

References reducedInputProcessHistoryID_, writedatasetfile::run, run_, runPrincipal_, and throwRunMissing().

Referenced by edm::test::TestProcessor::beginLuminosityBlock(), edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doBeginRunAsync(), edm::SubProcess::doEndRunAsync(), edm::SubProcess::doStreamBeginRunAsync(), edm::SubProcess::doStreamEndRunAsync(), edm::test::TestProcessor::endRun(), edm::EventProcessor::readAndMergeRun(), edm::EventProcessor::readLuminosityBlock(), and edm::test::TestProcessor::testBeginRunImpl().

setNumberOfConcurrentPrincipals()

void edm::PrincipalCache::setNumberOfConcurrentPrincipals

(

PreallocationConfiguration const &

iConfig

)

Definition at line 17 of file PrincipalCache.cc.

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

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

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

setProcessHistoryRegistry()

void edm::PrincipalCache::setProcessHistoryRegistry ( ProcessHistoryRegistry const &  phr )

inline

Definition at line 87 of file PrincipalCache.h.

{ processHistoryRegistry_ = &phr; }

References processHistoryRegistry_.

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

throwLumiMissing()

void edm::PrincipalCache::throwLumiMissing ( ) const

private

Definition at line 161 of file PrincipalCache.cc.

                                              {
    throw edm::Exception(edm::errors::LogicError)
        << "PrincipalCache::lumiPrincipal or PrincipalCache::lumiPrincipalPtr\n"
        << "Requested a luminosity block that is not in the cache (should never happen)\n"
        << "Contact a Framework Developer\n";
  }

References Exception, and edm::errors::LogicError.

throwRunMissing()

void edm::PrincipalCache::throwRunMissing ( ) const

private

Definition at line 155 of file PrincipalCache.cc.

                                             {
    throw edm::Exception(edm::errors::LogicError) << "PrincipalCache::runPrincipal\n"
                                                  << "Requested a run that is not in the cache (should never happen)\n"
                                                  << "Contact a Framework Developer\n";
  }

References Exception, and edm::errors::LogicError.

Referenced by runPrincipal(), and runPrincipalPtr().

Member Data Documentation

eventPrincipals_

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

private

Definition at line 101 of file PrincipalCache.h.

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

inputProcessBlockPrincipal_

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

private

Definition at line 98 of file PrincipalCache.h.

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

inputProcessHistoryID_

ProcessHistoryID edm::PrincipalCache::inputProcessHistoryID_

private

Definition at line 113 of file PrincipalCache.h.

Referenced by insert(), and merge().

lumi_

LuminosityBlockNumber_t edm::PrincipalCache::lumi_

private

Definition at line 116 of file PrincipalCache.h.

lumiHolder_

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

private

Definition at line 100 of file PrincipalCache.h.

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

processBlockPrincipal_

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

private

Definition at line 97 of file PrincipalCache.h.

Referenced by insert(), and processBlockPrincipal().

processHistoryRegistry_

ProcessHistoryRegistry const* edm::PrincipalCache::processHistoryRegistry_

private

Definition at line 104 of file PrincipalCache.h.

Referenced by insert(), merge(), and setProcessHistoryRegistry().

reducedInputProcessHistoryID_

ProcessHistoryID edm::PrincipalCache::reducedInputProcessHistoryID_

private

Definition at line 114 of file PrincipalCache.h.

Referenced by deleteRun(), insert(), merge(), runPrincipal(), and runPrincipalPtr().

run_

RunNumber_t edm::PrincipalCache::run_

private

Definition at line 115 of file PrincipalCache.h.

Referenced by deleteRun(), insert(), merge(), runPrincipal(), and runPrincipalPtr().

runPrincipal_

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

private

Definition at line 99 of file PrincipalCache.h.

Referenced by adjustIndexesAfterProductRegistryAddition(), deleteRun(), hasRunPrincipal(), insert(), merge(), preReadFile(), runPrincipal(), and runPrincipalPtr().