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_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_basic_closed

      public static Network fj_basic_closed()
      Simple closed fork-join network with symmetric service rates.

      Features: - Single closed class with 5 jobs - Delay node and two PS queues with identical service rates (1.0) - Basic closed fork-join cycle: Delay → Fork → Queue1invalid input: '&Queue2' → Join → Delay - Demonstrates balanced load sharing in closed systems

      Returns:
      configured simple closed fork-join model

    • 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 → Queue1invalid input: '&Queue2' → Join1 - Second stage: Fork2 → Queue3invalid input: '&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()