edm::ProcessBlockHelper Class Reference

#include <ProcessBlockHelper.h>

Inheritance diagram for edm::ProcessBlockHelper:

Public Member Functions
std::vector< unsigned int > const &	cacheEntriesPerFile () const final
std::vector< unsigned int > const &	cacheIndexVectorsPerFile () const final
void	clearAfterOutputFilesClose ()
bool	dropProcessesAndReorderStored (StoredProcessBlockHelper &storedProcessBlockHelper, std::set< std::string > const &processesToKeep, std::vector< unsigned int > const &nEntries, std::vector< unsigned int > &finalIndexToStoredIndex, std::vector< std::string > const &firstFileFinalProcesses) const
void	fillFromPrimaryInput (StoredProcessBlockHelper const &storedProcessBlockHelper, std::vector< unsigned int > const &nEntries)
bool	firstFileDropProcessesAndReorderStored (StoredProcessBlockHelper &storedProcessBlockHelper, std::set< std::string > const &processesToKeep, std::vector< unsigned int > const &nEntries, std::vector< unsigned int > &finalIndexToStoredIndex) const
bool	initializedFromInput () const
void	initializeFromPrimaryInput (StoredProcessBlockHelper const &storedProcessBlockHelper)
std::vector< std::vector < unsigned int > > const &	nEntries () const final
unsigned int	nProcessesInFirstFile () const final
unsigned int	outerOffset () const final
std::vector< std::vector < unsigned int > > const &	processBlockCacheIndices () const final
unsigned int	processBlockIndex (std::string const &processName, EventToProcessBlockIndexes const &) const final
ProcessBlockHelperBase const *	topProcessBlockHelper () const final
std::vector< std::string > const &	topProcessesWithProcessBlockProducts () const final
Public Member Functions inherited from edm::ProcessBlockHelperBase
std::vector< std::string > const &	addedProcesses () const
void	emplaceBackAddedProcessName (std::string const &processName)
void	emplaceBackProcessName (std::string const &processName)
std::vector< std::string > const &	processesWithProcessBlockProducts () const
std::string	selectProcess (ProductRegistry const &, ProductLabels const &, TypeID const &) const
void	setAddedProcesses (std::vector< std::string > const &val)
void	setProcessesWithProcessBlockProducts (std::vector< std::string > const &val)
void	updateForNewProcess (ProductRegistry const &, std::string const &processName)
virtual	~ProcessBlockHelperBase ()

Private Member Functions
void	dropProcessesAndReorderStoredImpl (StoredProcessBlockHelper &storedProcessBlockHelper, std::vector< std::string > &finalProcesses, std::vector< unsigned int > const &nEntries, std::vector< unsigned int > const &finalIndexToStoredIndex) const
void	fillEntriesFromPrimaryInput (std::vector< unsigned int > nEntries)
void	fillFromPrimaryInputWhenNotEmpty (std::vector< std::string > const &storedProcesses, std::vector< unsigned int > const &storedCacheIndices, std::vector< unsigned int > const &nEntries)

Private Attributes
std::vector< unsigned int >	cacheEntriesPerFile_
unsigned int	cacheIndexOffset_ = 0
std::vector< unsigned int >	cacheIndexVectorsPerFile_
bool	initializedFromInput_ = false
std::vector< std::vector < unsigned int > >	nEntries_
unsigned int	nProcessesInFirstFile_ = 0
unsigned int	outerOffset_ = 0
std::vector< std::vector < unsigned int > >	processBlockCacheIndices_

Additional Inherited Members
Static Public Member Functions inherited from edm::ProcessBlockHelperBase
static constexpr unsigned int	invalidCacheIndex ()
static constexpr unsigned int	invalidProcessIndex ()

Detailed Description

Author

W. David Dagenhart, created 15 September, 2020

Definition at line 19 of file ProcessBlockHelper.h.

Member Function Documentation

std::vector< unsigned int > const & edm::ProcessBlockHelper::cacheEntriesPerFile ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 30 of file ProcessBlockHelper.cc.

References cacheEntriesPerFile_.

{ return cacheEntriesPerFile_; }

std::vector< unsigned int > const & edm::ProcessBlockHelper::cacheIndexVectorsPerFile ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 26 of file ProcessBlockHelper.cc.

References cacheIndexVectorsPerFile_.

                                                                                    {
    return cacheIndexVectorsPerFile_;
  }

void edm::ProcessBlockHelper::clearAfterOutputFilesClose

(

)

Definition at line 158 of file ProcessBlockHelper.cc.

References cacheEntriesPerFile_, cacheIndexOffset_, cacheIndexVectorsPerFile_, nEntries_, outerOffset_, and processBlockCacheIndices_.

                                                      {
    processBlockCacheIndices_.clear();
    nEntries_.clear();
    cacheIndexVectorsPerFile_.clear();
    cacheEntriesPerFile_.clear();
    outerOffset_ = 0;
    cacheIndexOffset_ = 0;
  }

bool edm::ProcessBlockHelper::dropProcessesAndReorderStored	(	StoredProcessBlockHelper &	storedProcessBlockHelper,
		std::set< std::string > const &	processesToKeep,
		std::vector< unsigned int > const &	nEntries,
		std::vector< unsigned int > &	finalIndexToStoredIndex,
		std::vector< std::string > const &	firstFileFinalProcesses
	)		const

Definition at line 83 of file ProcessBlockHelper.cc.

References dropProcessesAndReorderStoredImpl(), edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::RootFile::dropProcessesAndReorder().

                                                                                                                    {
    std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();

    std::vector<std::string> finalProcesses;
    // Always will allocate enough space (sometimes too much)
    finalProcesses.reserve(storedProcesses.size());
    finalIndexToStoredIndex.reserve(storedProcesses.size());

    // The outer loop here establishes the order
    // Only allows processes that got into finalProcesses for the first file
    for (unsigned int iFirst = 0; iFirst < firstFileFinalProcesses.size(); ++iFirst) {
      // Only includes processes also in storedProcesses
      for (unsigned int iStored = 0; iStored < storedProcesses.size(); ++iStored) {
        std::string const& storedProcess = storedProcesses[iStored];
        if (firstFileFinalProcesses[iFirst] == storedProcess) {
          // Also requires processes have kept ProcessBlock products
          if (processesToKeep.find(storedProcess) != processesToKeep.end()) {
            finalProcesses.emplace_back(storedProcess);
            finalIndexToStoredIndex.emplace_back(iStored);
            break;
          }
        }
      }
    }

    bool isModified = true;
    if (storedProcesses == finalProcesses) {
      isModified = false;
      return isModified;
    }

    dropProcessesAndReorderStoredImpl(storedProcessBlockHelper, finalProcesses, nEntries, finalIndexToStoredIndex);
    return isModified;
  }

void edm::ProcessBlockHelper::dropProcessesAndReorderStoredImpl ( StoredProcessBlockHelper &  storedProcessBlockHelper, std::vector< std::string > &  finalProcesses, std::vector< unsigned int > const &  nEntries, std::vector< unsigned int > const &  finalIndexToStoredIndex  ) const

private

Definition at line 170 of file ProcessBlockHelper.cc.

References cms::cuda::assert(), edm::ProcessBlockHelperBase::invalidCacheIndex(), dqmiolumiharvest::j, isotrackApplyRegressor::k, eostools::move(), hltrates_dqm_sourceclient-live_cfg::offset, edm::StoredProcessBlockHelper::processBlockCacheIndices(), edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), edm::StoredProcessBlockHelper::setProcessBlockCacheIndices(), and edm::StoredProcessBlockHelper::setProcessesWithProcessBlockProducts().

Referenced by dropProcessesAndReorderStored(), and firstFileDropProcessesAndReorderStored().

                                                                    {
    std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();
    std::vector<unsigned int> const& storedCacheIndices = storedProcessBlockHelper.processBlockCacheIndices();

    assert(!storedProcesses.empty());
    std::vector<unsigned int> newCacheIndices;
    if (!finalProcesses.empty()) {
      // ProcessBlocks are read in the order of storedProcesses and within
      // each process in entry order in the TTree.  This establishes the cache
      // order that the values in storedCacheIndices refer to. The "offset" refers
      // to cache index value of the first ProcessBlock in a TTree.
      std::vector<unsigned int> oldOffsets;
      oldOffsets.reserve(storedProcesses.size());
      unsigned int offset = 0;
      for (auto const& entries : nEntries) {
        oldOffsets.emplace_back(offset);
        offset += entries;
      }

      unsigned int nFinalProcesses = finalProcesses.size();
      std::vector<unsigned int> newOffsets;
      newOffsets.reserve(nFinalProcesses);
      offset = 0;
      for (unsigned int iNew = 0; iNew < nFinalProcesses; ++iNew) {
        newOffsets.emplace_back(offset);
        offset += nEntries[finalIndexToStoredIndex[iNew]];
      }

      unsigned int nOuterLoop = storedCacheIndices.size() / storedProcesses.size();
      assert(nOuterLoop * storedProcesses.size() == storedCacheIndices.size());
      newCacheIndices.reserve(nOuterLoop * nFinalProcesses);
      unsigned int storedOuterOffset = 0;

      for (unsigned int k = 0; k < nOuterLoop; ++k) {
        for (unsigned int j = 0; j < nFinalProcesses; ++j) {
          unsigned int storedIndex = finalIndexToStoredIndex[j];
          unsigned int oldCacheIndex = storedCacheIndices[storedOuterOffset + storedIndex];
          unsigned int newCacheIndex = invalidCacheIndex();
          if (oldCacheIndex != invalidCacheIndex()) {
            newCacheIndex = oldCacheIndex - oldOffsets[storedIndex] + newOffsets[j];
          }
          newCacheIndices.emplace_back(newCacheIndex);
        }
        storedOuterOffset += storedProcesses.size();
      }
    }
    storedProcessBlockHelper.setProcessBlockCacheIndices(std::move(newCacheIndices));
    storedProcessBlockHelper.setProcessesWithProcessBlockProducts(std::move(finalProcesses));
  }

void edm::ProcessBlockHelper::fillEntriesFromPrimaryInput ( std::vector< unsigned int >  nEntries )

private

Definition at line 271 of file ProcessBlockHelper.cc.

References cacheEntriesPerFile_, cacheIndexOffset_, eostools::move(), and nEntries_.

Referenced by fillFromPrimaryInput(), and fillFromPrimaryInputWhenNotEmpty().

                                                                                       {
    unsigned int entriesThisFile = 0;
    for (auto const& entries : nEntries) {
      entriesThisFile += entries;
    }
    nEntries_.push_back(std::move(nEntries));
    cacheEntriesPerFile_.push_back(entriesThisFile);
    cacheIndexOffset_ += entriesThisFile;
  }

void edm::ProcessBlockHelper::fillFromPrimaryInput	(	StoredProcessBlockHelper const &	storedProcessBlockHelper,
		std::vector< unsigned int > const &	nEntries
	)

Definition at line 132 of file ProcessBlockHelper.cc.

References cacheIndexVectorsPerFile_, fillEntriesFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), edm::ProcessBlockHelperBase::invalidCacheIndex(), eostools::move(), nProcessesInFirstFile_, outerOffset_, edm::StoredProcessBlockHelper::processBlockCacheIndices(), processBlockCacheIndices_, and edm::StoredProcessBlockHelper::processesWithProcessBlockProducts().

                                                                                         {
    // I've written this so it will continue to work even if we someday relax
    // the strict merging requirement in the ProductRegistry (there
    // is a little extra complexity that may be unnecessary...).

    std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();
    std::vector<unsigned int> const& storedCacheIndices = storedProcessBlockHelper.processBlockCacheIndices();

    outerOffset_ = processBlockCacheIndices_.size();

    if (nProcessesInFirstFile_ == 0) {
      // There were no ProcessBlock products in the first file. Nothing to do.
      return;
    } else if (!storedProcesses.empty()) {
      // Subsequent input file with ProcessBlock products
      fillFromPrimaryInputWhenNotEmpty(storedProcesses, storedCacheIndices, nEntries);
    } else if (storedProcesses.empty()) {
      // Subsequent input file without ProcessBlock products
      processBlockCacheIndices_.emplace_back(nProcessesInFirstFile_, invalidCacheIndex());
      cacheIndexVectorsPerFile_.push_back(1);
      std::vector<unsigned int> newNEntries(nProcessesInFirstFile_, 0);
      fillEntriesFromPrimaryInput(std::move(newNEntries));
    }
  }

void edm::ProcessBlockHelper::fillFromPrimaryInputWhenNotEmpty ( std::vector< std::string > const &  storedProcesses, std::vector< unsigned int > const &  storedCacheIndices, std::vector< unsigned int > const &  nEntries  )

private

Definition at line 224 of file ProcessBlockHelper.cc.

References cms::cuda::assert(), cacheIndexOffset_, cacheIndexVectorsPerFile_, fillEntriesFromPrimaryInput(), edm::ProcessBlockHelperBase::invalidCacheIndex(), edm::ProcessBlockHelperBase::invalidProcessIndex(), dqmiolumiharvest::j, isotrackApplyRegressor::k, eostools::move(), nProcessesInFirstFile_, outerOffset_, processBlockCacheIndices_, edm::ProcessBlockHelperBase::processesWithProcessBlockProducts(), and findQualityFiles::size.

Referenced by fillFromPrimaryInput().

                                                                                                     {
    assert(nProcessesInFirstFile_ <= processesWithProcessBlockProducts().size());

    // Calculate a translation from an index into the process names from the first file
    // to an index into the process names from the current file. Note the value will
    // be left invalid if the process name is not found in the current file.
    std::vector<unsigned int> firstFileToStored(nProcessesInFirstFile_, invalidProcessIndex());
    std::vector<unsigned int> newNEntries(nProcessesInFirstFile_, 0);
    for (unsigned int j = 0; j < nProcessesInFirstFile_; ++j) {
      for (unsigned int k = 0; k < storedProcesses.size(); ++k) {
        if (processesWithProcessBlockProducts()[j] == storedProcesses[k]) {
          firstFileToStored[j] = k;
          newNEntries[j] = nEntries[k];
          break;
        }
      }
    }

    // Append the cache indices from the current input file to the
    // cache indices container from the previous files.
    unsigned int nCacheIndexVectors = storedCacheIndices.size() / storedProcesses.size();
    assert(storedProcesses.size() * nCacheIndexVectors == storedCacheIndices.size());
    processBlockCacheIndices_.resize(processBlockCacheIndices_.size() + nCacheIndexVectors);
    unsigned int storedIndex = 0;
    for (unsigned int k = 0; k < nCacheIndexVectors; ++k) {
      processBlockCacheIndices_[outerOffset_ + k].reserve(nProcessesInFirstFile_);
      for (unsigned int j = 0; j < nProcessesInFirstFile_; ++j) {
        unsigned int iStored = firstFileToStored[j];
        if (iStored == invalidProcessIndex()) {
          processBlockCacheIndices_[outerOffset_ + k].push_back(invalidCacheIndex());
        } else {
          unsigned int oldCacheIndex = storedCacheIndices[storedIndex];
          ++storedIndex;
          unsigned int newCacheIndex = invalidCacheIndex();
          if (oldCacheIndex != invalidCacheIndex()) {
            newCacheIndex = oldCacheIndex + cacheIndexOffset_;
          }
          processBlockCacheIndices_[outerOffset_ + k].push_back(newCacheIndex);
        }
      }
    }
    cacheIndexVectorsPerFile_.push_back(nCacheIndexVectors);
    fillEntriesFromPrimaryInput(std::move(newNEntries));
  }

bool edm::ProcessBlockHelper::firstFileDropProcessesAndReorderStored	(	StoredProcessBlockHelper &	storedProcessBlockHelper,
		std::set< std::string > const &	processesToKeep,
		std::vector< unsigned int > const &	nEntries,
		std::vector< unsigned int > &	finalIndexToStoredIndex
	)		const

Definition at line 47 of file ProcessBlockHelper.cc.

References dropProcessesAndReorderStoredImpl(), LaserDQM_cfg::process, and edm::StoredProcessBlockHelper::processesWithProcessBlockProducts().

Referenced by edm::RootFile::dropProcessesAndReorder().

                                                              {
    std::vector<std::string> const& storedProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts();

    bool isModified = false;
    unsigned int finalSize = 0;
    for (auto const& process : storedProcesses) {
      if (processesToKeep.find(process) == processesToKeep.end()) {
        isModified = true;
      } else {
        ++finalSize;
      }
    }
    if (!isModified) {
      return isModified;
    }

    std::vector<std::string> finalProcesses;
    finalProcesses.reserve(finalSize);
    finalIndexToStoredIndex.reserve(finalSize);
    for (unsigned int iStored = 0; iStored < storedProcesses.size(); ++iStored) {
      if (processesToKeep.find(storedProcesses[iStored]) != processesToKeep.end()) {
        finalProcesses.emplace_back(storedProcesses[iStored]);
        finalIndexToStoredIndex.emplace_back(iStored);
      }
    }
    dropProcessesAndReorderStoredImpl(storedProcessBlockHelper, finalProcesses, nEntries, finalIndexToStoredIndex);
    return isModified;
  }

bool edm::ProcessBlockHelper::initializedFromInput ( ) const

inline

Definition at line 31 of file ProcessBlockHelper.h.

References initializedFromInput_.

Referenced by edm::RootFile::dropProcessesAndReorder().

{ return initializedFromInput_; }

void edm::ProcessBlockHelper::initializeFromPrimaryInput

(

StoredProcessBlockHelper const &

storedProcessBlockHelper

)

Definition at line 122 of file ProcessBlockHelper.cc.

References cms::cuda::assert(), relativeConstraints::empty, initializedFromInput_, nProcessesInFirstFile_, edm::ProcessBlockHelperBase::processesWithProcessBlockProducts(), edm::StoredProcessBlockHelper::processesWithProcessBlockProducts(), and edm::ProcessBlockHelperBase::setProcessesWithProcessBlockProducts().

Referenced by edm::RootFile::RootFile().

                                                                                                              {
    if (!initializedFromInput_) {
      initializedFromInput_ = true;

      assert(processesWithProcessBlockProducts().empty());
      setProcessesWithProcessBlockProducts(storedProcessBlockHelper.processesWithProcessBlockProducts());
      nProcessesInFirstFile_ = processesWithProcessBlockProducts().size();
    }
  }

std::vector< std::vector< unsigned int > > const & edm::ProcessBlockHelper::nEntries ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 24 of file ProcessBlockHelper.cc.

References nEntries_.

{ return nEntries_; }

unsigned int edm::ProcessBlockHelper::nProcessesInFirstFile ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 18 of file ProcessBlockHelper.cc.

References nProcessesInFirstFile_.

{ return nProcessesInFirstFile_; }

unsigned int edm::ProcessBlockHelper::outerOffset ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 42 of file ProcessBlockHelper.cc.

References outerOffset_.

{ return outerOffset_; }

std::vector< std::vector< unsigned int > > const & edm::ProcessBlockHelper::processBlockCacheIndices ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 20 of file ProcessBlockHelper.cc.

References processBlockCacheIndices_.

                                                                                               {
    return processBlockCacheIndices_;
  }

unsigned int edm::ProcessBlockHelper::processBlockIndex ( std::string const &  processName, EventToProcessBlockIndexes const &  eventToProcessBlockIndexes  ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 32 of file ProcessBlockHelper.cc.

References edm::EventToProcessBlockIndexes::index(), edm::ProcessBlockHelperBase::invalidCacheIndex(), nProcessesInFirstFile_, processBlockCacheIndices_, and edm::ProcessBlockHelperBase::processesWithProcessBlockProducts().

                                                                                                        {
    for (unsigned int iProcess = 0; iProcess < nProcessesInFirstFile_; ++iProcess) {
      if (processName == processesWithProcessBlockProducts()[iProcess]) {
        return processBlockCacheIndices_[eventToProcessBlockIndexes.index()][iProcess];
      }
    }
    return invalidCacheIndex();
  }

ProcessBlockHelperBase const * edm::ProcessBlockHelper::topProcessBlockHelper ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 12 of file ProcessBlockHelper.cc.

{ return this; }

std::vector< std::string > const & edm::ProcessBlockHelper::topProcessesWithProcessBlockProducts ( ) const

finalvirtual

Implements edm::ProcessBlockHelperBase.

Definition at line 14 of file ProcessBlockHelper.cc.

References edm::ProcessBlockHelperBase::processesWithProcessBlockProducts().

                                                                                             {
    return processesWithProcessBlockProducts();
  }

Member Data Documentation

std::vector<unsigned int> edm::ProcessBlockHelper::cacheEntriesPerFile_

private

Definition at line 100 of file ProcessBlockHelper.h.

Referenced by cacheEntriesPerFile(), clearAfterOutputFilesClose(), and fillEntriesFromPrimaryInput().

unsigned int edm::ProcessBlockHelper::cacheIndexOffset_ = 0

private

Definition at line 114 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillEntriesFromPrimaryInput(), and fillFromPrimaryInputWhenNotEmpty().

std::vector<unsigned int> edm::ProcessBlockHelper::cacheIndexVectorsPerFile_

private

Definition at line 99 of file ProcessBlockHelper.h.

Referenced by cacheIndexVectorsPerFile(), clearAfterOutputFilesClose(), fillFromPrimaryInput(), and fillFromPrimaryInputWhenNotEmpty().

bool edm::ProcessBlockHelper::initializedFromInput_ = false

private

Definition at line 104 of file ProcessBlockHelper.h.

Referenced by initializedFromInput(), and initializeFromPrimaryInput().

std::vector<std::vector<unsigned int> > edm::ProcessBlockHelper::nEntries_

private

Definition at line 94 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillEntriesFromPrimaryInput(), and nEntries().

unsigned int edm::ProcessBlockHelper::nProcessesInFirstFile_ = 0

private

Definition at line 102 of file ProcessBlockHelper.h.

Referenced by fillFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), initializeFromPrimaryInput(), nProcessesInFirstFile(), and processBlockIndex().

unsigned int edm::ProcessBlockHelper::outerOffset_ = 0

private

Definition at line 110 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), and outerOffset().

std::vector<std::vector<unsigned int> > edm::ProcessBlockHelper::processBlockCacheIndices_

private

Definition at line 87 of file ProcessBlockHelper.h.

Referenced by clearAfterOutputFilesClose(), fillFromPrimaryInput(), fillFromPrimaryInputWhenNotEmpty(), processBlockCacheIndices(), and processBlockIndex().