LuminosityBlockProcessingStatus.h

Go to the documentation of this file.

#ifndef FWCore_Framework_LuminosityBlockProcessingStatus_h
#define FWCore_Framework_LuminosityBlockProcessingStatus_h
// -*- C++ -*-
//
// Package:     FWCore/Framework
// Class  :     LuminosityBlockProcessingStatus
// 
//
// Original Author:  root
//         Created:  Tue, 19 Dec 2017 14:24:57 GMT
//

// system include files
#include <memory>
#include <atomic>

// user include files
#include "FWCore/Concurrency/interface/LimitedTaskQueue.h"
#include "DataFormats/Provenance/interface/Timestamp.h"
#include "FWCore/Framework/interface/IOVSyncValue.h"

// forward declarations
namespace edm {
#if !defined(TEST_NO_FWD_DECL)
  class EventProcessor;
  class LuminosityBlockPrincipal;
  class WaitingTaskHolder;
  class LuminosityBlockProcessingStatus;
#endif

class LuminosityBlockProcessingStatus
{

  public:
  LuminosityBlockProcessingStatus(EventProcessor* iEP, unsigned int iNStreams, std::shared_ptr<void> iRunResource):
  run_(std::move(iRunResource)) , eventProcessor_(iEP), nStreamsStillProcessingLumi_(iNStreams){}

  std::shared_ptr<LuminosityBlockPrincipal>& lumiPrincipal() { return lumiPrincipal_;}

  void setResumer( LimitedTaskQueue::Resumer iResumer ) {
    globalLumiQueueResumer_ = std::move(iResumer);
  }
  void resumeGlobalLumiQueue() {
    //free lumi for next usage
    lumiPrincipal_.reset();
    globalLumiQueueResumer_.resume();
  }
  
  bool streamFinishedLumi() {
    return 0 == (--nStreamsStillProcessingLumi_);
  }
  
  bool wasEventProcessingStopped() const { return stopProcessingEvents_;}
  void stopProcessingEvents() { stopProcessingEvents_ = true;}
  void startProcessingEvents() { stopProcessingEvents_ = false;}
  
  bool isLumiEnding() const {return lumiEnding_;}
  void endLumi() { lumiEnding_ = true;}
  
  bool continuingLumi() const { return continuingLumi_;}
  void haveContinuedLumi() { continuingLumi_ = false; }
  void needToContinueLumi() { continuingLumi_ = true;}

  bool haveStartedNextLumi() const { return startedNextLumi_;}
  void startNextLumi() { startedNextLumi_ = true;}
  
  bool didGlobalBeginSucceed() const {return globalBeginSucceeded_;}
  void globalBeginDidSucceed() { globalBeginSucceeded_ = true;}

  void noExceptionHappened() { cleaningUpAfterException_ = false; }
  bool cleaningUpAfterException() const { return cleaningUpAfterException_;}

  //These should only be called while in the InputSource's task queue
  void updateLastTimestamp( edm::Timestamp const& iTime) {
    if (iTime> endTime_) { endTime_ = iTime;}
  }
  edm::Timestamp const& lastTimestamp() const { return endTime_;}
  
  void setNextSyncValue(IOVSyncValue iValue) {
    nextSyncValue_ = std::move(iValue);
  }
  
  const IOVSyncValue nextSyncValue() const { return nextSyncValue_;}
  
  std::shared_ptr<void> const& runResource() const {return run_;}
  
  //Called once all events in Lumi have been processed
  void setEndTime();
  private:
  // ---------- member data --------------------------------
  std::shared_ptr<LuminosityBlockPrincipal> lumiPrincipal_;
  std::shared_ptr<void> run_;
  LimitedTaskQueue::Resumer globalLumiQueueResumer_;
  EventProcessor* eventProcessor_ = nullptr;
  IOVSyncValue nextSyncValue_;
  std::atomic<unsigned int> nStreamsStillProcessingLumi_{0}; //read/write as streams finish lumi so must be atomic
  edm::Timestamp endTime_{};
  std::atomic<char> endTimeSetStatus_{0};
  bool stopProcessingEvents_{false}; //read/write in m_sourceQueue OR from main thread when no tasks running
  bool lumiEnding_{false}; //read/write in m_sourceQueue NOTE: This is a useful cache instead of recalculating each call
  bool continuingLumi_{false}; //read/write in m_sourceQueue OR from main thread when no tasks running
  bool startedNextLumi_{false}; //read/write in m_sourceQueue
  bool globalBeginSucceeded_{false};
  bool cleaningUpAfterException_{true};


};
}

#endif