solvers.NC

nc_oi_refusal(sn, route)

REASON = NC_OI_REFUSAL(SN, ROUTE)

May the order-independent route ROUTE run on this model? ‘’ when it may, otherwise the reason it may not, in the words the analyzer refuses with.

ROUTE = ‘oi’ the exact OI convolution, SOLVER_NC_OI_ANALYZER, reached on
the shape NC_IS_OI_MODEL tests for;

ROUTE = ‘pas’ the importance sampler of the two-station pass-and-swap
tandem, SOLVER_NC_PAS_IS_ANALYZER, reached on the shape NC_IS_PAS_MODEL tests for (and on an OI model asked for by ‘is’ or ‘sampling’).

The shape predicates say which analyzer a model reaches; this one says what that analyzer then refuses. The rank rate mu(supp n) of an OI station is a function of the RAW classes present, so a chain that switches class has no rank rate; the sampler places one job of each class per position, so it needs unit per-class visits; and both routes are intercepted by @SolverNC/runAnalyzer AHEAD of the load-dependent and fork-join dispatches and build every BCMP station table from the server count alone, so a rate lattice would be dropped and a Fork would send the model to an image with open auxiliary classes, on which neither shape holds.

ONE PREDICATE, THREE CALLERS. Each analyzer asks it first and turns a non-empty answer into an error; NC_METHOD_REFUSAL asks it so that MODEL.HELP never offers a pair the run refuses. A new rule goes here.

nc_sdr_refusal(sn)

REASON = NC_SDR_REFUSAL(SN)

May SOLVER_NC_SDR_ANALYZER run on this model? ‘’ when it may, otherwise the reason it may not, in the words the analyzer refuses with. A model that declares no state-dependent routing is not that route’s business and gets ‘’.

The product form of Krzesinski (1987), “Multiclass Queueing Networks with State-Dependent Routing”, Performance Evaluation 7:125-143, eq. (16), is stated over the queue lengths of a CLOSED network whose customers keep their class, at BCMP centres whose f_i(n_i) admits chain-dependent rates only at the symmetric disciplines. Each clause below is one of those premises.

ONE PREDICATE, TWO CALLERS. The analyzer asks it first and turns a non-empty answer into an error; NC_METHOD_REFUSAL asks it so that MODEL.HELP never offers a pair the run refuses. A new rule goes here, not at a call site.

nc_is_lossn_model(sn)

[ISLOSSN, HASSHAPE] = NC_IS_LOSSN_MODEL(SN)

Is this the loss network SOLVER_NC_LOSSN_ANALYZER solves, i.e. an OPEN model with a single finite capacity region whose only member is an infinite server, and whose admission rule DROPS every class?

HASSHAPE reports the topology alone, without the DROP demand: a region of that shape under WAITQ (or any blocking rule) holds the arrival back instead of discarding it, which keeps the job in the region while it waits and is a queueing phenomenon the Erlang loss model has no state for. The two answers are returned separately because they have different remedies – switching the rule to DROP makes the first solvable here, while the second needs a solver that carries the region as state.

Factored out of @SolverNC/runAnalyzer, which decided the same question inline and could therefore not be asked it by the support gate; see NC_METHOD_REFUSAL.

solver_nc(sn, options)

nc_multiserver_policy(options)

POLICY = NC_MULTISERVER_POLICY(OPTIONS)

Resolves options.config.multiserver into the multiserver handling SolverNC implements. SolverNC represents a finite multiserver station in one of two ways: Seidmann’s approximation (demand L/c plus a delay L(c-1)/c, applied in SOLVER_NC) or the exact load-dependent lattice mu(n)=min(n,c), which routes the model to SOLVER_NCLD. Returns one of:

‘default’ the historical dispatch: Seidmann on method ‘default’, the
load-dependent lattice on method ‘exact’/’is’/’panald’, and the lattice on the 2-station Delay+multiserver topology

‘seidmann’ Seidmann everywhere, including on ‘exact’ ‘lld’ the load-dependent lattice everywhere it is admissible,

including on method ‘default’

options.config.multiserver is a field of the GENERAL SolverOptions, shared with SolverMVA, which implements approximations SolverNC has no counterpart for (‘softmin’, ‘conway’, ‘krzesinski’, ‘suri’, ‘erlang’). Those are not errors here – one options struct is commonly reused across solvers – but they are not silently honoured either: they warn and fall back to ‘default’.

nc_is_dps_model(sn)

ISDPS = NC_IS_DPS_MODEL(SN)

True when the model is the closed two-station network that Morrison’s heavy-usage asymptotic expansion is derived for: one infinite-server (think) station and one single-server discriminatory-processor-sharing station, with exponential service everywhere and every class alternating between the two. Such models are solved by SOLVER_NC_DPS_ANALYZER (npfqn_dps_morrison).

The shape is checked exactly, not approximately: outside it the expansion has no derivation behind it, so a model that misses any clause here is left to the ordinary NC routes (which refuse DPS) rather than answered wrongly.

solver_nc_spn_analyzer(model, sn, options)

[QN,UN,RN,TN,CN,XN,LG,RUNTIME,METHOD,PF] = SOLVER_NC_SPN_ANALYZER(MODEL, SN, OPTIONS) Stationary analysis of a PRODUCT-FORM stochastic Petri net by MDD-rec: the normalising constant is obtained from one memoised walk of the decision diagram holding the reachable set, and every reported measure is a masked walk of the same diagram.

This is the ‘rec’ method of SolverNC, and the first analytical route LINE offers for a Petri net – CTMC solves the explicit generator, SSA and LDES simulate, FLD fluidises. Three functions do the work and each is the subject of its own reference:

SPN_PF decides the product form and derives the per-place factors g_l
(Coleman-Henderson-Taylor complex balance)

MDD_REC G = sum_S prod_l g_l(s_l) in O(sum_l nodes_l * |S_l|) rather
than O(|S|) (Balsamo-Marin-Stojic)

SPN_METRICS mean tokens, place and mode utilisation, and throughputs, all
from masked walks of the same diagram (Balsamo-Marin-Stojic)

WHAT THIS REACHES THAT THE EXPLICIT GENERATOR DOES NOT. The diagram stores the reachable set, never the generator, so the cost is set by the number of diagram nodes and not by |S|. It also does not need the marking to be a conserved job population: a mode may consume two tokens and produce one, or consume one and produce two, which is the fork-join and batch case that the MDD-rec paper exists to serve.

– Output QN,UN,RN,TN : per (Place station, class): mean tokens, utilisation, Little

response time and token throughput

UN FOLLOWS LINE, NOT THE PAPER. A Place is an INF station, and LINE reports U = Q at an infinite server, which is what SolverCTMC returns for the same net. The paper’s place utilisation u(P_j) = 1 - P(m_j = 0) is a different quantity and is reported separately, as PF.metrics.placeUtil. CN,XN : per class, system response time and throughput at the reference LG : log of the normalising constant PF : the SPN_PF certificate (kind, complexes, deficiency, y, …)

See also: spn_pf(), mdd_rec(), spn_metrics(), spn_mdd(), SolverNC.

solver_nc_sdr_analyzer(sn, options)

[QN,UN,RN,TN,CN,XN,LG,RUNTIME,ITER,METHOD] = SOLVER_NC_SDR_ANALYZER(SN, OPTIONS)

Exact product-form analysis of a closed multiclass network with the state-dependent routing of Krzesinski (1987), “Multiclass Queueing Networks with State-Dependent Routing”, Performance Evaluation 7:125-143. The joint distribution is eq. (16); the coefficients xi are those of Section 3.2, obtained from the state-independent part of the routing matrix.

solver_nc_cacheqn_analyzer(self, options)

[Q,U,R,T,C,X,LG,RUNTIME,ITER] = SOLVER_NC_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 NC-specific isolated-cache miss algorithm (exact recursion or SPM approximation) and network solver.

solver_ncld(sn, options): [Q,U,R,T,C,X,LG,RUNTIME,ITER.METHOD] = SOLVER_NCLD(QN, OPTIONS)

solver_nc_jointaggr(sn, options)

[PR,G,LG,RUNTIME] = SOLVER_NC_JOINTAGGR(QN, OPTIONS)

LG is the LOG normalizing constant, returned in the same slot as in solver_nc_joint so that the two callers can be written alike. It is what the analyzer computes; G = exp(LG) is the derived value and underflows first.

solver_nc_pas_is_analyzer(sn, options)

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

Importance-sampling (IS) normalizing-constant analysis of a closed two-station pass-and-swap (P&S) tandem with a non-empty swap graph (Casale, Comte & Dorsman, 2026). With a genuine swap graph the ordered-state chain is reducible (Comte & Dorsman, 2021, arXiv:2009.12299); the recurrent communicating class carries a per-class product form pi(c) = Phi_1(c_1) Phi_2(c_2)/G_C, and its constant G_C is estimated by the auto-normalized IS routine PFQN_PAS_IS. This is the Monte-Carlo counterpart of SOLVER_NC_OI_ANALYZER for the case that the exact OI convolution does not apply (non-empty swap graph).

Station 1 is the upstream P&S queue (prefix of the ordering), station 2 the downstream queue (reversed suffix); the swap graph is a class-level property read from the upstream station. Both stations must be OI/P&S with unit per- class visits (the balanced-fairness framework). Mean per-class queue lengths come directly from PFQN_PAS_IS (auto-normalized IS, same samples for numerator and denominator). Per-class throughput uses the balanced-fairness ratio X_r = G(N - e_r)/G(N) with common random numbers across the N and N-e_r runs for variance reduction; utilization, response time, and system time follow the same conventions as SOLVER_NC_OI_ANALYZER.

solver_nc_mem_supports(sn)

[SUPPORTED, REASON, BLOCKING] = SOLVER_NC_MEM_SUPPORTS(SN)

Checks whether the Maximum Entropy Method (Kouvatsos 1994) supports the model described by the network structure SN. Returns SUPPORTED=true and an empty REASON when the model is a plain open queueing network (Section 3.2: Source, Queue, Delay and Sink nodes; GE/GE/1, GE/GE/c and GE/GE/inf building blocks), a plain closed queueing network (Section 3.3: Queue and Delay nodes; G/G/1 and G/G/inf building blocks only, so finite multiserver stations are rejected), or a mixed open/closed network (composition of the two algorithms; single-server and IS stations only), in all cases without class switching and with non-priority scheduling disciplines only; otherwise SUPPORTED=false and REASON explains the first unsupported feature found.

An open model with finite station buffers is also supported, provided it is single class: it is then solved by the censored GE/GE/c/0;N building block of Section 4.1, under loss (drop rule DROP) or transfer blocking (drop rule BAS, holding-node expansion of Tahilramani, Manjunath and Bose 1999). BLOCKING returns true for such a model, so the caller can route it to ME_OQN_BLK instead of ME_OQN. The GE distribution is only defined for scv >= 1, so a finite-buffer model with a hypo-exponential service or arrival process is rejected rather than approximated.

solver_nc_cacheqn_retrieval_analyzer(sn, options)

[…] = SOLVER_NC_CACHEQN_RETRIEVAL_ANALYZER(SN, OPTIONS)

NC analyzer for a CLOSED integrated cache-queueing model whose Cache node has a delayed-hit retrieval system. Delegates to da_cacheqn_retrieval with an NC network solve (load-dependent when the coalescing fetch station is present). Returns the true cache hit/miss probabilities (hit = P(item cached), miss = 1 - hit); the delayed-hit fraction folds into miss (delayedprob = 0).

nc_is_pas_model(sn)

ISPAS = NC_IS_PAS_MODEL(SN)

True when the model is a closed two-station pass-and-swap (P&S) tandem: both stations are OI/PAS (SchedStrategy.OI or SchedStrategy.PAS) and there is no other station. The swap graph may be empty, since an order-independent (OI) queue is exactly the P&S specialization with an empty/zero swap graph: the importance-sampling analyzer SOLVER_NC_PAS_IS_ANALYZER covers both, as PFQN_PAS_IS with H=0 samples all microstates and reduces to PFQN_OI_IS.

Used to bind the importance-sampling selectors (‘is’, and ‘sampling’ which maps to ‘is’ in the presence of OI/PAS stations). Note that a P&S tandem with a NON-EMPTY swap graph is reducible (Comte & Dorsman, 2021) and lies outside the exact path of NC_IS_OI_MODEL / SOLVER_NC_OI_ANALYZER, so it also takes this analyzer on ‘default’; a pure-OI tandem on ‘default’/’exact’ is caught earlier by the exact OI analyzer.

nc_is_oi_model(sn)

ISOI = NC_IS_OI_NC_MODEL(SN)

True when the model is a closed queueing network that contains at least one order-independent (OI) station (SchedStrategy.OI, or PAS with an empty swap graph) and every other station is a BCMP product-form station: infinite server (delay), PS, LCFS-PR, SIRO, or class-independent-rate FCFS. Such models are solved exactly by SOLVER_NC_OI_NC_ANALYZER. The OI requirement keeps pure-BCMP networks on the standard (faster) normalizing-constant path.

solver_nc_lcfsqn(sn, options, lcfsStat, lcfsprStat)

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

This function wraps the pfqn_lcfsqn_ca algorithm and computes performance metrics using the convolution approach.

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

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

solver_nc_margaggr(sn, options, lG): [PR,G,LG,RUNTIME] = SOLVER_NC_MARGAGGR(QN, OPTIONS)

solver_nc_marg(sn, options, lG): [PR,G,RUNTIME] = SOLVER_NC_MARG(QN, OPTIONS)

solver_nc_jointaggr_ld(sn, options): [PR,G,LG,RUNTIME] = SOLVER_NC_JOINTAGGR(QN, OPTIONS)

solver_nc_joint(sn, options): [PR,G,LG,RUNTIME] = SOLVER_NC_JOINT(QN, OPTIONS)

solver_nc_cache_analyzer(sn, options): [Q,U,R,T,C,X,LG,PIJ,RUNTIME,METHOD,HITPROBLIST,ITEMPROB,LISTCOST] = SOLVER_NC_CACHE_ANALYZER(QN, OPTIONS)

nc_method_refusal(sn, method, options, forReport)

REASON = NC_METHOD_REFUSAL(SN, METHOD, OPTIONS, FORREPORT)

May METHOD run on this model? ‘’ when it may, otherwise the reason it may not, in the words the analyzer refuses with.

FORREPORT (default TRUE) says WHICH QUESTION IS BEING ASKED, and for two method names the two questions have different answers:

true – “should MODEL.HELP offer this pair?” A pair that comes back as a
table of zeros must not be offered, so the answer is no.

false – “what does the reference DO when asked for it by name?” For
‘mmint2’ and ‘gleint’ outside their shape the reference deliberately WARNS AND RETURNS A ZERO TABLE (pfqn_nc.m, case {‘mmint2’,’gleint’}: lG = [] and return, unconditionally), and a caller who names the method keeps that answer.

THE ASYMMETRY IS A RULING, NOT AN OVERSIGHT (2026-07-25, reaffirmed when this gate was added): the report answers “should this be offered” and the run answers “what does the reference do”. ‘comomld’ is NOT in that bucket – PFQN_COMOMRM_LD raises ‘The solver accepts at most a single queueing station.’ natively – so it is refused on both paths.

ONE PREDICATE, TWO CALLERS. @SolverNC/runAnalyzer asks it once, ahead of the dispatch, and turns a non-empty answer into an error; SOLVERNC.SUPPORTSMODELMETHOD asks it so that MODEL.HELP and MODEL.FINDSOLVER never offer a (solver,method) pair that would raise, and so that SOLVERAUTO never delegates to one. Two copies of these rules is precisely how the report and the run drift apart, which is the failure this function exists to prevent, so a new rule goes here and not at a call site.

ONLY WHAT THE FEATURE REGISTRY CANNOT NAME LIVES HERE. A feature set says “I ACCEPT this construct”, so it can refuse a model for HAVING something and never for LACKING it: “no think time” and “closed population only” are therefore expressed in SOLVERNC.GETMETHODFEATURESET by dropping SchedStrategy_INF and OpenClass, while “requires a cache”, “requires state-dependent routing”, “requires a loss network”, “requires exactly two stations” and “requires normal usage” have no such form and are decided here. So is “THIS ROUTE READS NO METHOD NAME”: the loss network, the M/M/1/K closed form, the paired LCFS convolution, the SDR product form and the cache analyzers each switch on a few method names and answer every other name with their own default, which would come back under the caller’s label.

nc_lcfs_refusal(sn)

REASON = NC_LCFS_REFUSAL(SN)

May the paired LCFS / LCFS-PR route of SOLVER_NC run on this model? ‘’ when it may, otherwise the reason it may not, in the words SOLVER_NC refuses with. A model with no LCFS station is not that route’s business and gets ‘’.

A non-preemptive LCFS station is served by SOLVER_NC_LCFSQN alone, the convolution of Casale (QUESTA 2026) for the closed two-station network of one LCFS and one LCFS-PR station; PFQN_LCFSQN_CA reads the two stations’ per-class rates and the per-class populations and nothing else, so anything the shape does not name is not ignored by accident but has no term in the product form: a third station, a self-loop, a server count above one, a rate lattice, a class that switches, an open chain (the fork-join image carries the parallelism as OPEN auxiliary classes, so a Fork counts as one).

ONE PREDICATE, TWO CALLERS. SOLVER_NC asks it ahead of the LCFS arm and turns a non-empty answer into an error; NC_METHOD_REFUSAL asks it so that MODEL.HELP never offers a pair the run refuses. A new rule goes here.

nc_is_normal_usage(sn, form)

TF = NC_IS_NORMAL_USAGE(SN, FORM)

Is the closed model in NORMAL USAGE, the domain of the Mitra-McKenna PANACEA asymptotic expansion (J. ACM 33(3), 1986)?

Normal usage asks that every queueing centre be able to absorb the load the think stations offer it: with rho_j0 = Ztot(j) the aggregate think demand of chain j, r_ij = L_ij / rho_j0 and mu_i(Ntot) the saturation rate,

alpha_i = 1 - (sum_j N_j r_ij) / mu_i(Ntot) > 0 for every centre i.

Outside it the {phi(n)} series of the expansion DIVERGES, which is why PFQN_PANACEALD returns NaN there and PFQN_NCLD turns that NaN into a refusal rather than a numerical warning. This is a property of the demands and not of a construct the model declares, so it has no feature-registry name and cannot live in a feature set; NC_METHOD_REFUSAL is what carries it to the support gate.

The rates are the ones SOLVER_NCLD would build: mu_i(n) = 1 for an ordinary single server, min(n,c) for a finite multiserver (the conversion runAnalyzer performs on the ‘panald’ arm), and the declared sn.lldscaling row when the model sets one. An infinite server is a think station and contributes to Ztot rather than to the centres.

FORM selects which of the two shapes the demands take on the way to the expansion. ‘lattice’ (default) is the load-dependent one above, what PFQN_PANACEALD receives. ‘seidmann’ is the load-INDEPENDENT one of the ‘pana’ arm of PFQN_NC, which SOLVER_NC reaches through Seidmann’s approximation: a c-server centre enters as demand L/c with mu_i(n) = 1 and its remainder L(c-1)/c is added to the think demand, so a multiserver model may be in normal usage in one form and not in the other, and the gate has to ask the form the run will take.

nc_lld_from_nservers(sn, latticeMax)

LLDSCALING = NC_LLD_FROM_NSERVERS(SN, LATTICEMAX)

Represents every finite multiserver station of a closed model as the exact load-dependent rate lattice mu(n)=min(n,c), the form SOLVER_NCLD consumes and PFQN_NCLD solves exactly. Returns [] when the conversion does not apply, in which case the caller keeps Seidmann’s approximation:

no finite station has more than one server (forcing the lattice on an all-single-server model mishandles a self-looping closed chain)

the total population is not finite (an open or mixed model)

the per-chain population lattice exceeds LATTICEMAX

LATTICEMAX prices the exact enumeration SOLVER_NCLD performs, whose cost is unbounded in N while the multiserver test is topological. Callers pass the same 6000-state budget SolverCTMC uses for exact enumeration.

The server count c is left on sn.nservers: SOLVER_NCLD keeps reading it to normalize utilization, and LLD_ENCODES_MULTISERVER recognises the pairing.

solver_nc_dps_analyzer(sn, options)

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

Heavy-usage asymptotic analysis of the closed two-station network with one think (infinite-server) station and one discriminatory processor-sharing station, by the generating-function expansion of

J.A. Morrison, “Asymptotic analysis of a large closed queueing network with discriminatory processor sharing”, Queueing Systems 9 (1991) 191-214.

Admitted only on the exact shape NC_IS_DPS_MODEL tests for. The kernel is NPFQN_DPS_MORRISON; this function maps the model struct onto it and lifts the per-class DPS results into the station-by-class arrays the NC analyzers return.

THERE IS NO NORMALIZING CONSTANT HERE. A DPS station is not product-form – that is the premise of the paper – so lG is returned as NaN, as it is on the maximum-entropy route. NC hosts this method because NC is where LINE keeps the asymptotic expansions of generating functions and normalizing-constant integrals (pana, mmint2, le, ble, gleint, rayint), which is the family Morrison’s expansion belongs to, not because a constant is being computed.

Response times come from Little’s law on the queue-length result rather than from the expanded RESULT 2 (eq. 4.17), so that Q = R*T holds exactly in the returned table; the two agree to the order of the approximation, since Morrison derives (4.17) as the ratio (4.11)/(4.15).

solver_nc_retrieval_analyzer(sn, options)

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

Exact analysis of a delayed-hit (retrieval-system) cache via the product-form recurrence algorithms: retrieval_nc (normalizing constant) and retrieval_metrics (hit / miss / delayed-hit ratios). Latency is left to SolverMVA (retrieval_fpi_latency) and returned as NaN here.

Those recurrences are exponential in the number of items, so OPTIONS.METHOD = ‘rayint’ selects instead the ray (WKB) approximation of retrieval_rayint, which is polynomial. It applies only when every fetch station is infinite-server, where the delayed-hit constant factorizes exactly as prod_k D_k times the plain cache constant with access factors gamma_{k,j}/D_k; elsewhere it warns and falls back to the exact path. Accuracy is that of retrieval_rayint, i.e. roughly 0.14*(1/min_j m_j + 1/(n - sum_j m_j)) in relative terms.

solver_nc_jointmarg(sn, options, nvec, engine, lG)

[PR,LPR,LG,RUNTIME] = SOLVER_NC_JOINTMARG(SN, OPTIONS, NVEC, ENGINE, LG)

Joint probability that station I holds NVEC(I) jobs IN TOTAL, all classes summed out. This is NOT solver_nc_jointaggr, which fixes the per-class population of every station: each state here is the sum of jointaggr over the whole fibre of per-class tables with these row sums, and that fibre grows combinatorially. The permanent evaluates the sum in closed form (pfqn_jointmarg).

LG, when supplied, is the log normalizing constant of the model, the same one that @SolverNC/getProbAggr caches as result.Prob.logNormConstAggr.

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

solver_nc_lossn_analyzer(sn, options)

SOLVER_NC_LOSSN_ANALYZER Analyzes open loss networks with FCR

This analyzer handles open queueing networks with a single multiclass Delay node inside a Finite Capacity Region (FCR) with DROP policy.

The FCR admission rule is A n <= C on the per-class occupancy vector n of the region, where the rows of A are assembled from every constraint the region declares: the global job cap, the memory budget weighted by the per-class sizes, the per-class job caps, and any explicit linear constraint set with FiniteCapacityRegion.setConstraint. Rows left unbounded are dropped rather than given a surrogate capacity.

Method selection (options.method):

‘exact’ (default) - Manjunath-Sikdar transform (lossn_manjunath): the: normalization constant is obtained exactly as a multidimensional contour integral evaluated by residues. Requires integer A and C.
‘rec’ - MDD-rec (lossn_rec): the same constant as the exact: sum over the admissible set, obtained by one memoised walk of the decision diagram holding it. Places no integrality demand on A or C.

‘erlangfp’ - Erlang fixed-point (reduced-load) approximation. ‘mci’ - Monte Carlo importance-sampling summation

(Ross-Wang 1992): estimates the normalization constant g(C) and class blocking with confidence intervals. Set options.samples and options.seed.

The default is the residue transform on an integral region and MDD-REC on a fractional one. It used to fall back to ‘erlangfp’ there, an approximation, because the residue argument counts whole units; MDD-rec needs only that the admissible set be finite and bounded per coordinate, which it still is, so the fractional case is now exact as well.

solver_nc_dt_analyzer(sn, options)

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

Exact normalizing-constant analysis of a discrete-time (slotted) queueing model, selected by OPTIONS.CONFIG.SLOTTED and classified by NC_IS_DT_MODEL. Two families are covered, both from Daduna (2001):

chapter 2 a Bernoulli server fed by a Bernoulli arrival stream, with an
unbounded buffer (theorem 2.3, corollary 2.7), a finite buffer (corollary 2.8) or a load-dependent service probability (example 2.10); evaluated by DQSYS_BERNOULLI1;

chapter 3 a closed cycle of Bernoulli servers (theorem 3.2, corollary
3.4); evaluated by DPFQN_NC when the service probabilities are state independent and by DPFQN_NCLD otherwise.

Every metric is expressed on the slot lattice: a rate is a per-slot probability and a time is a number of slots. OPTIONS.CONFIG.SLOTLENGTH rescales both to model time units, dividing throughputs and multiplying times, so that a caller who declared a slot of length d reads back the same units it built the model in.

On the cycle route the per-class split is proportional to the per-class population. Service in the cycle is type independent and FCFS forbids overtaking, so the cyclic order of the jobs is frozen; the marginal law of the queue lengths therefore carries no class information, and the long-run share of station j held by chain g is its population share N_g/N. That is the sense in which section 3.2 of the reference calls the multichain case a direct adaptation of the unichain one.

solver_nc_conv(sn, options)

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

Exact normalizing constant solver for closed networks with Limited class-dependent (cdscaling) service rates, using the multichain convolution algorithm of Sauer (1983), Section 5.2.

This solver handles models where some stations have class-dependent scaling (e.g., Flow-Equivalent Servers from aggregateFES).

nc_is_dt_model(sn, options)

DT = NC_IS_DT_MODEL(SN, OPTIONS)

Classify SN against the two families of discrete-time product-form models of Daduna (2001) that SOLVER_NC_DT_ANALYZER can solve exactly. The route is requested with OPTIONS.CONFIG.SLOTTED, the same knob SolverLDES uses to run on a discrete time scale, and is never auto-detected: a Geometric service time is a perfectly ordinary continuous-time model unless the caller says the model lives on a slot lattice.

Returns a struct with field KIND:

‘bernoulli1’ - one Bernoulli server fed by a state dependent Bernoulli: arrival stream (chapter 2). Fields STATION, ARRIVALPROB, SERVICEPROB, CAPACITY.
‘cycle’ - closed cycle of Bernoulli servers (chapter 3). Fields: ORDER (stations in cycle order), SERVICEPROB (J-by-N matrix p_j(n)), POPULATION.
‘none’ - not a discrete-time product-form model. Field REASON says: why, and the analyzer turns it into an error rather than falling back to a continuous-time approximation.

The admissible feature set is narrow because the discrete-time product form is narrow. Beyond the geometric service requirement:

a cycle is the only topology; Daduna, section 4.1, records that general discrete-time topologies of FCFS Bernoulli servers have no product form;

every station must be a single server. Pestien and Ramakrishnan, quoted in the same reference before example 2.10, proved that a multiserver node inside a cycle of geometrical queues destroys the product form for any finite server count;

class switching is rejected, and a multichain cycle is admitted only through the aggregate population (see SOLVER_NC_DT_ANALYZER).

See also SOLVER_NC_DT_ANALYZER, DPFQN_NC, DPFQN_NCLD, DQSYS_BERNOULLI1

solver_nc_oi_analyzer(sn, options)

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

Exact normalizing-constant analysis of a closed queueing network that mixes order-independent (OI) stations with ordinary BCMP product-form stations. Supported stations:

OI stations (SchedStrategy.OI / PAS with an empty swap graph), analyzed by the balanced-fairness rank rate mu(supp n) (Bonald & Proutiere 2003);

any BCMP product-form station: infinite-server (delay, IS), processor sharing (PS), LCFS-PR, and class-independent-rate FCFS, single- or multi- server, analyzed by the load-dependent BCMP weight table

W_i(n) = (sum n)!/prod(n_r!) * prod_r D_{i,r}^{n_r} / prod_{k=1}^{sum n} beta_i(k),

with D_{i,r} = V(i,r)/rate(i,r) the per-class demand and beta_i(k) the load-dependent capacity (min(k,c) for a c-server queue, k for IS).

The full-network normalizing-constant table G(P) over the lattice 0 <= P <= N is assembled by balanced-fairness convolution of all station tables, with the OI stations and the aggregated delay evaluated through PFQN_NCOI. The exact per-class mean queue length at any station follows from the OI functional-server (FNC) identity of PFQN_OI_FNC (Casale, QEST 2006):

E[n_{i,r}] = ( sum_{0<=b<=N} Psi_{i,r}(b) G(N-b) ) / G(N) - 1,

Psi_{i,r} being the FNC balance function built from that station’s balance table with f(n)=n_r. Per-class throughput X_r = G(N-e_r)/G(N); delay queue length and response time follow from Little’s law.

General per-class visits at the OI stations are supported: they enter the v-weighted balanced-fairness balance Phi^v(n)=(1/mu(n)) sum_r v_r Phi^v(n-e_r). BCMP-station visits are arbitrary (folded into D).

solver_nc_mem(sn, options)

[QN,UN,RN,TN,CN,XN,TOTITER,ACTUALMETHOD] = SOLVER_NC_MEM(SN, OPTIONS)

Maximum Entropy Method (MEM) for Open and Closed Queueing Networks

Implements the ME algorithms from Kouvatsos (1994) for analyzing queueing networks with general arrival and service processes under non-priority scheduling disciplines. Open models (Section 3.2) are decomposed into GE/GE/1, GE/GE/c and GE/GE/inf building blocks; closed models (Section 3.3) are solved by the two-stage pseudo-open network plus convolution algorithm on G/G/1 and G/G/inf building blocks; mixed models compose the two algorithms by product-form-style conditioning (open classes reduce the server capacity seen by the closed classes, closed occupancy inflates the open queue lengths).

Parameters:

sn - Network structure from getStruct()
options - Solver options with MEM-specific fields –
- config.mem_tol: convergence tolerance (default 1e-6)
- config.mem_maxiter: maximum iterations (default 1000)
- config.mem_verbose: print iteration info (default false)

Returns:

QN - Mean queue lengths [M x R matrix] UN - Utilizations [M x R matrix] RN - Mean response times [M x R matrix] TN - Throughputs [M x R matrix] CN - System response times per class [1 x R], by Little’s law XN - System throughputs per class [1 x R] totiter - Number of iterations until convergence actualmethod - ‘mem’, or ‘mem.blocking’ when the model carries a finite

station buffer and was solved by the censored GE/GE/c/0;N building blocks of Section 4.1

Reference:: D.D. Kouvatsos, “Entropy Maximisation and Queueing Network Models”, Annals of Operations Research, 48:63-126, 1994.