solver_mva_qsys_prio_tardiness.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_SOLVERS_MVA_SOLVER_MVA_QSYS_PRIO_TARDINESS_H
#define LINE_SOLVERS_MVA_SOLVER_MVA_QSYS_PRIO_TARDINESS_H
 
/**
 * @file
 * Port of `solver_mva_qsys_prio_tardiness.m`: the exact class-deadline
 * tardiness E[(R - D)^+] of the single priority queue `solver_mva_qsys_prio_analyzer`
 * solved (Hafizoglu, Gel and Keskinocak, INFORMS J. Comput. 25(2), 2013).
 *
 * Applies when some class has a finite deadline and every active class has
 * exponential service at one common rate. "mmc.prio" and "mg1.prio" are
 * head-of-line, "mg1.prio.pr" preemptive resume. Both matrices are EMPTY
 * otherwise, which is the reference's "solver does not compute it".
 *
 * ARITHMETIC: double.
 */
 
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
 
#include "line/api/qsys/qsys_mmc_prio_tardiness.h"
#include "line/solvers/mva/mva_dispatch.h"
 
namespace line {
namespace mva {
 
/** `Avg.Tard` (stations x classes, queue row filled) and `Avg.SysTard` (1 x classes). */
struct QsysPrioTardiness {
    Matrix<double> Tard, SysTard;
    bool empty() const { return SysTard.rows() == 0; }
};
 
/**
 * @param L            the model the prio analyzer solved
 * @param actualmethod the resolved method, optionally prefixed "default/"
 */
inline QsysPrioTardiness solver_mva_qsys_prio_tardiness(const qn::NetworkStruct<double>& L,
                                                        std::string actualmethod) {
    QsysPrioTardiness out;
    const std::string pre = "default/";
    if (actualmethod.compare(0, pre.size(), pre) == 0) actualmethod = actualmethod.substr(pre.size());
    std::string type;
    if (actualmethod == "mmc.prio" || actualmethod == "mg1.prio") type = "np";
    else if (actualmethod == "mg1.prio.pr") type = "pr";
    else return out;
    if (mva_qsys_prio_variant(L) != actualmethod) return out;
    const std::size_t K = L.nclasses;
    bool any = false;
    for (std::size_t r = 0; r < K; ++r)
        if (std::isfinite(L.classes[r].deadline)) any = true;
    if (!any) return out;
    const std::size_t src = detail::station_of_type(L, qn::NodeType::Source);
    const std::size_t q = detail::station_of_type(L, qn::NodeType::Queue);
    if (src == 0 || q == 0) return out;
    std::vector<std::size_t> order(K);
    for (std::size_t r = 0; r < K; ++r) order[r] = r;
    std::stable_sort(order.begin(), order.end(), [&](std::size_t a, std::size_t b) {
        return L.classes[a].prio < L.classes[b].prio;
    });
    std::vector<double> la, da;
    std::vector<std::size_t> cls;
    double mu0 = NAN;
    for (std::size_t j = 0; j < K; ++j) {
        const std::size_t r = order[j];
        const double lam = L.rates(src - 1, r), mu = L.rates(q - 1, r);
        if (!(lam > 0) || !std::isfinite(mu)) continue;
        if (std::isnan(mu0)) mu0 = mu;
        if (std::abs(L.scv(q - 1, r) - 1.0) > 1e-6 || std::abs(mu - mu0) > 1e-10 * mu0) return out;
        la.push_back(lam);
        da.push_back(L.classes[r].deadline);
        cls.push_back(r);
    }
    if (la.empty()) return out;
    const std::vector<double> t =
        qsys::qsys_mmc_prio_tardiness(la, mu0, static_cast<unsigned>(L.stations[q - 1].nservers), da, type).Tard;
    out.Tard = Matrix<double>(L.nstations, K);
    out.SysTard = Matrix<double>(1, K);
    for (std::size_t a = 0; a < cls.size(); ++a) {
        out.Tard(q - 1, cls[a]) = t[a];
        out.SysTard(0, cls[a]) = t[a];
    }
    return out;
}
 
}  // namespace mva
}  // namespace line
 
#endif  // LINE_SOLVERS_MVA_SOLVER_MVA_QSYS_PRIO_TARDINESS_H