File indexing completed on 2025-04-22 06:27:17
0001 #include "FWCore/Common/interface/OutputProcessBlockHelper.h"
0002
0003 #include "DataFormats/Provenance/interface/StoredProcessBlockHelper.h"
0004 #include "FWCore/Common/interface/ProcessBlockHelperBase.h"
0005
0006 #include <algorithm>
0007 #include <cassert>
0008 #include <utility>
0009
0010 namespace edm {
0011
0012 void OutputProcessBlockHelper::updateAfterProductSelection(
0013 std::set<std::string> const& processesWithKeptProcessBlockProducts,
0014 ProcessBlockHelperBase const& processBlockHelper) {
0015 processBlockHelper_ = &processBlockHelper;
0016
0017
0018
0019
0020
0021 assert(processesWithProcessBlockProducts_.empty());
0022 unsigned int iProcess = 0;
0023 for (auto const& process : processBlockHelper.processesWithProcessBlockProducts()) {
0024 if (processesWithKeptProcessBlockProducts.find(process) != processesWithKeptProcessBlockProducts.end()) {
0025 processesWithProcessBlockProducts_.emplace_back(process);
0026 translateFromStoredIndex_.emplace_back(iProcess);
0027 }
0028 ++iProcess;
0029 }
0030
0031 for (auto const& addedProcess : processBlockHelper.addedProcesses()) {
0032
0033
0034 if (std::find(processesWithProcessBlockProducts_.begin(),
0035 processesWithProcessBlockProducts_.end(),
0036 addedProcess) != processesWithProcessBlockProducts_.end()) {
0037 ++nAddedProcesses_;
0038 }
0039 }
0040
0041
0042
0043
0044
0045 productsFromInputKept_ =
0046 std::find_first_of(processesWithProcessBlockProducts_.begin(),
0047 processesWithProcessBlockProducts_.end(),
0048 processBlockHelper.topProcessesWithProcessBlockProducts().begin(),
0049 processBlockHelper.topProcessesWithProcessBlockProducts().begin() +
0050 processBlockHelper.nProcessesInFirstFile()) != processesWithProcessBlockProducts_.end();
0051 }
0052
0053 void OutputProcessBlockHelper::fillCacheIndices(StoredProcessBlockHelper& storedProcessBlockHelper) const {
0054
0055
0056
0057 std::vector<unsigned int> storedCacheIndices;
0058
0059
0060 unsigned int nStoredProcesses = storedProcessBlockHelper.processesWithProcessBlockProducts().size();
0061
0062 if (!productsFromInputKept_) {
0063
0064
0065
0066 assert(nAddedProcesses_ == nStoredProcesses);
0067 storedCacheIndices.reserve(nStoredProcesses);
0068 for (unsigned int i = 0; i < nStoredProcesses; ++i) {
0069 storedCacheIndices.push_back(i);
0070 }
0071 storedProcessBlockHelper.setProcessBlockCacheIndices(std::move(storedCacheIndices));
0072 return;
0073 }
0074
0075
0076
0077 std::vector<std::vector<unsigned int>> const& cacheIndices = processBlockHelper_->processBlockCacheIndices();
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091 std::vector<unsigned int> const& cacheIndexVectorsPerFile = processBlockHelper_->cacheIndexVectorsPerFile();
0092 std::vector<unsigned int> const& cacheEntriesPerFile = processBlockHelper_->cacheEntriesPerFile();
0093 std::vector<std::vector<unsigned int>> const& nEntries = processBlockHelper_->nEntries();
0094
0095 assert(!cacheIndices.empty());
0096
0097 unsigned int nInputProcesses = 0;
0098 for (unsigned int iStoredProcess = 0; iStoredProcess < nStoredProcesses; ++iStoredProcess) {
0099
0100
0101
0102
0103
0104 if (translateFromStoredIndex_[iStoredProcess] < cacheIndices[0].size()) {
0105 ++nInputProcesses;
0106 }
0107 }
0108
0109
0110
0111
0112
0113
0114 unsigned int fileOffset = 0;
0115
0116
0117
0118 std::vector<unsigned int> processOffset(nInputProcesses, 0);
0119
0120
0121
0122
0123
0124
0125 assert(!nEntries.empty());
0126 std::vector<unsigned int> storedProcessOffset(nInputProcesses + 1, 0);
0127
0128
0129
0130
0131 std::vector<unsigned int> storedFileInProcessOffset(nInputProcesses, 0);
0132
0133 setStoredProcessOffset(nInputProcesses, nEntries, storedProcessOffset);
0134
0135 storedCacheIndices.reserve(cacheIndices.size() * nStoredProcesses);
0136
0137 unsigned int iFile = 0;
0138 unsigned int innerVectorsCurrentFile = 0;
0139
0140
0141
0142 for (auto const& innerVectorOfCacheIndices : cacheIndices) {
0143
0144
0145
0146
0147
0148 while (innerVectorsCurrentFile == cacheIndexVectorsPerFile[iFile]) {
0149
0150
0151 fileOffset += cacheEntriesPerFile[iFile];
0152 ++iFile;
0153 innerVectorsCurrentFile = 0;
0154 }
0155 if (innerVectorsCurrentFile == 0) {
0156
0157 setProcessOffset(iFile, nInputProcesses, nEntries, processOffset);
0158 setStoredFileInProcessOffset(iFile, nInputProcesses, nEntries, storedFileInProcessOffset);
0159 }
0160 ++innerVectorsCurrentFile;
0161
0162 assert(nInputProcesses + nAddedProcesses_ == nStoredProcesses);
0163
0164
0165 for (unsigned int iStoredProcess = 0; iStoredProcess < nStoredProcesses; ++iStoredProcess) {
0166 unsigned int storedCacheIndex = ProcessBlockHelperBase::invalidCacheIndex();
0167 if (iStoredProcess < nInputProcesses) {
0168 unsigned int cacheIndex = innerVectorOfCacheIndices[translateFromStoredIndex_[iStoredProcess]];
0169 if (cacheIndex != ProcessBlockHelperBase::invalidCacheIndex()) {
0170
0171
0172 unsigned int inputOffset = fileOffset + processOffset[iStoredProcess];
0173 unsigned int storedOffset = storedProcessOffset[iStoredProcess] + storedFileInProcessOffset[iStoredProcess];
0174 storedCacheIndex = cacheIndex - inputOffset + storedOffset;
0175 }
0176 } else {
0177
0178
0179 storedCacheIndex = storedProcessOffset[nInputProcesses] + iStoredProcess - nInputProcesses;
0180 }
0181 storedCacheIndices.push_back(storedCacheIndex);
0182 }
0183 }
0184 storedProcessBlockHelper.setProcessBlockCacheIndices(std::move(storedCacheIndices));
0185 }
0186
0187 void OutputProcessBlockHelper::setStoredProcessOffset(unsigned int nInputProcesses,
0188 std::vector<std::vector<unsigned int>> const& nEntries,
0189 std::vector<unsigned int>& storedProcessOffset) const {
0190 unsigned int iStored = 0;
0191 for (auto& offset : storedProcessOffset) {
0192 offset = 0;
0193
0194 for (unsigned int jStored = 0; jStored < iStored; ++jStored) {
0195 unsigned int indexInEventProcessor = translateFromStoredIndex_[jStored];
0196
0197 for (auto const& entries : nEntries) {
0198 assert(indexInEventProcessor < entries.size());
0199 offset += entries[indexInEventProcessor];
0200 }
0201 }
0202 ++iStored;
0203 }
0204 }
0205
0206 void OutputProcessBlockHelper::setProcessOffset(unsigned int iFile,
0207 unsigned int nInputProcesses,
0208 std::vector<std::vector<unsigned int>> const& nEntries,
0209 std::vector<unsigned int>& processOffset) const {
0210 unsigned int iStored = 0;
0211 for (auto& offset : processOffset) {
0212 offset = 0;
0213 unsigned int iProcess = translateFromStoredIndex_[iStored];
0214 for (unsigned int jProcess = 0; jProcess < iProcess; ++jProcess) {
0215 offset += nEntries[iFile][jProcess];
0216 }
0217 ++iStored;
0218 }
0219 }
0220
0221 void OutputProcessBlockHelper::setStoredFileInProcessOffset(
0222 unsigned int iFile,
0223 unsigned int nInputProcesses,
0224 std::vector<std::vector<unsigned int>> const& nEntries,
0225 std::vector<unsigned int>& storedFileInProcessOffset) const {
0226 unsigned int iStored = 0;
0227 for (auto& offset : storedFileInProcessOffset) {
0228 offset = 0;
0229 unsigned int indexInEventProcessor = translateFromStoredIndex_[iStored];
0230
0231 for (unsigned int jFile = 0; jFile < iFile; ++jFile) {
0232 assert(indexInEventProcessor < nEntries[jFile].size());
0233 offset += nEntries[jFile][indexInEventProcessor];
0234 }
0235 ++iStored;
0236 }
0237 }
0238
0239 }