Package jline.examples.java.advanced

Class LoadDependentModel

java.lang.Object
jline.examples.java.advanced.LoadDependentModel
public class LoadDependentModel extends Object
Examples of models with load-dependent stations

  • Constructor Details

    • LoadDependentModel

      public LoadDependentModel()

  • Method Details

    • ld_multiserver_fcfs

      public static Network ld_multiserver_fcfs()
      Basic load-dependent queue with FCFS scheduling.

      Features: - Closed network with 16 jobs and delay node - FCFS queue with load-dependent service capacity - Service capacity increases linearly up to 2 servers - Alpha function: min(jobs+1, 2) servers available - Demonstrates load-dependent server allocation

      Returns:
      configured load-dependent network model

    • ld_multiserver_ps_twoclasses

      public static Network ld_multiserver_ps_twoclasses()
      Multi-class load-dependent network with PS scheduling.

      Features: - Two closed classes: Class1 (4 jobs), Class2 (2 jobs) - PS queue with total load-dependent capacity - Service capacity based on total population across both classes - Different service rates for each class - Demonstrates multi-class load dependence

      Returns:
      configured multi-class load-dependent model

    • ld_multiserver_ps

      public static Network ld_multiserver_ps()
      Three-station network with multiple load-dependent queues.

      Features: - Two closed classes with different populations - Two PS queues (Queue1, Queue2) both with load dependence - Serial routing: Delay → Queue1 → Queue2 → Delay - Each queue has capacity up to 3 servers - Different service rates at each station per class

      Returns:
      configured multi-station load-dependent model

    • ld_class_dependence

      public static Network ld_class_dependence()
      Class-dependent service capacity model.

      Features: - Two closed classes with different populations - PS queue with class-dependent capacity function - Service capacity depends only on Class1 population - Demonstrates selective load dependence by class - Custom SerializableFunction for capacity calculation

      Returns:
      configured class-dependent network model

    • ld_joint_dependence

      public static Network ld_joint_dependence()
      Joint-dependent (non-product-form) model, the twin of ld_class_dependence() and the port of MATLAB ld_joint_dependence.m.

      eta_i(n) reads the class-1 marginal only and returns a scalar shared by every class. Because it depends on a foreign class marginal rather than the own-class one, it is NON-product-form and must be declared through setJointDependence; setClassDependence is reserved for the product-form beta_{i,r}(n_{i,r}).

    • ld_global_dependence

      public static Network ld_global_dependence()
      Globally state-dependent (Whittle) model: setGlobalDependence declares a rate scaling phi(n) over the FULL (nstations x nclasses) population matrix, not just the population local to one station. Here two PS stations share one unit of capacity, phi_s(n) = n_s/|n|, the single-link allocation every alpha-fair rule collapses to.

      phi satisfies the Whittle balance property phi_s(n) phi_t(n-e_s) = phi_t(n) phi_s(n-e_t), so the chain is reversible, has the product form pi(n) ~ Phi(n) prod rho^n and is INSENSITIVE: the means do not change when the exponential service is replaced by an Erlang or a hyperexponential of the same mean.

      Only SolverCTMC and SolverSSA declare the GlobalDependence feature; every other solver rejects the model rather than solving it unscaled. SolverSSA carries the same factorization on the sample path, on its serial engine: the NRM's propensity closures see one station's population slice and never the whole population matrix phi reads.

      Returns:
      configured globally state-dependent network model

    • ld_whittle_bandwidth

      public static Network ld_whittle_bandwidth()
      Open Whittle network: a bandwidth-sharing model in which one route holds SEVERAL links at once, which no per-station rate scaling can express. This is the 2-link linear network -- route 1 crosses both links, routes 2 and 3 use one link each -- shared by BALANCED FAIRNESS, whose rates x_s(n) = Phi(n-e_s)/Phi(n) satisfy the Whittle balance property by construction. The stationary law is therefore pi(n) ~ Phi(n) prod rho_s^n_s and is insensitive.

      Each route is modelled as its own PS queue fed by its own open class, so the queue populations ARE the coordinates of the Whittle state n. Solve with SolverCTMC and an options.cutoff matching CUTOFF below.

      CUTOFF is 3 here rather than the 6 the MATLAB twin uses: the JAR sizes the open state space of this model more conservatively and its memory guard refuses 6. At the same cutoff all four codebases agree to the digit, and to the closed-form product form.

      Returns:
      configured open bandwidth-sharing model

    • fes_tandem

      public static Network fes_tandem(String name, String delayName, double n1, double n2, double[] delayMeans, double[] q1Means, double[] q2Means, double[] q3Means, String[] queueNames)
      The 4-station tandem the `fes_*` and `ld_fes_*` scripts aggregate.

      Delay -> Q1 -> Q2 -> Q3 -> Delay, every queue processor-sharing. The second class is built only when a second mean is supplied, which is what separates the single-class scripts from the two-class ones.

      Parameters:
      name - model name
      delayName - name of the think-time station, which the reference varies
      n1 - population of Class1
      n2 - population of Class2, ignored when the model is single-class
      delayMeans - per-class think time; length 1 makes the model single-class
      q1Means - per-class mean service at the first queue
      q2Means - per-class mean service at the second queue
      q3Means - per-class mean service at the third queue
      queueNames - the three queue names
      Returns:
      the tandem, linked

    • fes_aggregation

      public static Network fes_aggregation()
      The two-class tandem of `fes_aggregation`, N = (3, 2).

    • fes_single_class

      public static Network fes_single_class()
      The single-class tandem of `fes_single_class`, N = 5.

    • ld_fes_singleclass

      public static Network ld_fes_singleclass()
      The single-class tandem of `ld_fes_singleclass`, N = 5, queues named Q1..Q3.

    • ld_fes_multiclass

      public static Network ld_fes_multiclass()
      The two-class tandem of `ld_fes_multiclass`, N = (3, 2).

    • main

      public static void main(String[] args)
      Main method for testing and demonstrating load-dependent examples.

      Currently configured to run ld_multiserver_ps_twoclasses() and solve it using the MVA solver with default method settings.

      Parameters:
      args - command line arguments (not used)