Package jline.examples.java.advanced

Class LoadDependentExamples

java.lang.Object
jline.examples.java.advanced.LoadDependentExamples
public class LoadDependentExamples extends Object
Examples demonstrating load-dependent queueing behavior. This class provides Java implementations corresponding to the example notebooks in jline.examples.java.advanced.loadDependent package.

  • Constructor Summary

    Constructors
    Constructor
    Description
    LoadDependentExamples()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static void
    fes_aggregation()
    Flow-equivalent-server aggregation of a two-class tandem (fes_aggregation).
    static void
    fes_single_class()
    Flow-equivalent-server aggregation of a single-class tandem (fes_single_class).
    static void
    ld_class_dependence()
    Demonstrates load-dependent behavior with class dependence (ld_class_dependence.ipynb).
    static void
    ld_fes_multiclass()
    The same aggregation with two classes (ld_fes_multiclass).
    static void
    ld_fes_singleclass()
    Norton's theorem on a single-class tandem, solved by convolution (ld_fes_singleclass).
    static void
    ld_joint_dependence()
    Demonstrates joint (non-product-form) load dependence (ld_joint_dependence.m).
    static void
    ld_multiserver_fcfs()
    Demonstrates load-dependent multi-server with FCFS discipline (ld_multiserver_fcfs.ipynb).
    static void
    ld_multiserver_ps()
    Demonstrates load-dependent multi-server with processor sharing (ld_multiserver_ps.ipynb).
    static void
    ld_multiserver_ps_twoclasses()
    Demonstrates load-dependent PS with two classes (ld_multiserver_ps_twoclasses.ipynb).
    static void
    main(String[] args)
    Main method to run all load-dependent examples.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • LoadDependentExamples

      public LoadDependentExamples()

  • Method Details

    • ld_class_dependence

      public static void ld_class_dependence() throws Exception
      Demonstrates load-dependent behavior with class dependence (ld_class_dependence.ipynb). This example shows how service rates can depend on the mix of customer classes present in the queue. This models situations where different types of customers create different levels of resource contention. Features: - Service rates dependent on class composition - Multi-class load-dependent queues - Analysis of class interaction effects - Performance isolation between classes
      Throws:
      Exception - if the solver encounters an error

    • ld_joint_dependence

      public static void ld_joint_dependence() throws Exception
      Demonstrates joint (non-product-form) load dependence (ld_joint_dependence.m).

      The station rate reads the class-1 marginal only and is shared by every class, so it is NOT the product-form beta_{i,r}(n_{i,r}) of ld_class_dependence(); the exact CTMC is the reference against which the QD-AMVA approximation is read.

      Throws:
      Exception - if the solver encounters an error

    • ld_multiserver_fcfs

      public static void ld_multiserver_fcfs() throws Exception
      Demonstrates load-dependent multi-server with FCFS discipline (ld_multiserver_fcfs.ipynb). This example models a multi-server queue where the effective service rate depends on the number of customers in the system. Under FCFS, this creates complex interactions between waiting times and system occupancy. Features: - Multi-server queue with load-dependent rates - FCFS scheduling discipline - Modeling of server activation/deactivation - Analysis of economies/diseconomies of scale
      Throws:
      Exception - if the solver encounters an error

    • ld_multiserver_ps

      public static void ld_multiserver_ps() throws Exception
      Demonstrates load-dependent multi-server with processor sharing (ld_multiserver_ps.ipynb). This example shows load-dependent behavior in a processor sharing environment. PS discipline distributes service capacity equally among all customers, and the load dependence models how this capacity changes with system load. Features: - Multi-server queue with processor sharing - Load-dependent service capacity - Fair sharing of variable capacity - Comparison with FCFS load dependence
      Throws:
      Exception - if the solver encounters an error

    • ld_multiserver_ps_twoclasses

      public static void ld_multiserver_ps_twoclasses() throws Exception
      Demonstrates load-dependent PS with two classes (ld_multiserver_ps_twoclasses.ipynb). This example extends the PS load-dependent case to multiple customer classes. Each class can have different impacts on the load-dependent behavior, modeling heterogeneous workloads with different resource requirements. Features: - Two-class processor sharing system - Class-specific load dependence effects - Analysis of fairness across classes - Performance differentiation strategies
      Throws:
      Exception - if the solver encounters an error

    • fes_aggregation

      public static void fes_aggregation() throws Exception
      Flow-equivalent-server aggregation of a two-class tandem (fes_aggregation).

      Queue1 and Queue2 are replaced by one limited-class-dependent station whose per-class rates are the isolated subnetwork's throughputs. For a closed product-form network Norton's theorem makes this EXACT, so the aggregated throughput reproduces the original's rather than approximating it, which is what the comparison below prints.

      Throws:
      Exception - if the solver encounters an error

    • fes_single_class

      public static void fes_single_class() throws Exception
      Flow-equivalent-server aggregation of a single-class tandem (fes_single_class).
      Throws:
      Exception - if the solver encounters an error

    • ld_fes_singleclass

      public static void ld_fes_singleclass() throws Exception
      Norton's theorem on a single-class tandem, solved by convolution (ld_fes_singleclass).

      All THREE queues are aggregated, leaving the think time beside one FES, and the aggregate is solved with exact NC: the FES rates are Sauer's chain-dependent service rates, which the convolution consumes directly.

      Throws:
      Exception - if the solver encounters an error

    • ld_fes_multiclass

      public static void ld_fes_multiclass() throws Exception
      The same aggregation with two classes (ld_fes_multiclass).
      Throws:
      Exception - if the solver encounters an error

    • main

      public static void main(String[] args)
      Main method to run all load-dependent examples.
      Parameters:
      args - command line arguments (not used)