Sequencer.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Sequencer.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2017 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Plugins/FpeMonitoring/FpeMonitor.hpp"
#include "ActsExamples/Framework/IAlgorithm.hpp"
#include "ActsExamples/Framework/IContextDecorator.hpp"
#include "ActsExamples/Framework/IReader.hpp"
#include "ActsExamples/Framework/IWriter.hpp"
#include "ActsExamples/Framework/SequenceElement.hpp"
#include "ActsExamples/Utilities/tbbWrap.hpp"
#include <Acts/Utilities/Logger.hpp>

#include <cstddef>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>

#include <tbb/enumerable_thread_specific.h>

namespace ActsExamples {
class DataHandleBase;
class IAlgorithm;
class IContextDecorator;
class IReader;
class IWriter;
class SequenceElement;

using IterationCallback = void (*)();

class FpeFailure : public std::runtime_error {
  using std::runtime_error::runtime_error;
};

class SequenceConfigurationException : public std::runtime_error {
 public:
  SequenceConfigurationException()
      : std::runtime_error{"Sequence configuration error"} {}
};

class Sequencer {
 public:
  struct FpeMask {
    std::string file;
    std::pair<std::size_t, std::size_t> lines;
    Acts::FpeType type;
    std::size_t count;
  };

  struct Config {
    size_t skip = 0;
    std::optional<size_t> events = std::nullopt;
    Acts::Logging::Level logLevel = Acts::Logging::INFO;
    int numThreads = -1;
    std::string outputDir;
    std::string outputTimingFile = "timing.tsv";
    IterationCallback iterationCallback = []() {};
    bool runDataFlowChecks = true;

    bool trackFpes = true;
    std::vector<FpeMask> fpeMasks{};
    bool failOnFirstFpe = false;
    std::size_t fpeStackTraceLength = 8;
  };

  Sequencer(const Config &cfg);

  void addContextDecorator(std::shared_ptr<IContextDecorator> decorator);

  void addReader(std::shared_ptr<IReader> reader);

  void addAlgorithm(std::shared_ptr<IAlgorithm> algorithm);

  void addElement(const std::shared_ptr<SequenceElement> &element);

  void addWriter(std::shared_ptr<IWriter> writer);

  void addWhiteboardAlias(const std::string &aliasName,
                          const std::string &objectName);

  Acts::FpeMonitor::Result fpeResult() const;

  int run();

  const Config &config() const { return m_cfg; }

 private:
  std::vector<std::string> listAlgorithmNames() const;
  std::pair<size_t, size_t> determineEventsRange() const;

  std::pair<std::string, std::size_t> fpeMaskCount(
      const boost::stacktrace::stacktrace &st, Acts::FpeType type) const;

  void fpeReport() const;

  struct SequenceElementWithFpeResult {
    std::shared_ptr<SequenceElement> sequenceElement;
    tbb::enumerable_thread_specific<Acts::FpeMonitor::Result> fpeResult{};
  };

  Config m_cfg;
  tbbWrap::task_arena m_taskArena;
  std::vector<std::shared_ptr<IContextDecorator>> m_decorators;
  std::vector<std::shared_ptr<IReader>> m_readers;
  std::vector<SequenceElementWithFpeResult> m_sequenceElements;
  std::unique_ptr<const Acts::Logger> m_logger;

  std::unordered_map<std::string, std::string> m_whiteboardObjectAliases;

  std::unordered_map<std::string, const DataHandleBase *> m_whiteBoardState;

  std::atomic<std::size_t> m_nUnmaskedFpe = 0;

  const Acts::Logger &logger() const { return *m_logger; }
};

std::ostream &operator<<(std::ostream &os,
                         const ActsExamples::Sequencer::FpeMask &m);

}  // namespace ActsExamples