solvers.MVA

solver_mvald(sn, options): [Q,U,R,T,C,X,LG,iter] = SOLVER_MVALD(SN, OPTIONS)

solver_amvald_forward(M, K, nservers, schedparam, lldscaling, cdscaling, jdscaling, sched, classprio, gamma, tau, Xchain_ref, Qchain_in, Xchain_in, Uchain_in, STchain_in, Vchain_in, Nchain_in, SCVchain_in, options): Xchain_ref is the throughput vector the tau differences were taken against. tau(s,r) = X_r(N-1_s) - Xchain_ref(r), so Xchain_ref(r) + tau(s,r) is an arrival-instant throughput from one and the same sweep; adding tau to the moving inner iterate instead mixes two sweeps and can exceed the service capacity. Empty when no Linearizer recursion runs, i.e. when tau is zero.

solver_amvald(sn, Lchain, STchain, Vchain, alpha, Nchain, SCVchain, refstatchain, options)

mva_carries_interlock(sn, options)

MVA_CARRIES_INTERLOCK True when the MVA path this model already dispatches to carries a class-level interlock matrix (Franks 1999, Eq. 4.7) itself, so that supplying one does not silently move the model to a DIFFERENT algorithm.

Only two kernels implement the correction: PFQN_MVA (exact, closed single-server) and the AMVA forward step of SOLVER_AMVALD. A model that would otherwise be solved by exact multiserver or mixed MVA, or by the product-form AMVA kernels (linearizer and relatives), cannot take the matrix without swapping its algorithm, and the swap is worth far more than the correction it carries: inside SolverLN it can turn a converging Picard iteration into a limit cycle. A caller holding a matrix such a model cannot carry must apply its own correction instead (SolverLN keeps the residt scaling there).

The test is deliberately conservative: where the AMVA product-form branch is entered only for some resolved methods, this reports it entered for all of them, since refusing the matrix falls back on the caller’s own handling rather than on a changed algorithm.

solver_mva_qsys_sizebased_analyzer(sn, options, schedType)

[Q,U,R,T,C,X,LG,RUNTIME,ITER] = SOLVER_MVA_QSYS_SIZEBASED_ANALYZER(SN, OPTIONS, SCHEDTYPE)

Analyzer for M/G/1 queueing systems with size-based scheduling. Supports: SRPT, PSJF, FB/LAS, LRPT, SETF

This function handles multiclass open queueing systems with size-based scheduling policies using the analytical formulas from:

A. Wierman and M. Harchol-Balter, “Classifying scheduling policies with respect to unfairness in an M/GI/1”, SIGMETRICS 2003.

solver_mva_sum(sn, options)

[Q,U,R,T,C,X,LG,ITER] = SOLVER_MVA_SUM(SN, OPTIONS)

Summation method (SUM/ESUM) analyzer. Closed models are solved with sum_closed; open and mixed models with sum_closing (closing method, Kclosed=5000). FCFS and SIRO stations use their service SCVs (ESUM corrections for scv~=1); PS, LCFS-PR and infinite-server stations are insensitive and are passed scv=1. See api/sum and Bolch et al., Secs. 9.2, 10.1.4.4 and 10.1.5.

solver_mva_qsys_prio_analyzer(sn, options)

[Q,U,R,T,C,X,LG,RUNTIME,ITER,ACTUALMETHOD] = SOLVER_MVA_QSYS_PRIO_ANALYZER(SN, OPTIONS)

Exact non-preemptive priority (HOL) analyzer for a single open M/G/1 queue with Poisson per-class arrivals: dispatches to the Cobham formula (qsys_mg1_prio) instead of the AMVA preemptive shadow-server approximation, which underestimates the waiting time of every class.

solver_mva_polling_analyzer(sn, options): [Q,U,R,T,C,X,LG,RUNTIME,ITER,ACTUALMETHOD] = SOLVER_MVA_POLLING_ANALYZER(QN, OPTIONS)

solver_mva_marie_analyzer(sn, options)

[QN,UN,RN,TN,CN,XN,LG,RUNTIME,LASTITER,ACTUALMETHOD] = SOLVER_MVA_MARIE_ANALYZER(SN, OPTIONS)

Marie’s iterative aggregation-decomposition (Marie 1979/1980) for closed networks with FCFS non-exponential (Coxian) service, wired as SolverMVA method ‘marie’. Infinite-server stations fold into per-chain think time; pfqn_marie is applied to the queueing stations, where only FCFS is service- sensitive (its SCV is used) while insensitive product-form disciplines (PS, LCFSPR) are forced to exponential. Chain results are then deaggregated to classes via sn_deaggregate_chain_results.

Single chain: aggregate is the exact load-dependent product-form solve, so exponential service is exact. Multiple chains: aggregate is QD-AMVA with class-dependent scaling, exact for product form and approximate otherwise.

solver_sqd(sn, options)

[Q,U,R,T,C,X,LG,ITER] = SOLVER_BAS(SN, OPTIONS)

Blocking-After-Service (BAS) approximate MVA handler.

Wraps npfqn_sqd (chain-aggregated approximation): solves the single closed chain, then disaggregates the chain-level throughput, queue length and utilization back to per-class results via sn_deaggregate_chain_results. Supports single-chain closed networks (one or more classes connected by class switching); multi-chain models are rejected, since the BAS approximation models a single circulating population.

solver_mva_mapqn_analyzer(sn, options)

[QN,UN,RN,TN,CN,XN,LG,RUNTIME,LASTITER,ACTUALMETHOD] = SOLVER_MVA_MAPQN_ANALYZER(SN, OPTIONS)

SolverMVA method ‘amva.mapqn’: the horizontal-cut mean value analysis of a closed multiclass network with one exponential delay station and one FCFS single-server queue whose class-r service is a MAP (mapqn_amva). The structural premise is checked by mva_mapqn_reason, the same predicate that offers and reports the method. Metrics: at the queue Q_r, U_r = X_r E[S_r] and R_r = Q_r / X_r; at the delay Q_r = U_r = X_r Z_r and R_r = Z_r; C_r = N_r / X_r. lG is NaN: the recursion carries no normalizing constant.

solver_mvald_analyzer(sn, options): [Q,U,R,T,C,X,RUNTIME,ITER] = SOLVER_MVALD_ANALYZER(SN, OPTIONS)

solver_mva_analyzer(sn, options): [Q,U,R,T,C,X,LG,RUNTIME] = SOLVER_MVA_ANALYZER(QN, OPTIONS)

solver_rqna(sn, options)

[Q,U,R,T,C,X,lG,totiter] = SOLVER_RQNA(SN, OPTIONS)

Robust Queueing Network Analyzer (RQNA) based on indices of dispersion. Approximates the steady-state performance of a single-class open queueing network of single-server FCFS queues with Markovian routing and general (non-renewal) external arrival and (non-exponential) service processes.

Reference: W. Whitt and W. You (2018), “A Robust Queueing Network Analyzer Based on Indices of Dispersion”, INFORMS J. on Computing. This routine implements Algorithm 1 (general framework): traffic-rate equations, limiting variability equations, time-dependent IDC equations with default correction terms alpha (eq. 34) and beta (eqs. 38-39), and the robust-queueing (RQ) workload approximation (eq. 13) with the derived performance measures.

solver_mva_qsys_analyzer(sn, options): [Q,U,R,T,C,X,LG,RUNTIME,ITER,ACTUALMETHOD] = SOLVER_MVA_QSYS_ANALYZER(QN, OPTIONS)

solver_mva_lcfsqn(sn, options, lcfsStat, lcfsprStat)

[Q,U,R,T,C,X,LG] = SOLVER_MVA_LCFSQN(SN, OPTIONS, LCFSSTAT, LCFSPRSTAT) Specialized MVA solver for LCFS + LCFS-PR 2-station networks

This function wraps the pfqn_lcfsqn algorithm and maps LINE’s data structures to/from the algorithm’s expected format.

Parameters:

sn - network structure
options - solver options
lcfsStat - index of the LCFS station
lcfsprStat - index of the LCFS-PR station

Returns:

Q - queue length matrix (stations x classes) U - utilization matrix (stations x classes) R - response time matrix (stations x classes) T - throughput matrix (stations x classes) C - cycle time vector (1 x classes) X - throughput vector (1 x classes) lG - log of normalizing constant (NaN for this method)

mva_marie_reason(sn)

REASON = MVA_MARIE_REASON(SN)

The structural premise of the SolverMVA method ‘marie’: the reason it cannot solve SN, or ‘’ when it can. One predicate, two callers: supportsModelMethod reports it (through SolverMVA.supportsMarie) and solver_mva_marie_analyzer raises it, so the reported and the run answers cannot drift apart. listValidMethods withholds the name on the two halves that make the whole family pointless, an open model and class-dependent routing; the other halves are reported here rather than hidden.

The premise is the model of pfqn_marie: a closed network whose infinite-server stations fold into a per-chain think time and whose queueing stations are FCFS (service-sensitive, the SCV is read), PS or LCFS-PR (insensitive, taken exponential), each isolated from its chain demands alone, so no cache, no fork-join and no load-, class- or joint-dependent scaling, with a multiserver station admitted only when there is a single chain, the one case the isolation carries a server count. The nameable halves (open class, cache, fork-join, scaling, discipline) are also dropped from the method’s feature set in SolverMVA.getMethodFeatureSet, so the report names the offending feature; the rest is structural and lives here alone.

mva_mapqn_reason(sn)

REASON = MVA_MAPQN_REASON(SN)

The structural premise of the SolverMVA method ‘amva.mapqn’: the reason it cannot solve SN, or ‘’ when it can. One predicate, three callers: listValidMethods drops the name when it is nonempty, supportsModelMethod reports it, and solver_mva_mapqn_analyzer raises it, so the offered, reported and run answers cannot drift apart.

The premise is the model of mapqn_amva: a closed network of exactly one infinite-server station with exponential think times and one FCFS single-server queue whose service processes are Markovian (any process with a (D0,D1) representation: Exp, Erlang, HyperExp, PH, APH, Coxian, MAP, MMPP2), every class cycling delay -> queue -> delay. Only the station count, the server count, the think-time law and the routing shape are structural; MAP support itself is a feature-set matter and lives in SolverMVA.getMethodFeatureSet.

solver_mva_oi_analyzer(sn, options)

SOLVER_MVA_OI_ANALYZER Exact mean-value MVA for order-independent networks

An order-independent (OI) station is a class-dependent load-dependent server whose total service rate mu(n) is a permutation-invariant function of the per-class count vector n. A closed network of infinite-server (delay) and load-independent (single-server, product-form) stations plus ANY number of OI stations is product-form. This analyzer aggregates the delay stations into a single think-time vector Z, collects the load-independent (LI) queue demands and the OI-station rate handles, and calls PFQN_MVAOI, the mean-value Conditional-MVA (CMVA) that carries one rate-shift vector per OI station and returns exact per-class throughput and queue-lengths WITHOUT any normalizing constant or joint marginal. The marginal-distribution counterpart is PFQN_MVAOI_MARG.

Reference:: Reiser, Lavenberg (1980). Mean-Value Analysis of Closed Multichain Queuing Networks. JACM 27(2). Load-dependent extension: Bruell, Balbo, Afshari (1984). OI stations / CMVA: Casale (2009); Casale, Comte, Dorsman (2026).

solver_amva(sn, options)

[Q,U,R,T,C,X,lG,ITER] = SOLVER_AMVA(SN, OPTIONS)

solver_rqt(sn, options)

[Q,U,R,T,C,X,lG,totiter] = SOLVER_RQT(SN, OPTIONS)

Robust Queueing Network Analyzer (RQNA) of Robust Queueing Theory. Estimates the steady-state performance of a single-class open network of FCFS queues with Markovian routing by replacing the stochastic primitives with polyhedral uncertainty sets and taking a worst-case view of each node in isolation.

The algorithm is Section 7.2 of the reference: (1) the external streams get Gamma_a = sigma_a, (2) the effective arrival process at each node follows from the network characterization of Theorem 10 (NPFQN_TRAFFIC_RQT), (3) the service variability parameter follows from the adaptation of Section 7.1 (QSYS_GIGK_RQT_GAMMA), and (4) the system time at each node is the worst-case bound of Theorem 3 (QSYS_GIGK_RQT). Step 3 of the published algorithm, the path enumeration, is not needed here: LINE aggregates per-node system times into per-class response times through the visit ratios.

The adaptation of step (3) is regressed against simulation in heavy traffic, so accuracy degrades at low utilization: on M/M/1 the error is about 8% at rho=0.9 but over 50% at rho=0.5. Use ‘qna’ or an exact method for lightly loaded models.

Tail coefficients default to alpha=2, the finite-variance regime; set options.config.rqt_alpha_a and options.config.rqt_alpha_s (scalars, or vectors over stations) in (1,2] to declare heavy-tailed streams, which LINE’s distributions cannot express since they carry finite moments. options.config.rqt_regime selects the Table 1 adaptation regime (‘independent’, ‘normal’, ‘pareto’) and options.config.rqt_exact replaces the closed-form bound by the exact worst case over the uncertainty sets.

Reference: C. Bandi, D. Bertsimas, N. Youssef (2015). Robust Queueing Theory. Operations Research 63(3), 676-700.

solver_mva_cacheqn_analyzer(self, options)

[Q,U,R,T,C,X,LG,RUNTIME,ITER] = SOLVER_MVA_CACHEQN_ANALYZER(SELF, OPTIONS)

Integrated cache-queueing analyzer: delegates the decomposition- aggregation alternation between the isolated caches and the queueing network to da_cacheqn, supplying the MVA-specific isolated-cache miss algorithm (exact cache_mva or FPI approximation) and network solver.

solver_mva(sn, options): [Q,U,R,T,C,X,LG] = SOLVER_MVA(SN,OPTIONS)

mva_is_bas_model(sn)

MVA_IS_BAS_MODEL Detect a closed single-chain network with Blocking-After-Service (BAS) finite-buffer blocking, which solver_sqd handles but exact/AMVA MVA does not.

solver_qna(sn, options)

[Q,U,R,T,C,X,lG,totiter] = SOLVER_QNA(QN, OPTIONS)

Implementation as per Section 7.2.3 of N. Gautaum, Analysis of Queues, CRC Press, 2012. Minor corrections applied in discussion with the author.

Decomposition-aggregation structure: each sweep superposes the flows into every station (da_traffic_superpos aggregation), solves the stations in isolation, and splits the departure flows; the sweeps are driven to a fixed point on the queue lengths by da_fpi.

solver_mva_sjn_analyzer(sn, options)

[Q,U,R,T,C,X,LG,RUNTIME,TOTITER,ACTUALMETHOD] = SOLVER_MVA_SJN_ANALYZER(SN, OPTIONS)

Analyzer for closed networks with non-preemptive shortest-job-next (SJF) stations. The station is modelled by the conditional waiting time equation of K. Kant, “MVA approximations for SJN scheduling”, Performance Evaluation 15(1):41-61, 1992, evaluated either over the full population lattice (pfqn_mvasjn) or through its Schweitzer fixed point (pfqn_amvasjn).

The lattice costs prod(N+1) steps, so ‘default’ switches to the fixed point once the lattice exceeds options.config.sjn_lattice_max states. Ask for ‘exact’ or ‘mva’ to force the lattice, ‘amva’ to force the fixed point. ‘default’ also falls back to the fixed point when the lattice reports the starvation regime, where it has no valid continuation.

solver_mva_retrieval_analyzer(sn, options)

[Q,U,R,T,C,X,LG,HITPROB,MISSPROB,DELAYEDPROB,HITPROBLIST,LATENCY,RUNTIME,METHOD] = SOLVER_MVA_RETRIEVAL_ANALYZER(SN, OPTIONS)

Fixed-point approximation of a delayed-hit (retrieval-system) cache via the FPI algorithms: retrieval_fpi (hit / miss / delayed-hit ratios) and retrieval_fpi_latency (expected latency Z, eq:latency tot).

solver_mvac(sn, options)

[Q,U,R,T,C,X,LG] = SOLVER_MVAC(SN,OPTIONS)

Exact mean value analysis by chain (MVAC, Conway-de Souza e Silva-Lavenberg 1989) via pfqn_mvac. Closed product-form networks of single-server fixed-rate (SSFR) queues and infinite-server centers only.

solver_mva_cacheqn_retrieval_analyzer(sn, options)

[…] = SOLVER_MVA_CACHEQN_RETRIEVAL_ANALYZER(SN, OPTIONS)

Analyzer for a CLOSED integrated cache-queueing model whose Cache node has a delayed-hit retrieval system. Delegates to da_cacheqn_retrieval, which relabels the cache as a class switch and lets the finite-population coalescing emerge from the closed AMVA via a load-dependent fetch station. Returns the true cache hit/miss probabilities (hit = P(item cached), miss = 1 - hit); the delayed-hit fraction is folded into miss (delayedprob = 0).

solver_mva_cache_analyzer(sn, options): [Q,U,R,T,C,X,LG,RUNTIME,ITER,METHOD,HITPROBLIST] = SOLVER_MVA_CACHE_ANALYZER(QN, OPTIONS)