MergeableRunProductMetadata.h

Go to the documentation of this file.

#ifndef FWCore_Framework_MergeableRunProductMetadata_h
#define FWCore_Framework_MergeableRunProductMetadata_h

#include "DataFormats/Provenance/interface/MergeableRunProductMetadataBase.h"
#include "FWCore/Framework/interface/MergeableRunProductProcesses.h"
#include "DataFormats/Provenance/interface/RunLumiEventNumber.h"

#include "tbb/concurrent_vector.h"

#include <string>
#include <vector>

namespace edm {

  class IndexIntoFileItrHolder;
  class StoredMergeableRunProductMetadata;

  class MergeableRunProductMetadata : public MergeableRunProductMetadataBase {
  public:
    enum MergeDecision { MERGE, REPLACE, IGNORE };

    MergeableRunProductMetadata(MergeableRunProductProcesses const&);

    ~MergeableRunProductMetadata() override;

    // Called each time a new input file is opened
    void preReadFile();

    // Called each time a run entry is read from an input file. This
    // should be called before the run products themselves are read
    // because it sets the decision whether to merge, replace, or ignore
    // run products as they read.
    void readRun(long long inputRunEntry,
                 StoredMergeableRunProductMetadata const& inputStoredMergeableRunProductMetadata,
                 IndexIntoFileItrHolder const& inputIndexIntoFileItr);

    // Called to record which lumis were processed by the current run
    void writeLumi(LuminosityBlockNumber_t lumi);

    void preWriteRun();
    void postWriteRun();

    void addEntryToStoredMetadata(StoredMergeableRunProductMetadata&) const;

    MergeDecision getMergeDecision(std::string const& processThatCreatedProduct) const;

    // If Runs were split on lumi boundaries, but then the files were merged
    // in a way that made it impossible to properly merge run products, this
    // function will return true. The Framework usually does not know
    // enough to detect other cases where there is a merging problem.
    bool knownImproperlyMerged(std::string const& processThatCreatedProduct) const override;

    std::string const& getProcessName(unsigned int index) const {
      return mergeableRunProductProcesses_->getProcessName(index);
    }

    class MetadataForProcess {
    public:
      MetadataForProcess() = default;

      std::vector<LuminosityBlockNumber_t>& lumis() { return lumis_; }
      std::vector<LuminosityBlockNumber_t> const& lumis() const { return lumis_; }

      MergeDecision mergeDecision() const { return mergeDecision_; }
      void setMergeDecision(MergeDecision v) { mergeDecision_ = v; }

      bool valid() const { return valid_; }
      void setValid(bool v) { valid_ = v; }

      bool useIndexIntoFile() const { return useIndexIntoFile_; }
      void setUseIndexIntoFile(bool v) { useIndexIntoFile_ = v; }

      bool allLumisProcessed() const { return allLumisProcessed_; }
      void setAllLumisProcessed(bool v) { allLumisProcessed_ = v; }

      void reset();

    private:
      std::vector<LuminosityBlockNumber_t> lumis_;
      MergeDecision mergeDecision_ = MERGE;
      bool valid_ = true;
      bool useIndexIntoFile_ = false;
      bool allLumisProcessed_ = false;
    };

    MetadataForProcess const* metadataForOneProcess(std::string const& processName) const;

    // The next few functions are only intended to be used in tests.
    std::vector<MetadataForProcess> const& metadataForProcesses() const { return metadataForProcesses_; }

    std::vector<LuminosityBlockNumber_t> const& lumisFromIndexIntoFile() const { return lumisFromIndexIntoFile_; }

    bool gotLumisFromIndexIntoFile() const { return gotLumisFromIndexIntoFile_; }

    tbb::concurrent_vector<LuminosityBlockNumber_t> const& lumisProcessed() const { return lumisProcessed_; }

  private:
    void mergeLumisFromIndexIntoFile();

    bool addProcess(StoredMergeableRunProductMetadata& storedMetadata,
                    MetadataForProcess const& metadataForProcess,
                    unsigned int storedProcessIndex,
                    unsigned long long beginProcess,
                    unsigned long long endProcess) const;

    MergeableRunProductProcesses const* mergeableRunProductProcesses_;

    // This vector has an entry for each process that has a
    // mergeable run product in the input. It has an exact one to
    // correspondence with mergeableRunProductProcesses_ and
    // is in the same order.
    std::vector<MetadataForProcess> metadataForProcesses_;

    std::vector<LuminosityBlockNumber_t> lumisFromIndexIntoFile_;
    bool gotLumisFromIndexIntoFile_ = false;

    tbb::concurrent_vector<LuminosityBlockNumber_t> lumisProcessed_;
  };
}  // namespace edm
#endif