Core Modules

Networks, nodes, classes, distributions, solvers

These modules provide the fundamental building blocks for creating and solving queueing models.

Network Models (matlab/src/lang/)

The lang module contains the core classes for building queueing network models.

Main Classes

Network - Main queueing network model container

Constructor

model = Network(name): Create a new queueing network model

Static Factory Methods

model = Network.cyclic(N, D, strategy, S): Generate cyclic queueing network
model = Network.tandem(lambda, D, strategy): Generate tandem queueing network
model = Network.cyclicPs(N, D): Create cyclic network with PS scheduling
model = Network.cyclicFcfs(N, D, S): Create cyclic network with FCFS scheduling
model = Network.tandemPs(lambda, D): Create tandem network with PS scheduling
model = Network.tandemFcfs(lambda, D): Create tandem network with FCFS scheduling

Network Construction

addNode(model, node): Add a node (Queue, Source, Sink, etc.) to the network
addJobClass(model, classObj): Add a job class (OpenClass or ClosedClass)
addLink(model, nodeA, nodeB): Create a link between two nodes
addLinks(model, nodeList): Add multiple links from a node list
addRegion(model, nodes): Create a finite capacity region over nodes
addItemSet(model, itemSet): Add an item set for cache modeling

Routing

link(model, P): Link nodes using routing probability matrix
relink(model, P): Re-establish links using new routing matrix
linkAndLog(model, nodes, classes, P, wantLogger, logPath): Link nodes with logging capability
setRouting(model, nodeA, nodeB, jobclass, prob): Set routing probability from nodeA to nodeB for a job class
serialRouting(model, nodes, ...): Create serial routing pattern through nodes
initRoutingMatrix(model): Initialize routing probability matrix
P = getRoutingMatrix(model, arvRates): Get routing matrix with optional arrival rates
P = getLinkedRoutingMatrix(model): Get the currently linked routing matrix
printRoutingMatrix(model, onlyclass): Print routing matrix to console

Query Methods - Nodes

nodes = getNodes(model): Get all nodes in the network
names = getNodeNames(model): Get names of all nodes
types = getNodeTypes(model): Get types of all nodes
node = getNodeByName(model, name): Get node by name
node = getNodeByIndex(model, idx): Get node by index
idx = getNodeIndex(model, name): Get index of a node by name
M = getNumberOfNodes(model): Get total number of nodes
nodes = getStatefulNodes(model): Get all stateful nodes
names = getStatefulNodeNames(model): Get names of stateful nodes
M = getNumberOfStatefulNodes(model): Get count of stateful nodes
idx = getIndexStatefulNodes(model): Get indices of stateful nodes
idx = getStatefulNodeIndex(model, name): Get index of stateful node

Query Methods - Stations

names = getStationNames(model): Get names of all stations
station = getStationByName(model, name): Get station by name
station = getStationByIndex(model, idx): Get station by index
idx = getStationIndex(model, name): Get index of a station
M = getNumberOfStations(model): Get total number of stations
idx = getStationIndexes(model): Get indices of all stations
sched = getStationScheduling(model): Get scheduling strategies for all stations
S = getStationServers(model): Get number of servers at each station
S = getStatefulServers(model): Get server counts for stateful nodes
idx = getIndexSourceStation(model): Get index of source station
idx = getIndexSourceNode(model): Get index of source node
idx = getIndexSinkNode(model): Get index of sink node

Query Methods - Classes

classes = getClasses(model): Get all job classes
names = getClassNames(model): Get names of all classes
class = getClassByName(model, name): Get class by name
class = getClassByIndex(model, idx): Get class by index
idx = getClassIndex(model, name): Get index of a class
R = getNumberOfClasses(model): Get total number of classes
N = getNumberOfJobs(model): Get population vector for all classes
refs = getReferenceStations(model): Get reference stations for classes
refs = getReferenceClasses(model): Get reference classes
idx = getIndexOpenClasses(model): Get indices of open classes
idx = getIndexClosedClasses(model): Get indices of closed classes
chain = getClassChain(model, className): Get chain for a class
idx = getClassChainIndex(model, className): Get chain index for a class

Query Methods - Chains

[chainTable, chainMatrix] = getChains(model, rt): Get chain table and matrix
C = getNumberOfChains(model): Get number of chains in the model
D = getDemandsChain(model): Get service demands by chain

Query Methods - Structure

sn = getStruct(model, structType, wantState): Get internal data structure representation
[M, R] = getSize(model): Get [M,R] where M=nodes, R=classes
conn = getConnectionMatrix(model): Get node connection matrix
[H, G] = getGraph(model): Get graph representation
mask = getClassSwitchingMask(model): Get class switching mask
fj = getForkJoins(model, rt): Get fork-join pairs
ulf = getUsedLangFeatures(model): Get structure of used language features

Query Methods - Performance Handles

[Q,U,R,T,A,W] = getAvgHandles(model): Get all average metric handles
Q = getAvgQLenHandles(model): Get queue length handles
U = getAvgUtilHandles(model): Get utilization handles
R = getAvgRespTHandles(model): Get response time handles
T = getAvgTputHandles(model): Get throughput handles
A = getAvgArvRHandles(model): Get arrival rate handles
W = getAvgResidTHandles(model): Get residence time handles
[Qt,Ut,Tt] = getTranHandles(model): Get transient metric handles

Query Methods - Parameters

[D, Z] = getDemands(model): Get service demands
[lambda,D,N,Z,mu,S] = getProductFormParameters(model): Get product-form parameters
params = getProductFormChainParameters(model): Get product-form parameters by chain
ld = getLimitedLoadDependence(model): Get load-dependent scaling factors
cd = getLimitedClassDependence(model): Get class-dependent scaling factors
path = getLogPath(model): Get logging path

Query Methods - CTMC Analysis

Q = getGenerator(model, ...): Get CTMC generator matrix (delegates to CTMC)
SS = getStateSpace(model, ...): Get state space (delegates to CTMC)
MCTMC = getCTMC(model, par1, par2): Get marked CTMC representation
MCTMC = getMarkedCTMC(model, ...): Alias for getCTMC

Boolean Query Methods - Classes and Chains

bool = hasOpenClasses(model): Check if model has open classes
bool = hasClosedClasses(model): Check if model has closed classes
bool = hasClassSwitching(model): Check if model has class switching
bool = hasSingleChain(model): Check if single chain model
bool = hasMultiChain(model): Check if multi-chain model
bool = hasSingleClass(model): Check if single class model
bool = hasMultiClass(model): Check if multi-class model

Boolean Query Methods - Nodes

bool = hasFork(model): Check if model has fork nodes
bool = hasJoin(model): Check if model has join nodes
bool = hasMultiServer(model): Check for multi-server stations

Boolean Query Methods - Scheduling

bool = hasFCFS(model): Check if model has FCFS scheduling
bool = hasDPS(model): Check if model has DPS scheduling
bool = hasGPS(model): Check if model has GPS scheduling
bool = hasINF(model): Check if model has infinite server scheduling
bool = hasPS(model): Check if model has PS scheduling
bool = hasSIRO(model): Check if model has SIRO scheduling
bool = hasHOL(model): Check if model has HOL scheduling
bool = hasLCFS(model): Check if model has LCFS scheduling
bool = hasLCFSPR(model): Check if model has LCFSPR scheduling
bool = hasSEPT(model): Check if model has SEPT scheduling
bool = hasLEPT(model): Check if model has LEPT scheduling
bool = hasSJF(model): Check if model has SJF scheduling
bool = hasLJF(model): Check if model has LJF scheduling
bool = hasHomogeneousScheduling(model, strategy): Check for homogeneous scheduling
bool = hasMultiClassFCFS(model): Check for multi-class FCFS
bool = hasMultiClassHeterFCFS(model): Check for heterogeneous multi-class FCFS

Boolean Query Methods - Properties

bool = hasInitState(model): Check if initial state is defined
bool = hasProductFormSolution(model): Check if model has product-form solution
bool = isMatlabNative(model): Returns true for MATLAB implementation
bool = isJavaNative(model): Returns false for MATLAB implementation
bool = isLimitedLoadDependent(model): Check for load dependence
bool = isStateValid(model): Check if state is valid

State Initialization

reset(model, resetState): Reset the model
resetHandles(model): Reset performance metric handles
resetModel(model, resetState): Reset model to initial state
resetNetwork(model, deleteCSnodes): Reset network structure
resetStruct(model): Reset internal data structure
[state, priorStateSpace, stateSpace] = getState(model): Get current state
initDefault(model, nodes): Initialize with default state
initFromAvgTableQLen(model, AvgTable): Initialize from average queue length table
initFromAvgQLen(model, AvgQLen): Initialize from average queue lengths
initFromMarginal(model, n, options): Initialize from marginal distribution
initFromMarginalAndRunning(model, n, s, options): Initialize from marginal and running jobs
initFromMarginalAndStarted(model, n, s, options): Initialize from marginal and started jobs
setInitialized(model, bool): Set initialization flag

Refresh Methods

refreshStruct(model, hard): Refresh internal data structure
refreshRates(model, statSet, classSet): Refresh service rates and SCVs
refreshProcessPhases(model, statSet, classSet): Refresh process phases
refreshProcessTypes(model): Refresh process types
refreshRoutingMatrix(model, rates): Refresh routing matrix
refreshLST(model, statSet, classSet): Refresh Laplace-Stieltjes transforms
refreshSync(model): Refresh synchronization constraints
refreshPriorities(model): Refresh class priorities
refreshScheduling(model): Refresh scheduling strategies
refreshProcesses(model, statSet, classSet): Refresh all processes
refreshChains(model, propagate): Refresh chains and visits
refreshCapacity(model): Refresh capacity constraints
refreshLocalVars(model): Refresh local variables

Utility Methods

setChecks(model, bool): Enable/disable consistency checks
setUsedLangFeature(model, className): Mark a language feature as used
setLogPath(model, logPath): Set path for logging
sanitize(model): Sanitize model for consistency
summary(model): Print model summary
plot(model): Plot network graph
view(model): View network in JSIM viewer
jsimwView(model): View in JSIM What-If viewer
jsimgView(model): View in JSIM Graphical viewer
source = getSource(model): Get source node
sink = getSink(model): Get sink node

LayeredNetwork - Layered queueing network model for client-server systems

Constructor

model = LayeredNetwork(name): Create a new layered queueing network
model = LayeredNetwork(name, filename): Create and load from XML file

Static Methods

model = LayeredNetwork.readXML(filename, verbose): Read model from XML file
model = LayeredNetwork.load(filename, verbose): Load model from file (alias for readXML)
model = LayeredNetwork.parseXML(filename, verbose): Parse XML file into LayeredNetwork
model = LayeredNetwork.fromNetwork(network): Convert Network model to LayeredNetwork

Construction Methods

proc = addProcessor(model, name): Add a processor (hardware) to the LQN
task = addTask(model, name, mult, proc): Add a task (software component) running on processor
entry = addEntry(model, task, name): Add an entry point (service interface) to task
addPrecedence(model, entryA, entryB): Define call dependency between entries

Query Methods

lqn = getStruct(model): Get LQN data structure
E = getNumberOfLayers(model): Get number of layers
E = getNumberOfModels(model): Get number of models in ensemble
layers = getLayers(model): Get all layer models
idx = getNodeIndex(model, node): Get index of a node
node = getNodeByName(model, name): Get node by name
[names,hosts,tasks,entries,acts] = getNodeNames(model): Get all node names
ulf = getUsedLangFeatures(model): Get used language features per layer

Property-Style Aliases

idx = nodeIndex(model, node): Alias for getNodeIndex
node = nodeByName(model, name): Alias for getNodeByName
names = nodeNames(model): Alias for getNodeNames
lqn = struct(model): Alias for getStruct
E = numberOfLayers(model): Alias for getNumberOfLayers
E = numberOfModels(model): Alias for getNumberOfModels
layers = layers(model): Alias for getLayers
ulf = usedLangFeatures(model): Alias for getUsedLangFeatures

Utility Methods

reset(model, isHard): Reset the layered model
sn = summary(model): Print model summary (returns sn structure)
plot(model, showTaskGraph): Plot the layered network
plotGraph(model, useNodes): Plot network graph
plotGraphSimple(model, useNodes): Plot simplified graph
plotTaskGraph(model, useNodes): Plot task graph
view(model): View model in JLINE viewer
writeXML(model, filename, useAbstractNames): Write model to XML file
setUsedLangFeature(model, e, className): Mark a language feature as used in layer e
initUsedFeatures(model): Initialize feature tracking

Ensemble - Collection of network models for ensemble analysis

Ensemble: Collection of network models for ensemble analysis
NetworkStruct: Internal structure representation of a network
RoutingMatrix: Defines customer routing between nodes

Node Classes (matlab/src/lang/nodes/)

Source - Arrival point for open classes (generates customers)

Constructor

source = Source(model, name): Create a source node

Arrival Configuration

setArrival(source, jobclass, distribution): Set arrival process for a job class
distrib = getArrivalProcess(source, oclass): Get arrival process for a class

Queue - Service station with waiting buffer (supports FCFS, LCFS, PS, etc.)

Constructor

queue = Queue(model, name, schedStrategy): Create queue with scheduling strategy (FCFS, LCFS, PS, etc.)

Service Configuration

setService(queue, jobclass, distribution): Set service time distribution for a job class
setService(queue, jobclass, distribution, weight): Set service distribution with weight parameter
distrib = getService(queue, jobclass): Get service distribution for a class

Server Configuration

setNumberOfServers(queue, numServers): Set number of parallel servers
setNumServers(queue, numServers): Alternative method to set number of servers

Scheduling Parameters

setStrategyParam(queue, jobclass, weight): Set scheduling strategy parameter for class

Load and Class Dependence

setLoadDependence(queue, alpha): Set load-dependent service (PS, FCFS only)
setClassDependence(queue, beta): Set class-dependent service (PS, FCFS only)

Polling Configuration (POLLING strategy)

setPollingType(queue, rule, par): Set polling rule and parameter
setSwitchover(queue, jobclass, soTime): Set switchover time for POLLING
setSwitchover(queue, jobclass_from, jobclass_to, soTime): Set general switchover between classes

Delay-Off Configuration

setDelayOff(queue, jobclass, setupTime, delayoffTime): Set setup and delay-off times

Delay - Infinite-server station (think time/delay station)

Constructor

delay = Delay(model, name): Create delay (infinite server) node

Service Configuration

setService(delay, jobclass, distribution): Set delay time distribution for a job class
setService(delay, jobclass, distribution, weight): Set service distribution with weight
distrib = getService(delay, jobclass): Get service distribution for a class

Sink - Departure point for open classes (absorbs customers)

Constructor

sink = Sink(model, name): Create a sink node

Utility Methods

sections = getSections(sink): Get node sections

Other Node Types

Router: Routing node for complex routing decisions
Fork: Splits a job into parallel tasks
Join: Merges parallel tasks back into a single job
Cache: Content caching station with replacement policies
ClassSwitch: Node that changes job class probabilistically
Logger: Records job traces for analysis
Place: Petri net place (for generalized stochastic Petri nets)
Transition: Petri net transition (for generalized stochastic Petri nets)

Job Class Classes

OpenClass - Job class with external arrivals (open workload)

Constructor

jobclass = OpenClass(model, name): Create an open job class
jobclass = OpenClass(model, name, priority): Create open class with priority level

Configuration

setReferenceStation(jobclass, source): Set reference station (must be a Source)

ClosedClass - Job class with fixed population (closed workload)

Constructor

jobclass = ClosedClass(model, name, population, refNode): Create closed class with fixed population
jobclass = ClosedClass(model, name, population, refNode, priority): Create closed class with priority

Configuration

setReferenceStation(jobclass, refNode): Set reference station

Utility

summary(jobclass): Print class summary with population

Other Job Class Types

SelfLoopingClass: Special class for self-looping behavior
DisabledClass: Placeholder for disabled class

Support Classes

Chain: Group of related job classes forming a Markov chain
Element: Base class for model elements
NetworkElement: Base class for network-specific elements
Event: Represents discrete events in the model
ModeEvent: Mode-specific event representation
Mode: Operating mode for multi-mode models
Env: Random environment definition
GlobalConstants: Global configuration constants

Solvers (matlab/src/solvers/)

The solvers module provides various analytical and simulation-based solvers.

Base Solver Classes and Common Methods

All solver classes inherit from NetworkSolver and provide these common methods:

Constructor

solver = SolverXXX(model): Create solver instance for a model
solver = SolverXXX(model, options): Create solver with custom options

Analysis Execution

results = solve(solver): Run the solver and return results structure
[runtime, analyzer] = runAnalyzer(solver, options): Run solver analysis with detailed output

Average Performance Metrics

[QN,UN,RN,TN,AN,WN] = getAvg(solver): Get average performance metrics
[QN,UN,RN,TN,AN,WN] = getAvg(solver, Q,U,R,T): Get specified average metrics using handles
AvgTable = getAvgTable(solver): Get results as formatted table
[QNc,UNc,RNc,TNc] = getAvgChain(solver): Get chain-level average metrics
[CNc,XNc] = getAvgSys(solver): Get system-level averages
[QN,UN,RN,TN,AN,WN] = getAvgNode(solver): Get node-level averages
QN = getAvgQLenChain(solver): Get chain queue lengths
UN = getAvgUtilChain(solver): Get chain utilizations
RN = getAvgRespTChain(solver): Get chain response times
TN = getAvgTputChain(solver): Get chain throughputs
AN = getAvgArvRChain(solver): Get chain arrival rates
RN = getAvgSysRespT(solver): Get system response time
TN = getAvgSysTput(solver): Get system throughput

Transient Metrics (solver-dependent)

[QNt,UNt,TNt] = getTranAvg(solver, Qt,Ut,Tt): Get transient average metrics
[Pi_t, SSnode] = getTranProb(solver, node): Get transient node probabilities
[Pi_t, SSnode_a] = getTranProbAggr(solver, node): Get transient aggregated node probabilities
[Pi_t, SSsys] = getTranProbSys(solver): Get transient system probabilities
[Pi_t, SSsysa] = getTranProbSysAggr(solver): Get transient aggregated system probabilities
RD = getTranCdfRespT(solver, R): Get transient response time CDF
RD = getTranCdfPassT(solver, R): Get transient passage time CDF

State Probabilities (solver-dependent)

Pnir = getProb(solver, node, state): Get state probabilities at node
Pnir = getProbAggr(solver, node, state_a): Get aggregated state probabilities
Pn = getProbSys(solver): Get system-wide state probabilities
Pn = getProbSysAggr(solver): Get aggregated system probabilities
lNormConst = getProbNormConstAggr(solver): Get log normalizing constant

Distributions (solver-dependent)

RD = getCdfRespT(solver, R): Get response time CDF
RD = getCdfSysRespT(solver): Get system response time CDF

Sampling (solver-dependent)

tstate = sample(solver, node, numSamples): Sample node state trajectory
tstate = sampleAggr(solver, node, numSamples): Sample aggregated node state
tstate = sampleSys(solver, numSamples): Sample system state trajectory
tstate = sampleSysAggr(solver, numSamples): Sample aggregated system state

Query Methods

sn = getStruct(solver): Get model data structure
name = getName(solver): Get solver name

Property-Style Aliases (from EnsembleSolver)

s = solver(obj, e): Alias for getSolver - get solver for stage e
it = iteration(obj): Alias for getIteration - get current iteration
E = numberOfModels(obj): Alias for getNumberOfModels
avg = ensembleAvg(obj): Alias for getEnsembleAvg
tables = ensembleAvgTables(obj): Alias for getEnsembleAvgTables
methods = listValidMethods(solver): Get list of valid solution methods
options = getOptions(solver): Get current solver options

Control Methods

reset(solver): Reset solver state
setOptions(solver, options): Set solver options
setChecks(solver, bool): Enable/disable consistency checks

Static Methods

featSupported = SolverXXX.getFeatureSet(): Get supported model features
[bool, featSupported] = SolverXXX.supports(model): Check if model is supported
options = SolverXXX.defaultOptions(): Get default solver options

<tr><td colspan=”2”>**Property-Style Aliases (for get* methods)**</td></tr> <tr><td>``AvgTable = avgTable(solver)``</td><td>Alias for getAvgTable</td></tr> <tr><td>``AvgTable = avgSysTable(solver)``</td><td>Alias for getAvgSysTable</td></tr> <tr><td>``AvgTable = avgNodeTable(solver)``</td><td>Alias for getAvgNodeTable</td></tr> <tr><td>``AvgTable = avgChainTable(solver)``</td><td>Alias for getAvgChainTable</td></tr> <tr><td>``[QNc,UNc,RNc,TNc] = avgChain(solver)``</td><td>Alias for getAvgChain</td></tr> <tr><td>``[CNc,XNc] = avgSys(solver)``</td><td>Alias for getAvgSys</td></tr> <tr><td>``[QN,UN,RN,TN,AN,WN] = avgNode(solver)``</td><td>Alias for getAvgNode</td></tr> <tr><td>``RN = avgSysRespT(solver)``</td><td>Alias for getAvgSysRespT</td></tr> <tr><td>``TN = avgSysTput(solver)``</td><td>Alias for getAvgSysTput</td></tr> <tr><td>``AN = avgArvRChain(solver)``</td><td>Alias for getAvgArvRChain</td></tr> <tr><td>``QN = avgQLenChain(solver)``</td><td>Alias for getAvgQLenChain</td></tr> <tr><td>``UN = avgUtilChain(solver)``</td><td>Alias for getAvgUtilChain</td></tr> <tr><td>``RN = avgRespTChain(solver)``</td><td>Alias for getAvgRespTChain</td></tr> <tr><td>``TN = avgTputChain(solver)``</td><td>Alias for getAvgTputChain</td></tr> <tr><td>``QN = avgQLen(solver)``</td><td>Alias for getAvgQLen</td></tr> <tr><td>``UN = avgUtil(solver)``</td><td>Alias for getAvgUtil</td></tr> <tr><td>``RN = avgRespT(solver)``</td><td>Alias for getAvgRespT</td></tr> <tr><td>``TN = avgTput(solver)``</td><td>Alias for getAvgTput</td></tr> <tr><td>``AN = avgArvR(solver)``</td><td>Alias for getAvgArvR</td></tr> <tr><td>``[QNt,UNt,TNt] = tranAvg(solver, Qt,Ut,Tt)``</td><td>Alias for getTranAvg</td></tr> <tr><td>``RD = cdfRespT(solver, R)``</td><td>Alias for getCdfRespT</td></tr> <tr><td>``Pnir = prob(solver, node, state)``</td><td>Alias for getProb</td></tr> <tr><td>``Pnir = probAggr(solver, node, state_a)``</td><td>Alias for getProbAggr</td></tr> <tr><td>``Pn = probSys(solver)``</td><td>Alias for getProbSys</td></tr> <tr><td>``Pn = probSysAggr(solver)``</td><td>Alias for getProbSysAggr</td></tr> <tr><td>``lNormConst = probNormConstAggr(solver)``</td><td>Alias for getProbNormConstAggr</td></tr> <tr><td>``[Q,U,R,T,A,W] = avgHandles(solver)``</td><td>Alias for getAvgHandles</td></tr> <tr><td>``[Qt,Ut,Tt] = tranHandles(solver)``</td><td>Alias for getTranHandles</td></tr> Solver Options

SolverOptions: Configuration options for solvers (method, tolerance, iterations, etc.)
SolverFeatureSet: Describes features supported by a solver

Analytical Solvers

MVA - Mean Value Analysis (MVA/)

Valid Methods

‘default’, ‘mva’, ‘exact’, ‘amva’, ‘qna’, ‘qdlin’, ‘amva.qdlin’, ‘bs’, ‘amva.bs’, ‘sqni’, ‘qd’, ‘amva.qd’, ‘qli’, ‘amva.qli’, ‘fli’, ‘amva.fli’, ‘lin’, ‘egflin’, ‘gflin’, ‘amva.lin’, ‘mm1’, ‘mmk’, ‘mg1’, ‘mgi1’, ‘gm1’, ‘gig1’, ‘gig1.kingman’, ‘gigk’, ‘gigk.kingman_approx’, ‘gig1.gelenbe’, ‘gig1.heyman’, ‘gig1.kimura’, ‘gig1.allen’, ‘gig1.kobayashi’, ‘gig1.klb’, ‘gig1.marchal’, plus bounds methods

Description

Exact solver for product-form networks, approximate solver for non-product-form. Supports closed, open, and mixed models with various scheduling disciplines.

CTMC - Continuous-Time Markov Chain (CTMC/)

Additional Methods

[infGen, eventFilt, synchInfo] = getGenerator(solver, options): Get infinitesimal generator matrix
[infGen, eventFilt, synchInfo] = getInfGen(solver, options): Get infinitesimal generator (alias)
[infGen, eventFilt, synchInfo, SS, SSnode] = getSymbolicGenerator(solver, invertSymbol, primeNumbers): Get symbolic generator with state space
[SS, SSnode] = getStateSpace(solver, options): Get state space representation
SSa = getStateSpaceAggr(solver): Get aggregated state space
MCTMC = getMarkedCTMC(solver, options): Get marked CTMC object

Property-Style Aliases

SS = stateSpace(solver, options): Alias for getStateSpace
Q = generator(solver, options): Alias for getGenerator

Valid Methods

‘default’, ‘gpu’

Description

State-space enumeration solver. Exact for models with finite state space. Supports arbitrary service distributions and scheduling.

FLD - Fluid/Mean-Field Approximation (Fluid/)

Valid Methods

‘default’, ‘softmin’, ‘statedep’, ‘closing’, ‘matrix’

Description

ODE-based fluid approximation for large-scale models. Efficient for models with large populations.

MAM - Matrix-Analytic Methods (MAM/)

Valid Methods

‘default’, ‘dec.source’, ‘dec.mmap’, ‘dec.poisson’, ‘mna’

Description

Matrix-analytic methods for models with phase-type distributions and Markovian arrival processes.

NC - Normalizing Constant (NC/)

Additional Methods

[normConst, lNormConst] = getNormalizingConstant(solver): Get normalizing constant

Valid Methods

‘default’, ‘exact’, ‘imci’, ‘ls’, ‘le’, ‘mmint2’, ‘gleint’, ‘pana’, ‘ca’, ‘kt’, ‘sampling’, ‘propfair’, ‘comom’, ‘cub’, ‘rd’, ‘nrp’, ‘nrl’, ‘gm’

Description

Normalizing constant computation for closed product-form networks. Multiple exact and approximate algorithms.

SSA - Stochastic Simulation Algorithm (SSA/)

Additional Methods

[runtime, tranSysState, tranSync] = run(solver, options): Run stochastic simulation

Valid Methods

‘default’, ‘ssa’, ‘serial’, ‘para’, ‘parallel’, ‘nrm’

Description

Gillespie-style stochastic simulation. Supports all model features, provides trajectory sampling.

AUTO - Automatic solver selection (AUTO/)

Additional Methods

chooseSolver(solver, method): Choose appropriate solver based on model
chooseSolverAI(solver, method): AI-based solver selection
chooseSolverHeur(solver, method): Heuristic solver selection
chooseAvgSolverAI(solver): AI-based choice for Avg methods
chooseAvgSolverHeur(solver): Heuristic choice for Avg methods
delegate(solver, method, nretout, varargin): Delegate method to chosen solver

Description

Automatically selects the best solver for a given model and metric. Delegates all performance metric methods to the chosen solver.

External Solver Wrappers

JMT - Java Modelling Tools (JMT/)

Configuration

setJMTJarPath(solver, path): Set path to JMT.jar
path = getJMTJarPath(solver): Get JMT.jar path
path = getFilePath(solver): Get file path for JMT files
filename = getFileName(solver): Get filename for JMT files

Analysis

[result, parsed] = getResults(solver): Get simulation results
result = getResultsJSIM(solver): Get JSIM simulation results
result = getResultsJMVA(solver): Get JMVA analytical results

File I/O

writeJSIM(solver, sn, outputFileName): Write JSIM model file
writeJMVA(solver, sn, outputFileName, options): Write JMVA model file

Viewing

jsimwView(solver, options): View in JSIM What-If viewer
jsimgView(solver, options): View in JSIM graphical viewer

Static Methods

bool = JMT.isAvailable(): Check if JMT is available
JMT.jsimgOpen(filename): Open file in JSIM graphical mode
JMT.jsimwOpen(filename): Open file in JSIM What-If mode
parseLogs(solver, model, isNodeLogged, metric): Parse JMT log files
parseTranState(solver, fileArv, fileDep, nodePreload): Parse transient state data
parseTranRespT(solver, fileArv, fileDep): Parse transient response time data

Valid Methods

‘default’, ‘jsim’, ‘jmva’, ‘jmva.amva’, ‘jmva.mva’, ‘jmva.recal’, ‘jmva.comom’, ‘jmva.chow’, ‘jmva.bs’, ‘jmva.aql’, ‘jmva.lin’, ‘jmva.dmlin’

Description

Wrapper for Java Modelling Tools solvers. Provides both simulation (JSIM) and analytical (JMVA) capabilities.

LQNS - Layered Queueing Network Solver (LQNS/)

Analysis

AvgTable = getAvgTable(solver): Get metrics table for layered model
[result, iterations] = parseXMLResults(solver, filename): Parse LQNS XML results
savedfname = plot(solver, model): Plot layered model

Static Methods

bool = LQNS.isAvailable(): Check if LQNS is available on system path

Valid Methods

‘default’, ‘lqns’, ‘srvn’, ‘exactmva’, ‘srvn.exactmva’, ‘sim’, ‘lqsim’, ‘lqnsdefault’

Description

Wrapper for Layered Queueing Network Solver. Supports both analytical and simulation methods for LQN models.

QNS - QNS Solver (LQNS/)

Analysis

runtime = run(solver): Run QNS solver

Static Methods

bool = QNS.isAvailable(): Check if QNS is available

Valid Methods

‘default’, ‘conway’, ‘rolia’, ‘zhou’, ‘suri’, ‘reiser’, ‘schmidt’

Description

Wrapper for QNS queueing network solver. Multiple approximation algorithms available.

Composite Model Solvers

LN - Layered Network Decomposition (LN/)

Constructor

solver = LN(lqnmodel, solverFactory, options): Create layered network solver with factory for per-layer solvers

Analysis

[QN,UN,RN,TN,AN,WN] = getEnsembleAvg(solver): Get layer-averaged metrics
[AvgTable,QT,UT,RT,WT,AT,TT] = getAvgTable(solver, useLQNSNaming): Get metrics table with optional LQN naming
cdfRespT = getCdfRespT(solver): Get entry response time CDFs
[QNlqn_t, UNlqn_t, TNlqn_t] = getTranAvg(solver): Get transient layer averages

Layer Management

svcmatrix = getEntryServiceMatrix(solver): Get entry service matrix

Property-Style Aliases (from EnsembleSolver)

s = solver(obj, e): Alias for getSolver - get solver for layer e
it = iteration(obj): Alias for getIteration - get current iteration
E = numberOfModels(obj): Alias for getNumberOfModels
avg = ensembleAvg(obj): Alias for getEnsembleAvg
tables = ensembleAvgTables(obj): Alias for getEnsembleAvgTables

Valid Methods

‘default’, ‘moment3’

Description

Layered network decomposition solver. Iteratively solves each layer using specified per-layer solver.

ENV - Random Environment Solver (ENV/)

Constructor

solver = ENV(renv, solverFactory, options): Create environment solver with factory for stage solvers

Analysis

[QN,UN,RN,TN,AN,WN] = getEnsembleAvg(solver): Get environment-averaged metrics
AvgTable = getAvgTable(solver, keepDisabled): Get metrics table
envsn = getStruct(solver): Get environment structures (cell array)
[renvInfGen, stageInfGen, ...] = getGenerator(solver): Get random environment generator

Description

Solver for models in random environments. Computes weighted averages across environment stages.

LINE - Unified solver interface

LINE: Unified solver interface that delegates to appropriate solver

Distributions (matlab/src/lang/processes/)

The processes module provides probability distributions for service and arrival processes.

Base Distribution Classes

Distribution: Abstract base class for all distributions
ContinuousDistribution: Base class for continuous distributions
DiscreteDistribution: Base class for discrete distributions
Markovian: Marker interface for Markovian (memoryless) distributions
Process: Base class for stochastic processes

Continuous Distributions

Exp: (rate)
Det: (value)
Erlang: (k, rate)
Gamma: (shape, scale)
HyperExp: (p, rates)
Lognormal: (mu, sigma)
Pareto: (shape, scale)
Uniform: (min, max)
Weibull: (shape, scale)

Phase-Type Distributions

APH: (alpha, T)
Coxian: (mu, phi)
Cox2: (mu1, mu2, phi1)
PH: (alpha, T)

Markovian Arrival Processes

MAP

(D0, D1)

MarkedMAP

(D0, D1, …)

MMPP2

(lambda0, lambda1, sigma0, sigma1)

MarkedMMPP

(D0, D1, …)

MarkovModulated

MarkovProcess

MarkovChain

Discrete Distributions

Bernoulli

Binomial

(n, p)

DiscreteUniform

(min, max)

Geometric

Poisson

(rate)

Zipf

(s, N)

DiscreteSampler

(p, x)

Special Distributions

Disabled

Immediate

Replayer

(filename)

Trace

(filename)

EmpiricalCDF

(c, x)

Layered Networks (matlab/src/lang/layered/)

The layered module provides support for layered queueing networks (LQNs).

Main Classes

LayeredNetwork: Container for layered queueing network models
LayeredNetworkElement: Base class for LQN elements
LayeredNetworkStruct: Internal structure representation

Network Elements

Processor: Hardware resource (CPU, disk, etc.)
Host: Alias for Processor
Task: Software component running on a processor
Entry: Service interface of a task
Activity: Unit of work within an entry
ActivityPrecedence: Control flow between activities

Cache Tasks

CacheTask: Task with caching behavior
SetupTask: Task whose servers switch off when idle, paying a setup time on reactivation
FunctionTask: Deprecated alias of SetupTask
ItemEntry: Entry for cache item access