lang.sections

class Forker

Bases: OutputSection

An output section forking jobs into sibling tasks

Constructor Summary

Forker(customerClasses): SELF = FORKER(CUSTOMERCLASSES)

Property Summary

branchProb: Per-destination, per-class branch activation probability. Empty means 1.0: the branch always fires, which is the classic fork.

tasksPerLink: Nominal tasks emitted on each outgoing link, shared by every link and every class. For a fork whose degree is random this is the MEAN, so a consumer that only knows this field gets E[tasks per link] rather than a number the fork never emits.

tasksPerLinkByDest: Per-destination, per-class overrides, each a containers-free struct array of (destNodeName, class index, value). Empty means “uniform, use tasksPerLink”. They are kept by DESTINATION NAME rather than by link ordinal because the link order is an artefact of connmatrix traversal and silently renumbers when the model is relinked.

tasksPerLinkDist: Per-destination, per-class jobs-per-link distributions (DiscreteSampler over a non-negative integer support). Empty means degenerate at the corresponding tasksPerLink entry.

class SharedServer

Bases: ServiceSection

A service section for serving jobs with processor sharing type policies

Constructor Summary

SharedServer(customerClasses): SELF = SHAREDSERVER(CUSTOMERCLASSES)

class PreemptiveServer

Bases: ServiceSection

A service section for serving jobs preemptively

Constructor Summary

PreemptiveServer(customerClasses): SELF = SHAREDSERVER(CUSTOMERCLASSES)

class CacheClassSwitcher

Bases: StatefulClassSwitcher

A class switcher section based on cache hits and misses

Constructor Summary

CacheClassSwitcher(classes, items, capacity, levels): SELF = CACHECLASSSWITCHER(CLASSES, ITEMS, CAPACITY, LEVELS)

Property Summary

actualDelayedHitProb: delayed-hit fraction per arrival class (retrieval system; filled after solve)

actualDelayedHitQLen: [1 x items] mean secondary requests waiting on the fetch of each item

actualDelayedHitQLenFull: [1 x items] as above, including the request that triggered the fetch

actualHitProb

actualHitProbList: [classes x lists] per-list (per-level) hit fraction (filled after solve, where available)

actualItemProb

col 1 = miss, cols 2..end = per-list (filled after solve, where available)

Type:: [items x (lists+1)] per-item occupancy

actualListCost: [1 x lists] mean storage cost held by each list (filled after solve when item sizes are set)

actualMissProb

actualResidT: expected latency per arrival class (filled after solve)

cap

hitClass

items

levels

missClass

retrievalClasses: [items x classes] -1 where no retrieval class is defined

Method Summary

simpleHitMiss(r, s, state, statep): PROB = SIMPLEHITMISS(R, S, STATE, STATEP)

class StatefulClassSwitcher

Bases: ClassSwitcher

An abstract class for a state-dependent class switch

Constructor Summary

StatefulClassSwitcher(classes, name): SELF = STATEFULCLASSSWITCHER(CLASSES, NAME)

Method Summary

static classHolderFun(r, s, state, statep): PROB = CLASSHOLDERFUN(R, S, STATE, STATEP)

class Timing

Bases: ServiceSection

A service tunnel for general nodes

Constructor Summary

Timing(name): SELF = SERVICETUNNEL(NAME)

class Storage

Bases: InputSection

An input section for jobs to wait for service.

Constructor Summary

Storage(classes): SELF = STORAGE(CLASSES)

Property Summary

size

Method Summary

setSize(size)

class StatelessClassSwitcher

Bases: ClassSwitcher

A class switch node basic on class switch probabilities

Constructor Summary

StatelessClassSwitcher(jobclasses, csMatrix): SELF = STATELESSCLASSSWITCHER(CLASSES, CSMATRIX)

Property Summary

csMatrix

Method Summary

updateClassSwitch(csMatrix)

updateClasses(jobclasses)

class ServiceTunnel

Bases: ServiceSection

A service tunnel for general nodes

Constructor Summary

ServiceTunnel(name): SELF = SERVICETUNNEL(NAME)

class ServiceSection

Bases: Section

An abstract class for the service section of a node.

Property Summary

numberOfServers

serviceProcess

class Server

Bases: ServiceSection

Server Basic non-preemptive service section for job processing

Server implements a basic service section that processes jobs according to non-preemptive disciplines. It manages service processes for different job classes and coordinates with scheduling sections to provide complete queueing station functionality.

@brief Non-preemptive service section with class-dependent service processes

Key characteristics: - Non-preemptive job service - Class-dependent service time distributions - Single or multiple server support - Load-independent service strategies - Integration with scheduling disciplines

Server features: - Service process management per class - Service time distribution configuration - Server capacity specification - Load-independent operation - Deep copy support for model cloning

Server is used in: - Basic FCFS and LCFS queues - Priority queue service sections - Multi-server queue implementations - Load-independent service modeling - Class-differentiated service systems

Example: @code classes = {OpenClass(model, ‘Class1’), ClosedClass(model, ‘Class2’, 5)}; server = Server(classes); server.setServiceProcess(1, 1, Exp(2.0)); % Class1 service @endcode

Constructor Summary

Server(classes)

SERVER Create a basic server section instance

@brief Creates a Server section for non-preemptive job processing @param classes Cell array of JobClass objects to be served @return self Server instance configured for the specified classes

class Section

Bases: NetworkElement

An abstract class for sections that define the behavior of a Node

Property Summary

className

Method Summary

summary(): SUMMARY()

class RandomSource

Bases: InputSection

An input section generating arrivals from the external world at random times

Constructor Summary

RandomSource(classes): SELF = RANDOMSOURCE(CLASSES)

Property Summary

sourceClasses

class PollingServer

Bases: ServiceSection

A service section for serving input buffers cyclically

Constructor Summary

PollingServer(classes): SELF = SERVER(CLASSES)

class OutputSection

Bases: Section

An abstract class for the output section of a node.

Property Summary

outputStrategy

class LogTunnel

Bases: ServiceTunnel

A service tunnel for Logger nodes

Constructor Summary

LogTunnel(): SELF = LOGTUNNEL()

class Linkage

Bases: OutputSection

An output section dispatching jobs to a destination

Constructor Summary

Linkage(customerClasses): SELF = DISPATCHER(CUSTOMERCLASSES)

Method Summary

initDispatcherJobClasses(customerClasses): INITDISPATCHERJOBCLASSES(CUSTOMERCLASSES)

setStrategy(customerClasses, strategy): SETSTRATEGY(CUSTOMERCLASSES, STRATEGY)

class Joiner

Bases: InputSection

An input section that joins siblings tasks

Constructor Summary

Joiner(customerClasses): SELF = JOINER(CUSTOMERCLASSES)

Property Summary

joinJobClasses

joinRequired

joinStrategy

Method Summary

initJoinJobClasses(customerClasses): INITJOINJOBCLASSES(CUSTOMERCLASSES)

setRequired(customerClass, nJobs): SETREQUIRED(CUSTOMERCLASS, NJOBS)

setStrategy(customerClass, joinStrat): SETSTRATEGY(CUSTOMERCLASS, JOINSTRAT)

class InputSection

Bases: Section

An abstract class for the input section of a node.

Property Summary

schedPolicy

class InfiniteServer

Bases: ServiceSection

A service section to delay jobs without contention

Constructor Summary

InfiniteServer(customerClasses): SELF = INFINITESERVER(CUSTOMERCLASSES)

class Firing

Bases: OutputSection

An output section for Transitions

Constructor Summary

Firing(customerClasses): SELF = FORKER(CUSTOMERCLASSES)

class Enabling

Bases: InputSection

An input section for jobs to wait for service.

Constructor Summary

Enabling(classes): SELF = ENABLING(CLASSES)

Property Summary

size

class Dispatcher

Bases: OutputSection

Dispatcher Output section for routing jobs to downstream destinations

Dispatcher implements an output section that routes completed jobs to their next destinations according to specified routing strategies. It manages class-dependent routing decisions and coordinates job flow through the queueing network topology.

@brief Output section for class-dependent job routing and dispatching

Key characteristics: - Class-dependent routing strategies - Destination selection and job dispatching - Support for various routing policies - Integration with network topology - Probabilistic and deterministic routing

Dispatcher features: - Routing strategy management per class - Destination probability specification - Random, round-robin, and custom routing - Class-based routing differentiation - Network flow coordination

Dispatcher is used in: - Queue output sections for job routing - Router nodes for traffic distribution - Load balancing implementations - Multi-path network routing - Class-based service differentiation

Example: @code classes = {OpenClass(model, ‘WebReq’), OpenClass(model, ‘DBReq’)}; dispatcher = Dispatcher(classes); dispatcher.setStrategy(classes{1}, RoutingStrategy.PROB); @endcode

Constructor Summary

Dispatcher(customerClasses): SELF = DISPATCHER(CUSTOMERCLASSES)

Method Summary

initDispatcherJobClasses(customerClasses): INITDISPATCHERJOBCLASSES(CUSTOMERCLASSES)

initDispatcherJobClassesPreservingRouted(customerClasses): INITDISPATCHERJOBCLASSESPRESERVINGROUTED(CUSTOMERCLASSES) Reset to DISABLED only classes that currently lack a meaningful routing strategy (i.e. empty entries or those already DISABLED). Classes that have been configured before link() runs — e.g. by Cache.setRetrievalSystem’s auto-generated routing on the retrieval ClassSwitch and Queues for retrieval-pending classes that do not appear in P — are preserved.

setStrategy(customerClasses, strategy): SETSTRATEGY(CUSTOMERCLASSES, STRATEGY)

class ClassSwitcher

Bases: ServiceSection

An abstract classs for a service section that switches job class

Constructor Summary

ClassSwitcher(classes, name): SELF = CLASSSWITCHER(CLASSES, NAME)

Property Summary

classes

csFun

class Buffer

Bases: InputSection

An input section for jobs to wait for service.

Constructor Summary

Buffer(classes): SELF = BUFFER(CLASSES)

Property Summary

size

Method Summary

setSize(size)