uint64_t malformedInputs = 0; /// Malformed inputs which the user attempted to process

uint64_t droppedComputations = 0; /// How many computations have been dropped because one of the inputs was late

uint64_t droppedIncomingMessages = 0; /// How many messages have been dropped (not relayed) because they were late

uint64_t relayedMessages = 0; /// How many messages have been successfully relayed

EMPTY,

PENDING,

RUNNING,

DONE

{

public:

/// DataRelayer is thread safe because we have a lock around

/// each method and there is no particular order in which

/// methods need to be called.

constexpr static ServiceKind service_kind = ServiceKind::Global;

enum RelayChoice {

WillRelay,

WillNotRelay

};

struct ActivityStats {

int newSlots = 0;

int expiredSlots = 0;

};

struct RecordAction {

TimesliceSlot slot;

CompletionPolicy::CompletionOp op;

};

DataRelayer(CompletionPolicy const&,

std::vector<InputRoute> const& routes,

monitoring::Monitoring&,

TimesliceIndex&);

/// This invokes the appropriate `InputRoute::danglingChecker` on every

/// entry in the cache and if it returns true, it creates a new

/// cache entry by invoking the associated `InputRoute::expirationHandler`.

/// @a createNew true if the dangling inputs are allowed to create new slots.

/// @return true if there were expirations, false if not.

ActivityStats processDanglingInputs(std::vector<ExpirationHandler> const&,

ServiceRegistry& context, bool createNew);

/// This is used to ask for relaying a given (header,payload) pair.

/// Notice that we expect that the header is an O2 Header Stack

/// with a DataProcessingHeader inside so that we can assess time.

RelayChoice relay(std::unique_ptr<FairMQMessage>&& header,

std::unique_ptr<FairMQMessage>&& payload);

/// @returns the actions ready to be performed.

void getReadyToProcess(std::vector<RecordAction>& completed);

/// Returns an input registry associated to the given timeslice and gives

/// ownership to the caller. This is because once the inputs are out of the

/// DataRelayer they need to be deleted once the processing is concluded.

std::vector<MessageSet> getInputsForTimeslice(TimesliceSlot id);

/// Returns how many timeslices we can handle in parallel

size_t getParallelTimeslices() const;

/// Tune the maximum number of in flight timeslices this can handle.

void setPipelineLength(size_t s);

/// @return the current stats about the data relaying process

DataRelayerStats const& getStats() const;

/// Send metrics with the VariableContext information

void sendContextState();

void publishMetrics();

/// Get timeslice associated to a given slot.

/// Notice how this avoids exposing the timesliceIndex directly

/// so that we can mutex on it.

TimesliceId getTimesliceForSlot(TimesliceSlot slot);

/// Mark a given slot as done so that the GUI

/// can reflect that.

void updateCacheStatus(TimesliceSlot slot, CacheEntryStatus oldStatus, CacheEntryStatus newStatus);

/// Get the firstTFOrbit associate to a given slot.

uint32_t getFirstTFOrbitForSlot(TimesliceSlot slot);

/// Get the firstTFCounter associate to a given slot.

uint32_t getFirstTFCounterForSlot(TimesliceSlot slot);

/// Remove all pending messages

void clear();

private:

monitoring::Monitoring& mMetrics;

/// This is the actual cache of all the parts in flight.

/// Notice that we store them as a NxM sized vector, where

/// N is the maximum number of inflight timeslices, while

/// M is the number of inputs which are requested.

std::vector<MessageSet> mCache;

/// This is the index which maps a given timestamp to the associated

/// cacheline.

TimesliceIndex& mTimesliceIndex;

CompletionPolicy mCompletionPolicy;

std::vector<size_t> mDistinctRoutesIndex;

std::vector<data_matcher::DataDescriptorMatcher> mInputMatchers;

std::vector<data_matcher::VariableContext> mVariableContextes;

std::vector<CacheEntryStatus> mCachedStateMetrics;

static std::vector<std::string> sMetricsNames;

static std::vector<std::string> sVariablesMetricsNames;

static std::vector<std::string> sQueriesMetricsNames;

DataRelayerStats mStats;

TracyLockableN(std::recursive_mutex, mMutex, "data relayer mutex");