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