fj_metrics.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_SOLVERS_FJ_METRICS_H
#define LINE_SOLVERS_FJ_METRICS_H
 
/**
 * @file
 * @ingroup line_solvers
 * Fork-join section metrics: FJQLen, FJRespT and FJTput of every Fork/Join pair.
 *
 * The reference keeps them in `self.result.FJ` (struct forks, joins, QLen, RespT,
 * Tput) and reports them through `getAvgFJ` and `getAvgFJTable`, separately from
 * the average table, whose layout is unchanged on a fork-join model. A PAIR is a
 * nonzero (f, j) of `sn.fj`, and the pairs are ordered by fork node and then by
 * join node, which is `sortrows([forks joins])` in `fjFixedPoint.m`.
 *
 *   FJRespT(p,r)  mean time from a class-r job's arrival at the Fork of pair p to
 *                 its departure from the matching Join;
 *   FJTput(p,r)   class-r throughput through the pair;
 *   FJQLen(p,r)   mean number of class-r jobs inside the section.
 *
 * Who fills it: MVA, NC and Fluid from the fork-join fixed point (fj_driver.h,
 * FJQLen = FJTput * FJRespT exactly), JMT from its 'Fork Join Response Time' and
 * 'Fork Join Number of Customers' measures, and LDES from the per-fork-job
 * sojourns it measures. Every other solver leaves it EMPTY, and so does every
 * model without a Fork/Join pair: absent is not zero.
 */
 
#include <algorithm>
#include <cstddef>
#include <utility>
#include <vector>
 
#include "line/util/matrix.h"
 
namespace line {
namespace solvers {
 
/** `self.result.FJ`: one row per Fork/Join pair, one column per class. */
template <class T>
struct FjMetrics {
    std::vector<std::size_t> forks;  ///< 1-based fork node of each pair
    std::vector<std::size_t> joins;  ///< 1-based join node of each pair
    Matrix<T> QLen;                  ///< FJQLen, P x R
    Matrix<T> RespT;                 ///< FJRespT, P x R
    Matrix<T> Tput;                  ///< FJTput, P x R
    /** Whether a solver reported the metrics at all; false on a model without pairs. */
    bool computed = false;
    /** No pair to report: a model without Fork/Join, or a solver that does not compute them. */
    bool empty() const { return !computed || forks.empty(); }
    std::size_t npairs() const { return forks.size(); }
};
 
/**
 * The Fork/Join pairs of a struct, `sortrows([forks joins])` over `find(sn.fj)`:
 * ascending in fork node, then in join node, with duplicates removed. `S` is any
 * struct carrying `fj` as a vector of 1-based (fork, join) pairs.
 */
template <class S>
std::vector<std::pair<std::size_t, std::size_t>> fj_sorted_pairs(const S& sn) {
    std::vector<std::pair<std::size_t, std::size_t>> p;
    for (const auto& e : sn.fj)
        if (e.first != 0 && e.second != 0) p.push_back(e);
    std::sort(p.begin(), p.end());
    p.erase(std::unique(p.begin(), p.end()), p.end());
    return p;
}
 
/** An empty-but-shaped result: every pair of `sn`, all three matrices zero. */
template <class T, class S>
FjMetrics<T> fj_metrics_zero(const S& sn, std::size_t nclasses) {
    FjMetrics<T> out;
    const std::vector<std::pair<std::size_t, std::size_t>> p = fj_sorted_pairs(sn);
    for (const auto& e : p) {
        out.forks.push_back(e.first);
        out.joins.push_back(e.second);
    }
    const T zero = num_traits<T>::from_int(0);
    out.QLen = Matrix<T>(p.size(), nclasses, zero);
    out.RespT = Matrix<T>(p.size(), nclasses, zero);
    out.Tput = Matrix<T>(p.size(), nclasses, zero);
    out.computed = true;
    return out;
}
 
/** The same metrics in double precision, for the facade and the CLI. */
template <class T>
FjMetrics<double> fj_metrics_to_double(const FjMetrics<T>& in) {
    FjMetrics<double> out;
    out.forks = in.forks;
    out.joins = in.joins;
    out.computed = in.computed;
    const Matrix<T>* src[3] = {&in.QLen, &in.RespT, &in.Tput};
    Matrix<double>* dst[3] = {&out.QLen, &out.RespT, &out.Tput};
    for (int m = 0; m < 3; ++m) {
        *dst[m] = Matrix<double>(src[m]->rows(), src[m]->cols(), 0.0);
        for (std::size_t i = 0; i < src[m]->rows(); ++i)
            for (std::size_t j = 0; j < src[m]->cols(); ++j)
                (*dst[m])(i, j) = num_traits<T>::to_double((*src[m])(i, j));
    }
    return out;
}
 
}  // namespace solvers
}  // namespace line
 
#endif  // LINE_SOLVERS_FJ_METRICS_H