Package jline.lang.state

Class State

java.lang.Object
jline.lang.state.State
All Implemented Interfaces:
Serializable
public class State extends Object implements Serializable
Class modeling the state of Stateful nodes
See Also:

  • Field Details

  • Constructor Details

  • Method Details

    • arrivalIsLost

      public static boolean arrivalIsLost(NetworkStruct sn, int ist, int jobClass)
      True when an arrival of class jobClass that finds no room at station ist is LOST, and false when it must BLOCK the upstream instead. This is the single predicate that decides the refusal semantics; every refusal path must branch on it. Mirrors the MATLAB State.arrivalIsLost. The rule is the CLASS TYPE, not the drop rule:
      • OPEN class: LOST. The external arrival stream is memoryless, so a job that finds the station full simply never enters. The caller must then leave the state UNCHANGED (a self-loop): the arrival event still fires, so the offered rate reaches the arrival-rate statistic and the loss shows up as ArvR - Tput. A self-loop cancels on the generator diagonal and therefore cannot perturb the stationary distribution, so QLen/Util/Tput are unaffected.
      • CLOSED class: BLOCKED. A closed network's N jobs have nowhere to go; population conservation is a defining invariant, so a closed job can never be dropped. The caller must return an EMPTY outspace, which disables the upstream departure until room frees (and is what the true-BAS become-blocked edge tests for).
      An explicit blocking drop rule (BAS/BBS/RSRD) also asks for blocking, for any class. This is the same open/closed predicate as the CTMC analyzer's canDropClass and the BUG-12 utilization guard; the conventions are complementary, not contradictory (the arrival rate counts the OFFERED job, Util/QLen/Tput the CARRIED one).
      Parameters:
      sn - the network struct
      ist - the station index
      jobClass - the class index
      Returns:
      true when the refused arrival is lost, false when it blocks

    • isPhysicalCapacity

      public static boolean isPhysicalCapacity(NetworkStruct sn, int ist, int jobClass)
      True when the capacity bound at station ist for jobClass is a PHYSICAL finite capacity (setCapacity/setClassCapacity), as opposed to a state-space CUTOFF imposed on an open class only to bound enumeration. The distinction matters because a solver may fold the open-class cutoff into the producer's capacity/classcap arguments (SSA overwrites sn.cap/sn.classcap with min(cutoff, physical)), so at the cutoff boundary they are finite even when there is no physical cap. Treating a cutoff boundary as physical would turn a state-space truncation into a self-loop loss. The reliable in-producer signal is the DROP RULE: refreshCapacity sets a finite-capacity rule (Drop, or a blocking/retrial rule) exactly when the station has a physical finite capacity for the class; an open class bounded only by the cutoff keeps the WaitingQueue default. (A user who explicitly sets WaitingQueue on a physical cap is the one ambiguous case; it is already ill-defined and is treated here as a cutoff, i.e. truncated.)
      Parameters:
      sn - the network struct
      ist - the station index
      jobClass - the class index
      Returns:
      true when a physical finite capacity binds this station-class

    • fromMarginal

      public static Matrix fromMarginal(Network model, int ind, int[] n)
      Generates the state space of a node from the per-class marginal job counts.
      Parameters:
      model - the network model
      ind - the node index (0-based)
      n - per-class number of resident jobs
      Returns:
      the state-space matrix (one row per valid state)

    • fromMarginalAndRunning

      public static Matrix fromMarginalAndRunning(Network model, int ind, int[] n, int[] s)
      Generates the state space of a node from the per-class marginal job counts and the per-class number of running jobs.
      Parameters:
      model - the network model
      ind - the node index (0-based)
      n - per-class number of resident jobs
      s - per-class number of running jobs
      Returns:
      the state-space matrix (one row per valid state)

    • fromMarginalAndStarted

      public static Matrix fromMarginalAndStarted(Network model, int ind, int[] n, int[] s)
      Generates the state space of a node from the per-class marginal job counts and the per-class number of jobs that have just started service.
      Parameters:
      model - the network model
      ind - the node index (0-based)
      n - per-class number of resident jobs
      s - per-class number of started jobs
      Returns:
      the state-space matrix (one row per valid state)

    • fromMarg

      public static Matrix fromMarg(Network model, int ind, int ntot)
      Generates the state space of a node from its TOTAL job count, all classes summed out. The class-summed counterpart of fromMarginal: the union of fromMarginal over every class split of ntot the node can hold.
      Parameters:
      model - the network model
      ind - the node index (0-based)
      ntot - total number of resident jobs, all classes summed
      Returns:
      the state-space matrix (one row per valid state)

    • fromMargAndStarted

      public static Matrix fromMargAndStarted(Network model, int ind, int ntot, int stot)
      Generates the state space of a node from its TOTAL job count and its TOTAL number of started jobs, both summed over classes.
      Parameters:
      model - the network model
      ind - the node index (0-based)
      ntot - total number of resident jobs
      stot - total number of jobs that have started service
      Returns:
      the state-space matrix (one row per valid state)

    • afterEvent

      public static Ret.EventResult afterEvent(NetworkStruct sn, int ind, Matrix inspace, EventType event, int jobClass, boolean isSimulation)

    • afterEvent

      public static Ret.EventResult afterEvent(NetworkStruct sn, int ind, Matrix inspace, EventType event, int jobClass, boolean isSimulation, EventCache eventCache)

    • afterEventInit

      public static AfterEventContext afterEventInit(NetworkStruct sn)
      Precomputes the loop-invariant setup of afterEvent so that hot callers (e.g., the Solver_ssa Gillespie loop) avoid re-deriving it on every event evaluation. Build it from the SAME sn instance later passed to afterEvent, after any caller-side rewrite of its fields (the Solver_ssa preamble rewrites nservers/cap/classcap in place).

    • afterEvent

      public static Ret.EventResult afterEvent(NetworkStruct sn, int ind, Matrix inspace, EventType event, int jobClass, boolean isSimulation, EventCache eventCache, AfterEventContext ctx)

    • afterEvent

      public static Ret.EventResult afterEvent(NetworkStruct sn, int ind, Matrix inspace, EventType event, int jobClass, boolean isSimulation, EventCache eventCache, AfterEventContext ctx, boolean noPromote)
      noPromote: when true, a DEP at an FCFS-family station does not promote a waiting job into the vacated server. Set only for the departure half of an immediate-feedback self-loop (sn.immfeed) so the fed-back job holds the server rather than re-queueing behind the waiting jobs. It is part of the cache key so immediate-feedback and ordinary departures never collide.

    • immfeedSelfLoop

      public static boolean immfeedSelfLoop(NetworkStruct sn, EventType eventA, int nodeA, int nodeP, int classP)
      True when a synchronization is an IMMEDIATE-FEEDBACK SELF-LOOP: a departure whose passive half is an arrival back at the same station, in a class the station holds its server for (sn.immfeed, set by Queue.setImmediateFeedback or JobClass.setImmediateFeedback). The departure half of such a synchronization must run with noPromote, so the vacated server is not given to a waiting job and the fed-back arrival seizes it instead. Every solver that walks sn.sync must consult this, or it answers a model in which the self-looping job re-queues behind the waiting jobs. The class read is the PASSIVE one: after a class switch the job comes back as the class it was switched INTO, and refreshSync folds the switch into sn.rt, so a class-switching self-loop is still one synchronization with passive node == active node.
      Parameters:
      sn - network structure
      eventA - the active event of the synchronization
      nodeA - the active node index
      nodeP - the passive node index
      classP - the passive job class index
      Returns:
      true if the departure half must not promote a waiting job

    • afterEventHashed

      public static Ret.EventResult afterEventHashed(NetworkStruct sn, int ind, double inhash, EventType event, int Jobclass)
      THE INPUT IS A HASH, SO THE INPUT MUST BE A STATE OF THE CHAIN. The departure half of an immediate-feedback self-loop leaves the server idle with jobs still waiting, which is NOT a state of the chain -- the enumerated space has no row for it, because between events a work-conserving station never idles with a queue -- so that pair must compose on the raw vector instead. See afterEventHashedFromSpace and immfeedSelfLoop.

    • afterEventHashedFromSpace

      public static Ret.EventResult afterEventHashedFromSpace(NetworkStruct sn, int ind, Matrix inspace, EventType event, int Jobclass)
      afterEventHashed with a RAW input state instead of a hash: the successors are still hashed, but the predecessor need not be a state of the chain. This exists for the IMMEDIATE-FEEDBACK self-loop (sn.immfeed). Its departure half runs with noPromote and so leaves the server idle with jobs still waiting, which has no row in the enumerated space -- between events a work-conserving station never idles with a queue, so the space generator never emits it. Hashing that intermediate returns -1 and the whole arc is dropped, which is worse than ignoring the flag: the generator loses the transitions instead of merely re-queueing the job. The two halves therefore compose on the raw vector, and only the state the PAIR ends in is hashed.
      Parameters:
      inspace - the raw predecessor state, which need not be in sn.space

    • afterEventHashedOrAdd

      public static Ret.afterEventHashedOrAddResult afterEventHashedOrAdd(NetworkStruct sn, int ind, int inhash, EventType event, int jobclass)
      Combination of afterEventHashed with automatic state space extension Migrated from MATLAB afterEventHashedOrAdd.m
      Parameters:
      sn - Network structure
      ind - Node index
      inhash - Input hash ID
      event - Event type
      jobclass - Job class
      Returns:
      Ret.afterEventHashedOrAddResult containing output hash, rate, probability and updated network

    • handleEnableEvent

      protected static State.EventHandleResult handleEnableEvent(NetworkStruct sn, int ind, GlobalSync glevent, List<Matrix> glspace, List<Matrix> outglspace, Matrix inspace, Matrix spaceBuf, Matrix spaceSrv, Matrix spaceVar, Matrix fK, Matrix fKs, int mode, TransitionNodeParam transParam, int R)
      Handles ENABLE events for transitions in Stochastic Petri Net (SPN) event processing. This method processes the enabling phase of a transition firing, which checks if the transition can be enabled based on available tokens in input places and generates all possible state combinations when the transition becomes enabled. It implements the SPN semantics for transition enabling with support for multiple job classes and server allocation.
      Parameters:
      sn - Network structure containing the complete SPN model definition
      ind - Node index of the transition being processed
      glevent - Global synchronization event containing active and passive events
      glspace - Current global state space (list of states for each stateful node)
      outglspace - Output global state space to be updated
      inspace - Input state space matrix for the transition node
      spaceBuf - Buffer state space matrix (job queue states)
      spaceSrv - Server state space matrix (server allocation states)
      spaceVar - Variable state space matrix (phase variables)
      fK - Firing phases matrix for the transition
      fKs - Cumulative firing phases matrix
      mode - Current firing mode of the transition
      transParam - Transition node parameters containing enabling/firing rules
      R - Number of job classes in the network
      outspace - Output state space matrix to be populated
      outrate - Output rates matrix to be populated
      outprob - Output probabilities matrix to be populated
      Throws:
      IllegalArgumentException - if enabling conditions cannot be satisfied
      See Also:

    • handleFireEvent

      protected static State.EventHandleResult handleFireEvent(NetworkStruct sn, int ind, GlobalSync glevent, List<Matrix> glspace, List<Matrix> outglspace, Matrix inspace, Matrix spaceBuf, Matrix spaceSrv, Matrix spaceVar, Matrix fK, Matrix fKs, int mode, TransitionNodeParam transParam, int R, boolean isSimulation)
      Handles FIRE events for transitions in Stochastic Petri Net (SPN) event processing. This method processes the firing phase of a transition after it has been enabled, implementing the complete SPN firing semantics including: - Calculating the enabling degree (maximum number of concurrent firings) - Processing PRE events (token consumption from input places) - Processing POST events (token production to output places) - Managing server state transitions and phase changes - Generating all possible outcome states with their associated rates and probabilities The method supports multiple job classes, multi-server environments, and complex firing patterns through multinomial probability distributions for server allocation.
      Parameters:
      sn - Network structure containing the complete SPN model definition
      ind - Node index of the transition being fired
      glevent - Global synchronization event containing active and passive events
      glspace - Current global state space (list of states for each stateful node)
      outglspace - Output global state space to be updated
      inspace - Input state space matrix for the transition node
      spaceBuf - Buffer state space matrix (job queue states)
      spaceSrv - Server state space matrix (server allocation states)
      spaceVar - Variable state space matrix (phase variables)
      fK - Firing phases matrix for the transition
      fKs - Cumulative firing phases matrix
      mode - Current firing mode of the transition
      transParam - Transition node parameters containing enabling/firing rules
      R - Number of job classes in the network
      outspace - Output state space matrix to be populated with resulting states
      outrate - Output rates matrix to be populated with transition rates
      outprob - Output probabilities matrix to be populated with firing probabilities
      Throws:
      IllegalStateException - if the transition cannot be fired from the current state
      ArithmeticException - if probability calculations result in invalid values
      See Also:

    • buildSpaceHashMap

      public static Map<StatefulNode,Map<String,Integer>> buildSpaceHashMap(Map<StatefulNode,Matrix> space)

    • buildSpaceHash

      public static void buildSpaceHash(NetworkStruct sn)

    • getHashOrAdd

      public static Ret.getHashOrAddResult getHashOrAdd(NetworkStruct sn, int ind, Matrix inspace)
      Get hash ID for a state space, or add the state to the space if not found Migrated from MATLAB getHashOrAdd.m
      Parameters:
      sn - Network structure
      ind - Node index
      inspace - Input state space
      Returns:
      Ret.getHashOrAddResult containing hash IDs and updated network structure

    • isValid

      public static boolean isValid(Network sn, Matrix n, Matrix s)

    • roundMarginalPreservingChains

      public static void roundMarginalPreservingChains(Matrix n, NetworkStruct sn)
      Rounds a fractional marginal queue-length matrix (station x class) to integers with the largest remainder method, so that every closed chain keeps exactly its own population. Plain element-wise rounding does not: it can move a job between classes of the same chain or lose one altogether, which yields a state outside the state space (or inside a different chain population, hence a different steady state). Open chains are rounded element-wise. Modifies n in place.
      Parameters:
      n - marginal queue lengths, stations by classes
      sn - structure supplying the chain membership and populations

    • isValid

      public static boolean isValid(NetworkStruct sn, Matrix n, Matrix s)

    • reachableSpaceGenerator

      public static Ret.reachableSpaceGeneratorResult reachableSpaceGenerator(NetworkStruct sn, SolverOptions options)
      Generates state space restricted to states reachable from initial state Migrated from MATLAB reachableSpaceGenerator.m
      Parameters:
      sn - Network structure
      options - Solver options
      Returns:
      Ret.reachableSpaceGeneratorResult containing reachable state spaces

    • cacheRetrievalClassMap

      public static int[][] cacheRetrievalClassMap(NetworkStruct sn, int ind)
      Canonical ordering of the retrieval classes of a cache node. Block B of the cache local-variable vector is indexed by this ordering, so that the originating (arrival) class of a merged secondary request -- hence its hit class -- is recoverable when the fetch completes.
      Parameters:
      sn - network structure
      ind - cache node index
      Returns:
      int[3][] holding, in ascending retrieval-class order, the retrieval class indices, the 1-based item each serves, and the originating arrival class

    • spaceCachePublic

      public static Matrix spaceCachePublic(int n, Matrix m, int retrievalSystemCapacity)
      Make spaceCache method public Generates cache state space
      Parameters:
      n - Cache size
      m - Number of items
      retrievalSystemCapacity - number of items that can be in the retrieval system simultaneously
      Returns:
      Cache state space matrix

    • spaceClosedMulti

      public static Matrix spaceClosedMulti(int M, Matrix N)

    • spaceClosedMultiCS

      public static Matrix spaceClosedMultiCS(int M, Matrix N, Matrix chains)

    • spaceClosedMultiCSBounded

      public static Matrix spaceClosedMultiCSBounded(int M, Matrix N, Matrix chains, Matrix capMatrix, Set<String> visitedSums)

    • spaceClosedSinglePublic

      public static Matrix spaceClosedSinglePublic(int M, int N)
      Make spaceClosedSingle method public Generates state space for single-class closed networks
      Parameters:
      M - Number of stations
      N - Number of jobs
      Returns:
      State space matrix

    • spaceGenerator

      public static State.StateSpaceGeneratorResult spaceGenerator(NetworkStruct sn, Matrix cutoff, SolverOptions options)
      Generates the state space for a queueing network using a matrix cutoff. Each element of the cutoff matrix specifies the maximum population for the corresponding station-class combination.
      Parameters:
      sn - Network structure
      cutoff - Matrix of cutoff values with dimensions nstations × nclasses
      options - Solver options
      Returns:
      State space generation result
      Throws:
      IllegalArgumentException - if cutoff matrix dimensions don't match network structure

    • spaceGeneratorNodes

      public static State.spaceGeneratorNodesResult spaceGeneratorNodes(NetworkStruct sn, Matrix cutoff, SolverOptions options)

    • spaceLocalVarsPublic

      public static Matrix spaceLocalVarsPublic(NetworkStruct sn, int ind)
      Make spaceLocalVars method public Generates local variable state spaces
      Parameters:
      sn - Network structure
      ind - Node index
      Returns:
      Local variable state space

    • spaceLocalVarsPublic

      public static Matrix spaceLocalVarsPublic(NetworkStruct sn, int ind, int maxPending)
      Make spaceLocalVars method public, at a given delayed-hit truncation level. Mirrors the three-argument MATLAB State.spaceLocalVars.
      Parameters:
      sn - Network structure
      ind - Node index
      maxPending - secondary requests that may merge onto one in-flight fetch
      Returns:
      Local variable state space