 |
LINE Solver (C++)
Templated C++ port of the LINE queueing solver
|
|
LINE Solver (C++)
Templated C++ port of the LINE queueing solver
|
Maximum Entropy algorithm for single-class OPEN networks with FINITE BUFFERS, under loss or transfer blocking. More...
#include <algorithm>#include <cmath>#include <cstddef>#include <limits>#include <vector>#include "line/api/me/me_gegec_mql.h"#include "line/api/me/me_gegecn.h"#include "line/api/me/me_types.h"#include "line/num/number.h"#include "line/util/error.h"#include "line/util/lu.h"#include "line/util/matrix.h"Go to the source code of this file.
Classes | |
| struct | line::me::MeBlkOptions |
| Controls of the blocking fixed point, me_oqn_blk's options struct. More... | |
| struct | line::me::MeBlkResult< T > |
| What me_oqn_blk returns, per station. More... | |
Namespaces | |
| namespace | line |
| namespace | line::me |
Functions | |
| template<class T> | |
| MeBlkResult< T > | line::me::me_oqn_blk (std::size_t M, const std::vector< T > &lambda0, const std::vector< T > &Ca0, const std::vector< T > &mu, const std::vector< T > &Cs, const Matrix< T > &P, const std::vector< long > &c, const std::vector< long > &N, const std::vector< int > &blockrule, const MeBlkOptions &opt=MeBlkOptions()) |
| Port of me_oqn_blk. | |
Maximum Entropy algorithm for single-class OPEN networks with FINITE BUFFERS, under loss or transfer blocking.
Templated port of matlab/src/api/me/me_oqn_blk.m: Kouvatsos (1994) Section 4 for the loss case, and Tahilramani, Manjunath and Bose (1999) for transfer blocking.
TWO POLICIES, AND ONLY ONE OF THEM IS EASY.
LOSS (blockrule 0). A job finding the destination full is discarded. Every station is then a censored GE/GE/c/0;N queue and the network is a straightforward ME decomposition.
TRANSFER BLOCKING (blockrule 1, BAS). A job that completes at i and finds j full is held in i's SERVER, which can serve nobody else until j has room. That is NOT WORK CONSERVING, so no product-form approximation applies to the network as it stands. The reference first makes it work conserving by inserting a GE/GE/inf HOLDING NODE h_ij on every routing pair with a finite-buffer destination: the holding node absorbs the blocked job so i's server is released, and the delay it charges is the residual life of the minimum of the c_j services in progress at j, inflated geometrically because the released job may find j full again. Station i's own service is inflated by the same blocking probability, so the jobs queued behind the blocked one still see the server busy. THE HELD JOBS ARE ADDED BACK TO STATION i at the end – they are physically in i's servers, and reporting them at the holding node would lose them from the station table.
WHY THE SELF-LOOP IS ELIMINATED FIRST. The flow decomposition assumes RENEWAL arrival streams, which immediate feedback breaks. A job returning straight to i receives a geometric number of passes, so the composite service has rate mu(1-p_ii) and scv p_ii + (1-p_ii)Cs; the loop is removed and the residual routing renormalized.
TWO CONVENTIONS THAT ARE EASY TO GET WRONG, both carried deliberately. An EXTERNAL arrival finding the buffer full is LOST whatever the drop rule – there is no upstream server to hold it in – which is both the source's convention and what SolverCTMC does, returning the same answer for DROP and BAS on a source-fed finite queue. And the reported UTILIZATION is LINE's, the carried flow times the nominal mean service time per server, so a server held blocked after service does NOT count as busy; the ME solution's own E[min(n,c)]/c is computed under the INFLATED service and would include the blocking time, so it is recomputed at the end.
Definition in file me_oqn_blk.h.
1.18.0