TimesliceIndex.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef O2_FRAMEWORK_TIMESLICEINDEX_H_
#define O2_FRAMEWORK_TIMESLICEINDEX_H_
 
#include "Framework/DataDescriptorMatcher.h"
#include "Framework/CompilerBuiltins.h"
#include "Framework/RoutingIndices.h"
#include "Framework/ServiceHandle.h"
#include "Framework/TimesliceSlot.h"
#include "Framework/ChannelInfo.h"
 
#include <cstdint>
#include <vector>
#include <algorithm>
 
namespace o2::framework
{
 
class TimesliceIndex
{
 public:
  constexpr static ServiceKind service_kind = ServiceKind::Global;
 
  enum struct BackpressureOp {
    Wait,        // Do nothing and wait for the oldest slot to complete
    DropAncient, // Drop the message with the least recent timestamp
    DropRecent   // Drop the message with the most recent timestamp
  };
 
  enum struct ActionTaken {
    ReplaceUnused,   
    ReplaceObsolete, 
    Wait,            
    DropInvalid,     
    DropObsolete     
  };
 
  struct ActionSpec {
    ActionTaken action;
    TimesliceSlot slot;
  };
 
  struct OldestInputInfo {
    TimesliceId timeslice = {0};
    ChannelIndex channel = {ChannelIndex::INVALID};
  };
 
  struct OldestOutputInfo {
    TimesliceId timeslice = {0};
    ChannelIndex channel = {ChannelIndex::INVALID};
    TimesliceSlot slot = {(size_t)-1};
  };
 
  TimesliceIndex(size_t maxLanes, std::vector<InputChannelInfo>& channels);
  void resize(size_t s);
  [[nodiscard]] inline size_t size() const;
  [[nodiscard]] inline bool isValid(TimesliceSlot const& slot) const;
  [[nodiscard]] inline bool isDirty(TimesliceSlot const& slot) const;
  inline void markAsDirty(TimesliceSlot slot, bool value);
  inline void markAsInvalid(TimesliceSlot slot);
  inline void rescan();
  inline void publishSlot(TimesliceSlot slot);
 
  void associate(TimesliceId timestamp, TimesliceSlot slot);
 
  inline data_matcher::VariableContext& getVariablesForSlot(TimesliceSlot slot);
 
  inline data_matcher::VariableContext& getPublishedVariablesForSlot(TimesliceSlot slot);
 
  std::tuple<ActionTaken, TimesliceSlot> replaceLRUWith(data_matcher::VariableContext& newContext, TimesliceId timestamp);
 
  [[nodiscard]] bool didReceiveData() const;
  [[nodiscard]] OldestInputInfo setOldestPossibleInput(TimesliceId timeslice, ChannelIndex channel);
  bool validateSlot(TimesliceSlot slot, TimesliceId currentOldest);
 
  [[nodiscard]] OldestInputInfo getOldestPossibleInput() const;
  [[nodiscard]] OldestOutputInfo getOldestPossibleOutput() const;
  OldestOutputInfo updateOldestPossibleOutput(bool rewinded);
  [[nodiscard]] InputChannelInfo const& getChannelInfo(ChannelIndex channel) const;
 
  // Reset the TimesliceIndex to its initial state
  auto reset() -> void;
 
 private:
  [[nodiscard]] inline TimesliceSlot findOldestSlot(TimesliceId) const;
 
  std::vector<data_matcher::VariableContext> mVariables;
 
  std::vector<data_matcher::VariableContext> mPublishedVariables;
 
  std::vector<bool> mDirty;
 
  std::vector<InputChannelInfo>& mChannels;
  OldestInputInfo mOldestPossibleInput = {};
  OldestOutputInfo mOldestPossibleOutput = {};
 
  BackpressureOp mBackpressurePolicy = BackpressureOp::Wait;
  size_t mMaxLanes;
};
 
} // namespace o2::framework
 
#include "TimesliceIndex.inc"
#endif // FRAMEWORK_TIMESLICEINDEX_H