Sequence.h

Go to the documentation of this file.

#ifndef MARLINMT_SEQUENCE_h
#define MARLINMT_SEQUENCE_h 1

// -- std headers
#include <vector>
#include <unordered_set>
#include <memory>
#include <map>
#include <mutex>
#include <utility> // pair
#include <ctime>

// -- marlinmt headers
#include <marlinmt/Logging.h>
#include <marlinmt/Utils.h>

namespace marlinmt {

  class Application ;
  class SequenceItem ;
  class Processor ;
  class EventStore ;
  class RunHeader ;
  class ConfigSection ;

  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  class SequenceItem {
  public:
    ~SequenceItem() = default ;

    SequenceItem( std::shared_ptr<Processor> proc ) ;

    SequenceItem( std::shared_ptr<Processor> proc, std::shared_ptr<std::mutex> lock ) ;

    void processRunHeader( std::shared_ptr<RunHeader> rhdr ) ;

    clock::pair processEvent( std::shared_ptr<EventStore> event ) ;

    // clock::pair modifyEvent( std::shared_ptr<EVENT::LCEvent> event ) ;

    std::shared_ptr<Processor> processor() const ;

    const std::string &name() const ;

  private:
    std::shared_ptr<Processor>     _processor {nullptr} ;
    std::shared_ptr<std::mutex>    _mutex {nullptr} ;
  };

  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  struct ClockMeasure {
    clock::duration_rep   _appClock {0.} ;
    clock::duration_rep   _procClock {0.} ;
    int                   _counter {0} ;
  };

  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  class Sequence {
  public:
    using Container = std::vector<std::shared_ptr<SequenceItem>> ;
    using Index = Container::size_type ;
    using SizeType = Container::size_type ;
    using ClockMeasureMap = std::map<std::string, ClockMeasure> ;
    using SkippedEventMap = std::map<std::string, int> ;

  public:
    Sequence() = default ;
    ~Sequence() = default ;
    Sequence &operator=(const Sequence &) = delete ;
    Sequence(const Sequence &) = delete ;

  public:
    std::shared_ptr<SequenceItem> createItem( std::shared_ptr<Processor> processor, std::shared_ptr<std::mutex> lock ) const ;

    void addItem( std::shared_ptr<SequenceItem> item ) ;

    std::shared_ptr<SequenceItem> at( Index index ) const ;

    SizeType size() const ;

    void processRunHeader( std::shared_ptr<RunHeader> rhdr ) ;

    void processEvent( std::shared_ptr<EventStore> event ) ;

    ClockMeasure clockMeasureSummary() const ;

    const ClockMeasureMap &clockMeasures() const ;

    const SkippedEventMap &skippedEvents() const ;

  private:
    Container                       _items {} ;
    ClockMeasureMap                 _clockMeasures {} ;
    SkippedEventMap                 _skipEventMap {} ;
  };

  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  class SuperSequence {
  private:
    struct ItemEqual {
      using Item = std::shared_ptr<SequenceItem> ;
      bool operator()( const Item& lhs, const Item& rhs ) const {
        return lhs->processor() == rhs->processor() ;
      }
    };

    using Sequences = std::vector<std::shared_ptr<Sequence>> ;
    using Index = Sequences::size_type ;
    using SizeType = Sequences::size_type ;
    using SequenceItemList = std::unordered_set<
      std::shared_ptr<SequenceItem>,
      std::hash<std::shared_ptr<SequenceItem>>,
      ItemEqual> ;

  public:
    SuperSequence() = delete ;
    ~SuperSequence() = default ;
    SuperSequence(const SuperSequence &) = delete ;
    SuperSequence &operator=(const SuperSequence &) = delete ;

    SuperSequence( std::size_t nseqs ) ;

    std::shared_ptr<Sequence> sequence( Index index ) const ;

    void addProcessor( const ConfigSection &parameters ) ;

    SizeType size() const ;

    void init( Application *app ) ;

    void processRunHeader( std::shared_ptr<RunHeader> rhdr ) ;

    void end() ;

    void printStatistics( Logging::Logger logger ) const ;

  private:
    Sequences                  _sequences {} ;
    SequenceItemList           _uniqueItems {} ;
  };

} // end namespace marlinmt

#endif