 |
LINE Solver (C++)
Templated C++ port of the LINE queueing solver
|
|
LINE Solver (C++)
Templated C++ port of the LINE queueing solver
|
SolverMVA over a SolverLN layer. More...
#include "line/util/line_console.h"#include <algorithm>#include <cmath>#include <string>#include <vector>#include "line/api/npfqn/npfqn_sqd.h"#include "line/api/pfqn/pfqn_ab_amva.h"#include "line/api/pfqn/pfqn_aql.h"#include "line/api/pfqn/pfqn_qsa.h"#include "line/api/pfqn/pfqn_lcfsqn_mva.h"#include "line/api/pfqn/pfqn_bs.h"#include "line/api/pfqn/pfqn_chow.h"#include "line/api/pfqn/pfqn_clust.h"#include "line/api/pfqn/pfqn_dmlin.h"#include "line/api/pfqn/pfqn_lcp.h"#include "line/api/pfqn/pfqn_pam.h"#include "line/api/pfqn/pfqn_cdfun.h"#include "line/api/pfqn/pfqn_conwayms.h"#include "line/api/pfqn/pfqn_jdfun.h"#include "line/api/pfqn/pfqn_lldfun.h"#include "line/api/pfqn/pfqn_scat.h"#include "line/api/pfqn/pfqn_tay.h"#include "line/api/pfqn/pfqn_linearizermx.h"#include "line/api/pfqn/pfqn_mvams.h"#include "line/api/pfqn/pfqn_schmidt.h"#include "line/api/pfqn/pfqn_schmidt_ext.h"#include "line/api/pfqn/pfqn_sqni.h"#include "line/api/sum/sum_closed.h"#include "line/api/sum/sum_closing.h"#include "line/lang/qn/network_struct.h"#include "line/solvers/mva/mva_types.h"#include "line/solvers/mva/sn_chain.h"#include "line/util/error.h"Go to the source code of this file.
Namespaces | |
| namespace | line |
| namespace | line::mva |
Functions | |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_mva_lcfsqn (const qn::NetworkStruct< T > &L, std::size_t lcfs_ist, std::size_t lcfspr_ist) |
| Port of solver_mva_lcfsqn.m: the closed two-station LCFS + LCFS-PR network. | |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_mva (const qn::NetworkStruct< T > &L, const ChainDemands< T > &d, const MvaOptions &opt) |
| Port of solver_mva.m, closed and mixed product-form networks. | |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_amvald (const qn::NetworkStruct< T > &L, const ChainDemands< T > &d, const MvaOptions &opt, const std::string &method, bool &converged, const Matrix< T > &init_sol=Matrix< T >()) |
| Port of solver_amvald.m together with solver_amvald_forward.m, restricted to the INF / PS / FCFS-family disciplines with no load or class dependence. | |
| std::string | line::mva::amva_method_alias (const std::string &m) |
The amva. | |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_amva (const qn::NetworkStruct< T > &L, const ChainDemands< T > &d, MvaOptions opt, const Matrix< T > &init_sol, bool &converged) |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_mvald (const qn::NetworkStruct< T > &L, const MvaOptions &opt) |
| Port of solver_mvald.m: exact MVA on a load-dependent model, through pfqn_mvaldmx. | |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_mva_sum (const qn::NetworkStruct< T > &L, const MvaOptions &opt) |
| Port of solver_mva_sum.m: the SUM / ESUM summation method (Bolch et al., Secs. | |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_sqd (const qn::NetworkStruct< T > &L, const ChainDemands< T > &d) |
| Port of solver_sqd.m: Smith queue decomposition for blocking-after-service. | |
| template<class T> | |
| bool | line::mva::mva_is_bas_model (const qn::NetworkStruct< T > &L) |
| Port of isBasModel in solver_mva_analyzer.m: a closed single-CHAIN model with at least one blocking-after-service drop rule, which SQD handles and neither exact MVA nor AMVA does. | |
| template<class T> | |
| bool | line::mva::sn_is_bas_model (const qn::NetworkStruct< T > &L) |
| Port of matlab/src/api/sn/sn_is_bas_model.m: a closed single-CLASS model with a BAS drop rule. | |
| template<class T> | |
| bool | line::mva::sn_is_mm1k_loss (const qn::NetworkStruct< T > &L) |
| Port of matlab/src/api/sn/sn_is_mm1k_loss.m: a single-class open Source-Queue-Sink system whose queue is a single-server exponential M/M/1/K with tail drop. | |
| template<class T> | |
| bool | line::mva::amva_uses_pf_kernels (const qn::NetworkStruct< T > &L) |
| Conservative form of the branch test in solver_amva: true when this model may be solved by the product-form AMVA kernels rather than by solver_amvald. | |
| template<class T> | |
| bool | line::mva::mva_carries_interlock (const qn::NetworkStruct< T > &L, const MvaOptions &opt) |
| True when the MVA path this model already dispatches to carries a class-level interlock matrix (Franks 1999, Eq. | |
| template<class T> | |
| MvaSolution< T > | line::mva::solver_mva_analyzer (const qn::NetworkStruct< T > &L, const MvaOptions &opt, const Matrix< T > &init_sol) |
| Port of solver_mva_analyzer.m, default and the explicit method names. | |
SolverMVA over a SolverLN layer.
Ports of matlab/src/solvers/MVA/solver_mva.m (exact BCMP MVA), solver_amvald.m + solver_amvald_forward.m (the general approximate MVA), and solver_amva.m + solver_mva_analyzer.m (the method dispatch that chooses between them). The chain aggregation they all sit on is in sn_chain.h.
SCOPE. The dispatch reproduces the default ladder in full, since it is what decides which algorithm each layer gets and therefore what the numbers are. The algorithms behind it are ported for the disciplines a layered model produces – INF, PS, FCFS, SIRO, LCFSPR – with the default and seidmann multiserver approximations and the default high-variance setting. Priority (HOL), discriminatory sharing (DPS), load- and class-dependence, the suri and softmin multiserver variants, the queue-line and fraction-line estimators and open classes are REFUSED by name. Each is a distinct approximation, and mapping any of them onto a neighbour would return a plausible number that is not the reference's.
ARITHMETIC. Everything here is field arithmetic. The AMVA loops stop on a tolerance, so an exact run returns the iterate its stopping rule selected, computed without rounding; see the gate note in pfqn_egflinearizer.h.
Definition in file solver_mva.h.
1.18.0