Package jline.examples.java.basic

Class ForkJoinModel

java.lang.Object
jline.examples.java.basic.ForkJoinModel
public class ForkJoinModel extends Object
Examples of fork-join queueing networks

  • Constructor Details

    • ForkJoinModel

      public ForkJoinModel()

  • Method Details

    • fj_basic_open

      public static Network fj_basic_open()
      Basic open fork-join network with single class.

      Features: - Single open class with exponential arrivals (rate 0.05) - Fork node splits jobs to two parallel FCFS queues - Join node synchronizes completion from both queues - Different service rates: Queue1 (rate 1.0), Queue2 (rate 2.0) - Demonstrates basic fork-join synchronization

      Returns:
      configured fork-join network model

    • fj_mixed_openclosed

      public static Network fj_mixed_openclosed()
      Fork-join traversed by an open AND a closed class at once.

      Features: - Open class (Poisson rate 0.1) and closed class (1 job, think time 1) - Both classes share PreFork -> Fork -> two branches -> Join -> PostJoin - Flat counterpart of LayeredModel.lqn_fork_open_arrival(), which SolverLN refuses because the fork-join transform's Source collides with the layer's open-stream Source

      Reference (JMT, seed 23000, 2e5 samples): Branch1 open RespT 0.362, closed RespT 0.310, Join open RespT 0.215, closed throughput 0.540.

      Returns:
      configured mixed open/closed fork-join model

    • fj_asymm

      public static Network fj_asymm()
      Asymmetric closed fork-join network with serial queues.

      Features: - Single closed class with 10 jobs - Delay node followed by asymmetric fork-join - Branch 1: Queue1 (FCFS), Branch 2: Queue2→Queue3 serial (FCFS) - Different service rates creating asymmetric load - Demonstrates closed system with asymmetric parallel branches

      Returns:
      configured asymmetric fork-join model

    • fj_delays

      public static Network fj_delays()
      Closed fork-join network with two delays and two parallel queues.

      Features: - Single closed class with 10 jobs - Delay1→Delay2→Fork→{Queue1,Queue2}→Join→Delay1 cycle - FCFS scheduling for both parallel queues - Different service rates for delays and queues - Demonstrates multi-stage delays before fork-join

      Returns:
      configured closed fork-join model with delays

    • fj_complex_serial

      public static Network fj_complex_serial()
      Complex closed fork-join with serial processing within branches.

      Features: - Single closed class with 10 jobs - Fork to two branches with series queues within each branch - Branch 1: Queue1 → Queue4 → Queue5 - Branch 2: Queue2 → Queue3 - Different service rates creating load imbalance - Demonstrates fork-join with complex internal structure

      Returns:
      configured complex fork-join model

    • fj_threebranches

      public static Network fj_threebranches()
      Multi-class closed fork-join with asymmetric routing.

      Features: - Two closed classes with 10 jobs each - Fork to three PS queues with asymmetric connections - Queue2 → Queue3 connection creates series within branch - Different service rates for each class at each queue - Demonstrates multi-class load balancing in fork-join

      Returns:
      configured multi-class asymmetric fork-join model

    • fj_twoclasses_forked

      public static Network fj_twoclasses_forked()
      Multi-class fork-join network with different task multiplicity.

      Features: - Two open classes with different arrival rates (0.25 each) - Fork node creates 2 tasks per link for each job - PS scheduling for both parallel queues - Class2 has immediate service at Queue1, exponential at Queue2 - Demonstrates multi-class fork-join with task multiplication

      Returns:
      configured multi-class fork-join model

    • fj_basic_nesting

      public static Network fj_basic_nesting()
      Complex closed fork-join network with nested fork-join structures.

      Features: - Two closed classes with populations [5, 2] - Nested fork-join: Class2 goes through Fork1_1 then Fork1 - Multiple join synchronization points - PS queues with different service rates per class - Demonstrates complex fork-join topologies in closed systems

      Returns:
      configured nested fork-join model

    • fj_nojoin

      public static Network fj_nojoin()
      Open fork-join network without explicit join node.

      Features: - Single open class with exponential arrivals - Fork node splits to three parallel PS queues - No explicit Join node - jobs exit independently - Different service rates for each parallel branch - Demonstrates fork without synchronization requirement

      Returns:
      configured fork-only network model

    • fj_variable_fanout

      public static Network fj_variable_fanout(String mode)
      A fork whose degree is NOT one fixed number, in the four ways it can vary.
      • "fixed" the classic fork, one task on each of two links
      • "vector" three tasks towards Queue2 and one towards Queue1
      • "random" one or three tasks per link, each with probability 1/2
      • "prob" the branch towards Queue2 fires only half the time

      Exact under SolverJMT and SolverLDES, which draw the degree at the fork epoch. SolverMVA's MMT method sees the EXPECTED degree. The exact CTMC/SSA path accepts "fixed" and "vector" and refuses the other two by name, because its tag construction fixes the sibling count when the state space is built.

    • fj_basic_closed

      public static Network fj_basic_closed()

    • fj_serialfjs_open

      public static Network fj_serialfjs_open()
      Open network with cascaded fork-join stages.

      Features: - Single open class with exponential arrivals (rate 2.5) - Two fork-join stages in series - First stage: Fork1 → Queue1&Queue2 → Join1 - Second stage: Fork2 → Queue3&Queue4 → Join2 - All queues FCFS with identical service rates - Demonstrates staged parallel processing

      Returns:
      configured cascaded fork-join model

    • fj_cs_postfork

      public static Network fj_cs_postfork()
      Closed fork-join network with class switching after fork (post-fork).

      Based on matlab/examples/basic/forkJoin/fj_cs_postfork.m

      Features: - Two closed classes with 1 job each - Class 1: normal fork-join flow without class switching - Class 2: switches to class 1 after the fork (post-fork switching) - PS queues with exponential service rates - Demonstrates fork-join with class transformation after forking

      Returns:
      configured fork-join model with post-fork class switching

    • fj_cs_multi_visits

      public static Network fj_cs_multi_visits()
      Open fork-join with feedback loop and class switching.

      Features: - Two open classes: Class1 with arrivals, Class2 generated internally - Fork-join structure with PS queues - Router node creates feedback from Join back to Fork - Class switching capabilities at router - Demonstrates complex routing in fork-join networks

      Returns:
      configured fork-join model with feedback

    • fj_route_overlap

      public static Network fj_route_overlap()
      Fork-join with overlapping routes (fj_route_overlap.m).

      Two-class closed fork-join model matching MATLAB implementation.

      Features: - Two closed classes with 10 jobs each - Delay node with different service rates per class - Fork splits to two parallel FCFS queues - Queue service rates: Queue1(1.0), Queue2(2.0) for both classes - Join synchronizes both branches - Closed cycle: Delay → Fork → Queues → Join → Delay

      Returns:
      configured two-class fork-join model

    • fj_cs_prefork

      public static Network fj_cs_prefork()
      Fork-join network with class switching demonstration.

      Features: - Two closed classes with potential class switching - Multiple delay and queue nodes with PS scheduling - Fork-join structure with symmetric branches - Identical service rates for class switching analysis - Demonstrates class transformation in fork-join context

      Returns:
      configured fork-join model with class switching

    • fj_deep_nesting

      public static Network fj_deep_nesting()

    • fj_serialfjs_closed

      public static Network fj_serialfjs_closed()

    • main

      public static void main(String[] args)
      Main method for testing and demonstrating fork-join model examples.

      Currently configured to: - Run fj_basic_open() basic fork-join example - Solve using MVA solver and display results - Open JSimwView visualization (if available) - Solve using JMT solver for comparison

      Parameters:
      args - command line arguments (not used)

    • test_forkJoinCS_1

      public static Network test_forkJoinCS_1()