lang.constant

class SchedStrategy

SchedStrategy Enumeration of queueing scheduling disciplines and strategies

SchedStrategy defines constants for all supported scheduling disciplines in LINE queueing systems. These strategies determine the order in which jobs are selected for service from queues, affecting system performance and fairness characteristics.

@brief Comprehensive enumeration of queueing scheduling disciplines

Key scheduling categories: - Order-based: FCFS, LCFS, SIRO (service order policies) - Size-based: SJF, LJF, SEPT, LEPT (job length policies) - Sharing: PS, DPS, GPS (processor sharing variants) - Priority: HOL, PSPRIO, DPSPRIO, GPSPRIO (priority disciplines) - Special: INF, FORK, POLLING, EXT, REF (specialized strategies)

Common scheduling strategies: - FCFS: First-Come-First-Served (FIFO) - LCFS: Last-Come-First-Served (LIFO/Stack) - PS: Processor Sharing (round-robin with infinitesimal time slices) - SJF: Shortest Job First (non-preemptive, size known on arrival;

SRPT and PSJF are the preemptive size-based variants)

HOL: Head-of-Line priority (non-preemptive priority)
INF: Infinite server (delay station, no queueing)

SchedStrategy is used in: - Queue node configuration - Service discipline specification - Performance analysis parameterization - Model validation and compatibility checking - Solver method selection

Example: @code queue1 = Queue(model, ‘Server1’, SchedStrategy.FCFS); queue2 = Queue(model, ‘Server2’, SchedStrategy.PS); delay = Queue(model, ‘ThinkTime’, SchedStrategy.INF); @endcode

Property Summary

DPS

DPSPRIO

EDD: Earliest Due Date (non-preemptive)

EDF: Earliest Deadline First (preemptive)

EXT

FB: Feedback / Least Attained Service (priority by age)

FCFS

FCFSPI

FCFSPIPRIO

FCFSPR

FCFSPRIO: Alias for HOL

FCFSPRPRIO

FORK

FSP: Fair Sojourn Protocol (preemptive; ranks by virtual PS finish time)

GPS

GPSPRIO

HOL

INF

LAS: Alias for FB (Least Attained Service)

LCFS

LCFSPI

LCFSPIPRIO

LCFSPR

LCFSPRIO

LCFSPRPRIO

LEPT

LJF

LPS: Least Progress Scheduling

LRPT: Longest Remaining Processing Time

OI: Order-independent queue (pass-and-swap specialization with empty/zero swap graph)

PAS: Pass-and-swap (order-independent queue with class compatibility/swap graph)

POLLING

PS

PSJF: Preemptive Shortest Job First (priority by original size)

PSPRIO

REF

SEPT

SET: Alias for SETF

SETF: Shortest Elapsed Time First (non-preemptive FB)

SIRO

SJF

SRPT

SRPTPRIO

Method Summary

static fromId(id): TYPE = FROMID(ID)

static fromText(text): TYPE = FROMTEXT(TEXT)

static toFeature(type): TEXT = TOFEATURE(TYPE)

static toId(type): ID = TOID(TYPE)

static toProperty(text): PROPERTY = TOPROPERTY(TEXT)

static toText(type): TEXT = TOTEXT(TYPE)

class ProcessType

Enumeration of process ts

Property Summary

APH

BERNOULLI

BINOMIAL

BMAP

COX2

COXIAN

DET

DISABLED

DISCRETESAMPLER

DMAP

DUNIFORM

EMPIRICALCDF

ERLANG

EXP

GAMMA

GEOMETRIC

HYPEREXP

IMMEDIATE

LOGNORMAL

MAP

MAPT

ME

MMAP

MMPP2

NHPP

PARETO

PH

PHT

POISSON

PRIOR

RAP

REPLAYER

TRACE

UNIFORM

WEIBULL

ZIPF

Method Summary

static fromId(id): ID = TOID(TYPE)

static fromText(text): TIMMEDIATE = TOID(TYPE)

static isMarkovian(t)

BOOL = ISMARKOVIAN(T)

True when sn.proc carries an exact matrix representation of a process of type T: a genuine (D0,D1) pair, or its matrix-exponential analogue for ME/RAP.

The distinction is about SN.PROC, not about what getProcess returns. getProcess hands back raw distribution PARAMETERS for several non-Markovian families – Gamma, Weibull, Lognormal, Pareto and Uniform return two scalars (Pareto {alpha,k}, Uniform {min,max}) – and refreshProcessRepresentations replaces those with convertToMAP = map_erlang(mean, n) before storing them in sn.proc, where n = ceil(1/SCV) capped at 100 (n = 20 when SCV < CoarseTol). That fit matches the mean, and matches the SCV only when SCV <= 1: Pareto with SCV 64 gives n = 1, a single exponential of SCV 1. So for these types sn.proc is an approximation, not the law that was requested, and nothing on the cell says so – the only signal is sn.procid.

Solvers that read sn.proc as if it were the exact law must gate on this predicate. It is the procid-level counterpart of the JAR’s Distribution.isMarkovian(), i.e. of the Markovian class hierarchy, so the two lists must stay in step.

static toId(t): ID = TOID(TYPE)

static toText(t): TEXT = TOTEXT(TYPE)

class PollingType

Enumeration of polling service types

Property Summary

DECREMENTING

EXHAUSTIVE

GATED

KLIMITED

Method Summary

static fromName(name): ID = FROMNAME(NAME) - Inverse of toName.

static toId(type): ID = TOID(TYPE)

static toName(type): NAME = TONAME(TYPE) - Canonical name used on the JSON wire. The numeric ids agree with the Java enum but not with the Python one, which assigns them via auto(), so names are used to interchange polling types across codebases.

static toText(type): TEXT = TOTEXT(TYPE)

class ReplacementStrategy

Enumeration of cache replacement strategies

Property Summary

CLIMB: move-up-one-position on hit (transposition rule)

FIFO

HLRU

h lists, LRU discipline, promote i->i+1 on hit

Type:: hierarchical/k-LRU

LRU

QLRU

LRU discipline with probabilistic admission q on a miss

Type:: q-LRU

RR

SFIFO: strict fifo

Method Summary

static toFeature(type): TEXT = TOFEATURE(TYPE)

static toString(type): TEXT = TOSTRING(ID)

static toText(type): TEXT = TOTEXT(ID)

class SchedStrategyType

Enumeration of scheduling strategy types

Property Summary

NP: Non-preemptive

NPPrio: Non-preemptive priority

PNR: Preemptive non-resume

PNRPrio: Preemptive non-resume priority

PR: Preemptive resume

PRPrio: Preemptive resume priority

Method Summary

static getTypeId(strategy): TYPEID = GETTYPEID(STRATEGY) Classifies the scheduling strategy type

static toText(type): TEXT = TOTEXT(TYPE)

class DropStrategy

Enumeration of drop policies in stations.

Property Summary

BAS

BBS

DROP

Queue

job waits when region is full

Type:: Alias for WAITQ (waiting queue)

RETRIAL: Job moves to orbit and retries after delay (unlimited attempts)

RETRIAL_WITH_LIMIT: Job retries up to max attempts, then drops

RSRD

WAITQ

Method Summary

static toText(type): TEXT = TOTEXT(TYPE)

class DepartureDiscipline

Departure disciplines for the depository of a queueing place (QPN semantics).

A queueing place serves tokens in its embedded queue and, on service completion, moves them to a depository from which they become available to the output transitions. The departure discipline governs the order in which depository tokens become available.

Property Summary

FIFO: Tokens available in their order of arrival to the depository

NORMAL: Tokens available immediately upon service completion (standard QPN)

Method Summary

static toText(type): TEXT = TOTEXT(TYPE)

class VerboseLevel

Enumeration of verbosity levels.

Property Summary

DEBUG

SILENT

STD

class TimingStrategy

Enumeration of timing policies in Petri nets transitions.

Property Summary

IMMEDIATE

TIMED

Method Summary

static toText(type): TEXT = TOTEXT(TYPE)

class SignalType

Enumeration of signal types for signal classes.

Property Summary

CATASTROPHE: Catastrophe signal (removes ALL jobs)

NEGATIVE: Negative customer signal (removes jobs)

REPLY: Reply signal (triggers unblocking)

Method Summary

static fromText(text): TYPE = FROMTEXT(TEXT)

static toText(type): TEXT = TOTEXT(TYPE)

class ServiceStrategy

Enumeration of service strategies

Property Summary

CD: ClassDependent

JD: JointDependent

LD: LoadDependent

LI: LoadIndependent

SD: StateDependent

Method Summary

static toText(strategy)

class ServerType

Bases: Element

ServerType Represents a type of server within a heterogeneous multiserver queue

ServerType defines a group of identical servers with: - A unique name identifying this server type - A count of servers of this type - A list of job classes that are compatible with (can be served by) this type

Server types enable modeling of heterogeneous multiserver queues where different servers may have different service rates and serve different subsets of job classes.

Example: @code fastServer = ServerType(‘Fast’, 2); fastServer.setCompatible([classA, classB]); queue.addServerType(fastServer); queue.setService(classA, fastServer, Exp(2.0)); @endcode

Constructor Summary

ServerType(name, numOfServers, compatibleClasses, rate)

SERVERTYPE Create a new server type

self = SERVERTYPE(name, numOfServers) creates a server type with the specified name and number of servers. Compatible classes can be added later using setCompatible() or addCompatible().

self = SERVERTYPE(name, numOfServers, compatibleClasses) creates a server type with initial compatible classes.

@param name String name identifying this server type @param numOfServers Number of servers of this type (must be >= 1) @param compatibleClasses (optional) Cell array or array of JobClass objects

Property Summary

compatibleClasses: Cell array of compatible JobClass objects (or, on a layered server, of compatible Task/Entry operands)

id: Unique identifier within the queue

numOfServers: Number of servers of this type

parentQueue: The Queue or LayeredNetworkElement this server type belongs to

rate: Per-server rate of this pool; read on a LAYERED server, where the rate law is per pool

Method Summary

addCompatible(jobClass)

ADDCOMPATIBLE Add a job class to the compatible list

self = ADDCOMPATIBLE(jobClass) adds a job class to the list of classes that can be served by this server type.

@param jobClass The JobClass to add

getCompatibleClasses()

GETCOMPATIBLECLASSES Get the list of compatible job classes

classes = GETCOMPATIBLECLASSES() returns a cell array of compatible JobClass objects.

getId()

GETID Get the server type ID

id = GETID() returns the unique identifier of this server type within its queue, or -1 if not yet added to a queue.

getNumCompatibleClasses()

GETNUMCOMPATIBLECLASSES Get the number of compatible classes

n = GETNUMCOMPATIBLECLASSES() returns the count of compatible classes.

getNumOfServers()

GETNUMOFSERVERS Get the number of servers of this type

n = GETNUMOFSERVERS() returns the number of servers.

getParentQueue()

GETPARENTQUEUE Get the parent queue

queue = GETPARENTQUEUE() returns the Queue this server type belongs to, or [] if not yet added to a queue.

getRate(): R = GETRATE() Per-server rate of this pool.

hasCompatibleClasses()

HASCOMPATIBLECLASSES Check if any compatible classes are defined

result = HASCOMPATIBLECLASSES() returns true if at least one compatible class is defined.

isCompatible(jobClass)

ISCOMPATIBLE Check if a job class is compatible with this server type

result = ISCOMPATIBLE(jobClass) returns true if the job class can be served by this server type.

@param jobClass The JobClass to check @return result Boolean indicating compatibility

removeCompatible(jobClass)

REMOVECOMPATIBLE Remove a job class from the compatible list

self = REMOVECOMPATIBLE(jobClass) removes a job class from the list of compatible classes.

@param jobClass The JobClass to remove

setCompatible(classes)

SETCOMPATIBLE Set the list of compatible job classes

self = SETCOMPATIBLE(classes) sets the list of job classes that can be served by this server type.

@param classes Array or cell array of JobClass objects

setId(id)

SETID Set the server type ID

self = SETID(id) sets the unique identifier. This is typically called by the Queue when the server type is added.

setNumOfServers(n)

SETNUMOFSERVERS Set the number of servers of this type

self = SETNUMOFSERVERS(n) sets the number of servers (must be >= 1).

setParentQueue(queue)

SETPARENTQUEUE Set the parent queue

self = SETPARENTQUEUE(queue) sets the parent queue. This is typically called by the Queue when the server type is added.

setRate(r): SELF = SETRATE(R) Set the per-server rate of this pool.

summary()

SUMMARY Print a summary of this server type

SUMMARY() displays information about this server type.

class RemovalPolicy

Enumeration of removal policies for negative signals in G-networks.

When a negative signal (or catastrophe) arrives at a queue and removes positive customers, the removal policy determines which customers are selected for removal.

Policies: - RANDOM: Uniform random selection from all jobs at the station - FCFS: Remove oldest jobs first (first-come-first-served order) - LCFS: Remove newest jobs first (last-come-first-served order)

Property Summary

FCFS: Remove oldest jobs first

LCFS: Remove newest jobs first

RANDOM: Uniform random selection

Method Summary

static fromText(text): POLICY = FROMTEXT(TEXT) Convert text to policy constant

static toText(policy): TEXT = TOTEXT(POLICY) Convert policy to text representation

class NodeType

Enumeration of node types.

Property Summary

Cache

ClassSwitch

Delay

Fork

Join

Logger

Place

Queue

Region

Router

Sink

Source

Transition

Method Summary

static toText(nodetype)

class MetricType

An output metric of a Solver, such as a performance index

Property Summary

ArvR

DropRate

FCRMemOcc

FCRWeight

FJQLen

FJRespT

QLen

QueueT

ResidT

RespT

RespTSink

SysQLen

SysRespT

SysTard

SysTput

Tard

Tput

TputSink

TranQLen

TranRespT

TranTput

TranUtil

Util

Method Summary

static toText(metricId)

class JoinStrategy

Enumeration of join strategy types.

Property Summary

PARTIAL

STD

Method Summary

static toText(type): TEXT = TOTEXT(TYPE)

class JobClassType

Bases: NetworkElement

An abstract class for a collection of indistinguishable jobs

Property Summary

CLOSED

DISABLED

OPEN

Method Summary

static toText(classType)

class ImpatienceType

Enumeration of customer impatience types.

Property Summary

BALKING: Customer refuses to join based on queue state

RENEGING: Customer abandons after joining the queue (timer-based)

RETRIAL: Customer moves to orbit and retries after delay

Method Summary

static fromId(id)

TYPE = FROMID(ID)

Convert numeric ID to impatience type constant

static toId(type)

ID = TOID(TYPE)

Convert impatience type constant to numeric ID

static toText(type)

TEXT = TOTEXT(TYPE)

Convert impatience type constant to text description

class HeteroSchedPolicy

HeteroSchedPolicy Enumeration of scheduling policies for heterogeneous multiserver queues

HeteroSchedPolicy defines constants for scheduling policies that determine how jobs are assigned to server types in heterogeneous multiserver queues. These policies are used when a job’s class is compatible with multiple server types.

@brief Scheduling policies for heterogeneous server assignment

Available policies: - ORDER: Assign to first available compatible server type (in definition order) - ALIS: Assign Longest Idle Server (round-robin with busy servers at back) - ALFS: Assign Least Flexible Server (prefer the type that serves fewest classes) - FAIRNESS: Fair distribution across compatible server types - FSF: Fastest Server First (based on expected service time) - RAIS: Random Available Idle Server

Example: @code queue = Queue(model, ‘HeteroQueue’, SchedStrategy.FCFS); st1 = ServerType(‘Fast’, 2); queue.addServerType(st1); queue.setHeteroSchedPolicy(HeteroSchedPolicy.FSF); @endcode

Property Summary

ALFS: ALFS - Assign Least Flexible Server (prefer least-flexible compatible type)

ALIS: ALIS - Assign Longest Idle Server (round-robin)

FAIRNESS: FAIRNESS - Fair distribution across compatible server types

FSF: FSF - Fastest Server First (minimum expected service time)

ORDER: ORDER - First available compatible server type in definition order (default)

RAIS: RAIS - Random Available Idle Server

Method Summary

static fromText(text)

FROMTEXT Convert text to HeteroSchedPolicy constant

policy = FROMTEXT(text) converts a string to the corresponding HeteroSchedPolicy constant value.

@param text String representation of the policy @return policy The corresponding HeteroSchedPolicy constant

static toJMTText(policy)

TOJMTTEXT Convert HeteroSchedPolicy to JMT’s descriptive string

JMT’s CommonConstants.STATION_SCHEDULING_POLICY_* expects long human-readable identifiers (e.g. “ALIS (Assign Longest Idle Server)”). The bare names returned by toText do not match those constants, so when writing JSIM XML use this method.

static toText(policy)

TOTEXT Convert HeteroSchedPolicy constant to text

text = TOTEXT(policy) converts a HeteroSchedPolicy constant to its string representation.

@param policy The HeteroSchedPolicy constant @return text String representation of the policy

class CallType

Property Summary

ASYNC

FWD

SYNC

Method Summary

static toText(callType)

class BalkingStrategy

Enumeration of balking strategies.

BalkingStrategy defines how customers decide whether to balk (refuse to join a queue):

QUEUE_LENGTH - Balk based on current queue length ranges EXPECTED_WAIT - Balk based on expected waiting time COMBINED - Balk if either condition is met (OR logic)

Property Summary

COMBINED: Both conditions (OR logic)

EXPECTED_WAIT: Balk based on expected waiting time

QUEUE_LENGTH: Balk based on queue length ranges with probability

Method Summary

static fromId(id)

TYPE = FROMID(ID)

Convert numeric ID to balking strategy constant

static toId(type)

ID = TOID(TYPE)

Convert balking strategy constant to numeric ID

static toText(type)

TEXT = TOTEXT(TYPE)

Convert balking strategy constant to text description

class ActivityPrecedenceType

Activity Precedence types.

Property Summary

POST_AND

POST_CACHE

POST_LOOP

POST_OR

POST_SEQ

PRE_AND

PRE_OR

PRE_SEQ

Method Summary

static toText(precedence): TXT = TOTEXT(PRECEDENCE) Convert numeric ID to string label

class RoutingStrategy

RoutingStrategy Enumeration of job routing policies and load balancing strategies

RoutingStrategy defines constants for routing policies that determine how jobs are directed from one node to another in queueing networks. These strategies control load distribution, traffic balancing, and path selection throughout the network topology.

@brief Comprehensive enumeration of job routing and load balancing strategies

Key routing categories: - Probabilistic: RAND, PROB (random and probability-based routing) - Load balancing: JSQ, SQ (queue length-based decisions) - Round-robin: RROBIN, WRROBIN (cyclic and weighted distribution) - Advanced: FIRING (event-based routing) - Control: DISABLED (no routing for specific classes)

Common routing strategies: - RAND: Random routing (equal probability to all destinations) - PROB: Probabilistic routing (user-specified probabilities) - RROBIN: Round-robin (cyclic distribution) - JSQ: Join Shortest Queue (dynamic load balancing) - SQ: Shortest queue of d, SQ(d) (formerly KCHOICES) - SDR: Krzesinski product-form state-dependent routing - DISABLED: No routing (class blocked at this node)

RoutingStrategy is used in: - Node output section configuration - Network topology specification - Load balancing implementation - Traffic distribution control - Router and dispatcher configuration

Example: @code router.setRouting(jobClass, RoutingStrategy.PROB, [queue1, queue2], [0.7, 0.3]); loadBalancer.setRouting(jobClass, RoutingStrategy.JSQ); roundRobin.setRouting(jobClass, RoutingStrategy.RROBIN); @endcode

Property Summary

DISABLED

FIRING

JSQ

PROB

RAND

RROBIN

SDR: Krzesinski (1987) product-form state-dependent routing

SQ

shortest queue of d, SQ(d)

Type:: KCHOICES is now SQ

WRROBIN

Method Summary

static fromText(text): TYPE = FROMTEXT(TEXT)

static toFeature(type): FEATURE = TOFEATURE(TYPE)

static toId(type): ID = TOID(TYPE)

static toText(type): TEXT = TOTEXT(TYPE)

class EventType

Bases: Copyable

Types of events

Property Summary

ARV: job arrival

DEP: job departure

ENABLE: enable mode

FAILURE: the server of a station breaks down (goes from up to down)

FIRE: fire mode

INIT: model is initialized (time t=0)

LOCAL: dummy event

PHASE: service advances to next phase, without departure

POST: produce to a place or queue buffer

PRE: consume from a place or queue buffer (no side-effects on server)

PREEMPT: a job holding a server is pushed back into the buffer (tag on an ARV arc)

READ: read cache item

RENEGE: a waiting job abandons the queue (impatience)

REPAIR: the server of a station is repaired (goes from down to up)

RETRY: an orbiting job retries entry into a retrial station

STAGE: random environment stage change

START: a job begins or resumes holding a server (tag on an ARV/DEP arc)

SWITCH: the server of a polling station advances its switchover timer

Method Summary

static toText(type): TEXT = TOTEXT(TYPE)

class RetrialPolicy

Enumeration of retrial policies for an orbiting population.

The policy fixes how the aggregate rate at which the orbit attempts to re-enter the station depends on the orbit size n:

LINEAR - each orbiting customer retries independently at rate nu, so
the aggregate retrial rate is n*nu. This is the classical retrial queue of Falin and Templeton.

CONSTANT - the orbit as a whole retries at rate nu whenever it is
non-empty, independently of n. This models a single retrial controller shared by the orbit rather than per-customer timers.

Property Summary

CONSTANT

LINEAR

Method Summary

static fromText(text): TYPE = FROMTEXT(TEXT)

static toText(type): TEXT = TOTEXT(TYPE)