qsys_ddckk.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_API_QSYS_QSYS_DDCKK_H
#define LINE_API_QSYS_QSYS_DDCKK_H
 
/**
 * @file
 * @ingroup api_qsys
 * Exact analysis of the finite-source D/D/c/K/K machine-repair model.
 *
 * Port of matlab/src/api/qsys/qsys_ddckk.m. K sources each operate for a
 * deterministic time EO and then request a deterministic service ES from one
 * of c servers. After a transient the cycle settles into a periodic regime in
 * which the per-server utilization is
 *
 *   a = min(1, K / (c (1 + EO/ES))),    X = c a / ES,
 *
 * and the response time follows from the cycle law ET = K/X - EO, with no
 * waiting while the servers are not saturated.
 *
 * ARITHMETIC: field. Only min, products and quotients appear, so the
 * computation is exact for T = Rational.
 */
 
#include <string>
 
#include "line/api/qsys/qsys_res.h"
#include "line/num/number.h"
#include "line/util/error.h"
 
namespace line {
namespace qsys {
 
/**
 * @brief Exact D/D/c/K/K finite-source queue.
 *
 * @param EO deterministic operating (think) time, EO >= 0
 * @param ES deterministic service time, ES > 0
 * @param c  number of servers
 * @param K  number of sources, K >= c
 * @return MATLAB's result struct: meanQueueLength, meanQueueLengthQ,
 *         meanWaitingTime, meanSojournTime, throughput, utilization,
 *         meanOperating, and analyzer
 */
template <class T>
QsysResT<T> qsys_ddckk(const T& EO, const T& ES, unsigned c, unsigned K) {
    const T zero = num_traits<T>::from_int(0), one = num_traits<T>::from_int(1);
    if (EO < zero) throw Error("qsys_ddckk: EO must be a non-negative real scalar");
    if (ES <= zero) throw Error("qsys_ddckk: ES must be a positive real scalar");
    if (c < 1) throw Error("qsys_ddckk: c must be a positive integer");
    if (K < c) throw Error("qsys_ddckk: K must be an integer >= c");
    const T cT = num_traits<T>::from_int(static_cast<long>(c));
    const T KT = num_traits<T>::from_int(static_cast<long>(K));
    const T z = T(EO / ES);
    T a = T(KT / (cT * (one + z)));
    if (a > one) a = one;
    const T X = T(cT * a / ES);
    T ET = T(KT / X - EO);
    T EW = T(ET - ES);
    if (EW < zero) EW = zero;
    ET = T(EW + ES);
    QsysResT<T> r;
    r.set("meanQueueLength", T(X * ET));
    r.set("meanQueueLengthQ", T(X * EW));
    r.set("meanWaitingTime", EW);
    r.set("meanSojournTime", ET);
    r.set("throughput", X);
    r.set("utilization", a);
    r.set("meanOperating", T(X * EO));
    r.analyzer = "exact:D/D/" + std::to_string(c) + "/" + std::to_string(K) + "/" + std::to_string(K);
    return r;
}
 
}  // namespace qsys
}  // namespace line
 
#endif  // LINE_API_QSYS_QSYS_DDCKK_H