Package jline.examples.java

Class GettingStarted

java.lang.Object
jline.examples.java.GettingStarted
public class GettingStarted extends Object
Getting started examples

  • Constructor Details

    • GettingStarted

      public GettingStarted()

  • Method Details

    • tut01_mm1_basics

      public static Network tut01_mm1_basics()
      Getting started example 1: Basic M/M/1 queue.

      Features: - Simple M/M/1 queueing system - Exponential arrivals (rate 1.0) and service (rate 2.0) - FCFS scheduling with single server - LDES solver demonstration with result printing - Shows basic network construction and solution

      Returns:
      configured M/M/1 network model

    • tut02_mg1_multiclass_solvers

      public static Network tut02_mg1_multiclass_solvers()
      Getting started example 2: M/G/1 queue with two classes.

      Features: - Two open classes with different service distributions - Class1: Erlang service distribution (SCV = 1/3) - Class2: Trace-driven service using APH fitting - Demonstrates empirical data integration via Replayer - Manual routing matrix construction

      Returns:
      configured M/G/1 multi-class network model

    • tut03_repairmen

      public static Network tut03_repairmen()
      Getting started example 3: Machine Repair Problem (MRP).

      Features: - Closed network with 3 machines - Working state (delay) and repair queue with 2 servers - CTMC solver for exact state space analysis - Steady state probability computation - Demonstrates closed system modeling

      Returns:
      configured machine repair model

    • tut04_lb_routing

      public static Network tut04_lb_routing()
      Getting started example 4: Load balancing with routing strategies.

      Features: - Load balancer (router) distributing jobs to two PS queues - Demonstrates RAND (random) and RROBIN (round-robin) routing - Identical service rates for fair comparison - Shows how to change routing strategies dynamically - Model reset and re-solve for strategy comparison

      Returns:
      configured load balancing network model

    • tut05_completes_flag

      public static Network tut05_completes_flag()
      Getting started example 5: Class switching in single-node network.

      Features: - Three closed classes cycling through Class1→Class2→Class3→Class1 - Single FCFS queue with different Erlang service for each class - Demonstrates class switching routing matrix - Shows impact of setCompletes(false) on performance metrics - NC solver for exact normalizing constant computation

      Returns:
      configured class switching model

    • tut06_cache_lru_zipf

      public static Network tut06_cache_lru_zipf()
      Getting started example 6: Cache modeling with Zipf access pattern.

      Features: - LRU cache with 1000 items and capacity 50 - Zipf distribution (α=1.4) for realistic access patterns - Three classes: ClientClass, HitClass, MissClass - Different service times for cache hits vs misses - Demonstrates cache performance analysis

      Returns:
      configured cache network model

    • tut07_delayed_hit_cache

      public static Network tut07_delayed_hit_cache()
      Getting started example 7: delayed-hit cache with a processor-sharing retrieval queue.

      Features: - Open model: a RR cache of capacity 6 over 7 items, read under a skewed popularity - On a miss the request is fetched by a PS retrieval queue and returns to the cache, so requests for an item already being fetched become delayed hits - NC and MVA delayed-hit analyzers; the hit/miss ratios and the retrieval latency are read back from the Cache node, entry 0 being the read class

      Returns:
      configured delayed-hit cache model

    • tut08_respt_cdf

      public static Network tut08_respt_cdf()
      Getting started example 8: Simple closed network for optimization.

      Features: - Basic closed network with delay and PS queue - Single closed class with 5 jobs - Demonstrates foundation for optimization studies - Shows basic structure for parameter analysis

      Returns:
      configured simple closed network model

    • tut09_opt_load_balancing

      public static Network tut09_opt_load_balancing()
      Getting started example 9: Optimization with COBYLA algorithm.

      Features: - Closed load balancing network with optimization - Two PS queues with different service rates - COBYLA optimizer to find optimal routing probability - Minimizes average system response time - Demonstrates integration of queueing models with optimization

      Returns:
      optimized load balancing network model

    • tut10_dep_process_analysis

      public static void tut10_dep_process_analysis()
      Getting started example 10: Studying a departure process.

      Features: - Analysis of departure process from M/E/1 queue - CTMC solver with system sampling (sampleSysAggr) - Departure event filtering and inter-departure time analysis - Comparison of empirical vs theoretical SCV (Marshall's formula) - Demonstrates advanced sampling and stochastic analysis The Java implementation fully supports departure process analysis including: - Filtering departure events from sampled trajectories - Computing inter-departure times and empirical SCV - Calculating theoretical SCV using Marshall's formula - Comparing empirical vs theoretical results

    • tut11_lqn_basics

      public static LayeredNetwork tut11_lqn_basics()
      Getting started example 11: Basic layered queueing network.

      Features: - Layered queueing network (LQN) modeling - Two-tier client-server application - Client processor and database processor - Reference task with think time - Synchronous calls between tasks - Multiple database calls per client request - Demonstrates hierarchical performance analysis

      Returns:
      configured layered network model

    • tut12_random_env

      public static Environment tut12_random_env() throws Exception
      Getting started example 12: Random environments and SolverENV.

      This tutorial has been moved to RandomEnvExamples.renv_basic(). Delegates to that implementation for backward compatibility.

      This tutorial illustrates how to model a queueing system operating in a random environment, where system parameters (e.g., service rates) change according to an underlying environmental process.

      Scenario: A server that alternates between "Fast" and "Slow" modes. In Fast mode, service rate is 4.0. In Slow mode, service rate is 1.0. The environment switches from Fast->Slow at rate 0.5 and Slow->Fast at rate 1.0.

      Features: - Random environment with two operational stages - Stage-dependent service rates - Exponential transitions between environment stages - ENV solver with Fluid (FLD) sub-solver - Environment-averaged performance metrics

      Returns:
      configured environment model
      Throws:
      Exception - if solver encounters an error
      See Also:

    • tut13_posterior_analysis

      public static Network tut13_posterior_analysis()
      Getting started example 13: UQ analysis with uncertain parameters.

      Models an M/M/1 queue with arrival rate λ = 0.5 and an uncertain service rate represented by a Prior with 30 Gaussian-weighted alternatives over [0.7, 2.5] centred at μ = 1.3. The UQ solver wraps an inner solver (here MVA), runs it once per alternative, and aggregates the per-alternative results into prior-weighted means and per-alternative empirical posterior CDFs.

      Returns:
      the M/M/1 network with the Prior service distribution

    • tut14_cluster

      public static Network tut14_cluster()
      Getting started example 14: Open cluster.

      Source -> Dispatcher (Router) -> Server[1..M] -> Sink, with a single open class. The example contrasts two equivalent ways to build the model: the one-liner Network.clusterPs(Matrix, Matrix) factory, and the chainable Cluster builder, which also exposes helpers to compare dispatching policies on the same cluster.

      Returns:
      the open cluster Network built via the one-liner factory

    • tut15_bound_analysis

      public static Network tut15_bound_analysis()
      Getting started example 15: bound analysis with SolverBA.

      A bounding solver answers a different question from SolverMVA. Instead of a single point estimate it returns one guaranteed side of an interval, and the .lower/.upper pair of a family brackets the exact solution. Bounds need only the service demands and the population, never the service distributions, so they are cheap enough to sit inside an optimization loop where a full solve would be too slow.

      Returns:
      the closed BoundsDemo model

    • tut15_loss_network

      public static Network tut15_loss_network()
      Getting started example 15 (second tutorial under this number in MATLAB and Python): two-class finite-capacity loss network.

      Features: - Two open classes visiting an infinite-server Delay - A finite capacity region over the Delay: at most 5 jobs in total and 3 per class - Jobs arriving to a full region are dropped (loss network) - NC (Erlang fixed point, lossn), NC Monte Carlo integration (mci) and LDES simulation

      Returns:
      configured loss network model

    • tut16_queueing_petri_net

      public static Network tut16_queueing_petri_net()
      Getting started example 16: closed queueing Petri net.

      Features: - Two queueing places: CPU (single-server FCFS) and Think (infinite server) - Two immediate transitions moving one token per firing between them - LDES simulation of the net, cross-checked against the equivalent Delay + FCFS queue closed network solved exactly by MVA

      Returns:
      configured queueing Petri net

    • tut17_colored_gspn

      public static Network tut17_colored_gspn()
      Getting started example 17: colored generalized stochastic Petri net.

      Features: - Two token colors (Gold, Silver), two tokens each, starting in the Buffer place - Immediate admission with inhibitor arcs on both colors, so only one token is in service, and firing weights choosing gold twice as often as silver - Timed service with one exponential mode per color - Exact CTMC solution cross-checked by SSA simulation

      Returns:
      configured colored GSPN

    • main

      public static void main(String[] args) throws IllegalAccessException, ParserConfigurationException
      Main method for testing and demonstrating getting started examples.

      Only builds the model of tut04_lb_routing(); call the individual tutNN_* methods to run the other tutorials. The method names follow the MATLAB and Python numbering, including its two tutorials numbered 15 (tut15_bound_analysis and tut15_loss_network).

      Parameters:
      args - command line arguments (not used)
      Throws:
      IllegalAccessException - if access restrictions prevent execution
      ParserConfigurationException - if XML parsing configuration fails