Study guide
6.3 Decision, Merge, Fork & Join Execution
OMG Certified Systems Modeling Professional — Model User OCSMP OMG-OCSMP-MU100
Track your progress as you read
Finished sections get a check mark.
1 Introduction & Exam Overview
About the OCSMP Model User (OMG-OCSMP-MU100) Exam
2 Chapter 1: SysML Overview, Diagram Framework & Model Organization
1.1 SysML Overview, MBSE Foundations & Diagram Frame Syntax 1.2 Model Organization, Packages & Viewpoints
3 Chapter 2: Block Definition Diagrams — Blocks & Structural Features
2.1 Block Definitions, Features & Compartments 2.2 ValueTypes, Units, Dimensions & Primitive Types 2.3 Specialization, Generalization & Inheritance Hierarchies
4 Chapter 3: Block Definition Diagrams — Associations, Composition & Multiplicities
3.1 Associations, Composite Aggregation & Reference Associations 3.2 Multiplicities, Reference Properties & Association Ends
5 Chapter 4: Internal Block Diagrams — Internal Structure & Interconnection
4.1 Enclosing Blocks & Part Usages 4.2 Standard Ports, Flow Ports & Interfaces 4.3 Connectors, Item Flows & Flow Specifications
6 Chapter 5: Parametric Diagrams & Constraint Modeling
5.1 Constraint Blocks, Properties & Mathematical Expressions 5.2 Parametric Diagrams & Binding Connectors
7 Chapter 6: Activity Diagrams — Control & Object Flows
6.1 Activity Diagram Anatomy & Control Nodes 6.2 Object Flow, Pins & Activity Parameter Nodes 6.3 Decision, Merge, Fork & Join Execution
8 Chapter 7: Activity Diagrams — Partitions & Action Types
7.1 Activity Partitions (Swimlanes) & Structural Allocation 7.2 Action Types: Call Behavior, Send Signal & Accept Event
9 Chapter 8: State Machine Diagrams — States, Transitions & Events
8.1 State Machine Basics: States, Regions & Orthogonality 8.2 Transitions, Trigger-Guard-Effect Syntax & State Behaviors 8.3 Event Types & Run-to-Completion Semantics
10 Chapter 9: Sequence Diagrams — Message Interactions & Lifelines
9.1 Sequence Diagram Fundamentals, Lifelines & Execution 9.2 Message Types & Interaction References (ref)
11 Chapter 10: Cross-Cutting Constructs — Allocations & Metadata
10.1 The «allocate» Dependency: Semantics & Types 10.2 Allocation Representations: Callouts, Compartments, Partitions & Tables 10.3 Comments, Rationales, Problems, Stereotypes, Frames & Diagram Descriptions
12 Chapter 11: Requirement Diagrams — Requirements Modeling & Traceability
11.1 Requirement Element Definition, ID, Text & Compartments 11.2 Key Relationships: Derive, Satisfy & Verify 11.3 Refine, Trace & Containment Hierarchies
13 Chapter 12: Use Case Diagrams — System Context & Capabilities
12.1 Actors, Use Cases & Subject Boundaries 12.2 Associations, Include, Extend & Generalization
6.3 Decision, Merge, Fork & Join Execution
Key Takeaways Explain This Topic AI
Decision nodes (hollow diamond, 1-to-N) evaluate mutually exclusive guard conditions [guard] to route an incoming token down exactly one path.
Merge nodes (hollow diamond, N-to-1) bring alternative paths together without synchronization, immediately passing any arriving token to the outgoing edge.
Fork nodes (thick black bar, 1-to-N) duplicate an incoming token concurrently across all outgoing edges to initiate parallel execution threads.
Join nodes (thick black bar, N-to-1) synchronize concurrent execution by holding tokens until all incoming edges provide a token before emitting a single unified token.
Pairing a Decision node with a downstream Join node produces an unrecoverable system deadlock because the Join waits eternally for unexecuted branches.
Last updated: September 2026
6.3 Decision, Merge, Fork & Join Execution
Quick Reference: SysML separates conditional branching from concurrent execution using distinct control node geometries. Decision (1-to-N) and Merge (N-to-1) nodes use hollow diamonds to route tokens along mutually exclusive alternative paths without synchronization. Fork (1-to-N) and Join (N-to-1) nodes use thick black bars to initiate and synchronize concurrent parallel threads. Confusing Merge with Join is the primary cause of activity model deadlocks.
Branching vs. Concurrency: The Architectural Divide
A fundamental requirement in systems behavioral modeling is distinguishing between two different types of flow divergence and convergence:
Alternative Branching (Choice): The system evaluates dynamic conditions and selects exactly one path out of several mutually exclusive options. The other paths are not executed. This is modeled using Decision Nodes and recombined using Merge Nodes .
Concurrent Execution (Parallelism): The system initiates all paths simultaneously or in arbitrary order. Every path executes independently. This is modeled using Fork Nodes and synchronized using Join Nodes .
Mixing up the symbols or semantics of these two paradigms leads to non-functional system models and fatal simulation failures.
Decision Nodes: Conditional Selection
A Decision Node routes an incoming control or object token to one of several alternative outgoing edges based on evaluated guard expressions.
Geometry and Notation
Shape: A hollow diamond (rhombus) symbol ( ◇ ).
Connectivity: Exactly one incoming edge (or one primary edge and one decision input flow) and two or more outgoing edges .
Guard Conditions: Outgoing edges of a decision node normally carry a guard condition in square brackets, [guardExpression] . An edge with no guard is treated as always true.
Guard Evaluation and Firing Rules
Dynamic Evaluation: When a token arrives at the decision node, the guard conditions on all outgoing edges are evaluated.
Mutual Exclusivity: Guards should be modeled as mutually exclusive so that only one guard evaluates to true for any given system state.
Token Routing: The token is offered only to the single outgoing edge whose guard evaluates to true. A decision node never duplicates tokens ; exactly one token enters, and that same single token exits down the selected path.
The Predefined [else] Guard: A modeler can designate at most one outgoing edge with the reserved guard [else] . The [else] path is selected if and only if all other guards evaluate to false. This prevents token stagnation (where a token is trapped because no guard evaluates to true).
Decision Input Flow (Advanced): An optional secondary edge marked with stereotype «decisionInputFlow» can feed data from an object node directly into the decision diamond to supply the parameter values evaluated by the guards without passing through the branch itself.
Merge Nodes: Recombining Alternative Paths
A Merge Node brings multiple alternative incoming paths back together into a single outgoing flow.
Geometry and Notation
Shape: A hollow diamond (rhombus) symbol ( ◇ ), visually identical in shape to a Decision Node.
Connectivity: Two or more incoming edges and exactly one outgoing edge .
Absence of Guards: Outgoing edges on a merge node do not require guard conditions.
The Zero-Synchronization Rule
The most critical semantic rule regarding Merge Nodes is:
A Merge Node NEVER synchronizes flows.
When a token arrives on any incoming edge, the merge node immediately forwards that token to its single outgoing edge.
It does not wait for tokens on other incoming edges.
If three separate tokens arrive across different incoming edges over time, the merge node passes each token through individually, producing three separate outgoing tokens.
Merge nodes are the required targets for loopback paths when modeling cyclic iterations in SysML activities.
Fork Nodes: Creating Concurrent Threads
A Fork Node splits a single incoming flow into multiple concurrent, parallel execution paths.
Geometry and Notation
Shape: A thick solid black line segment (horizontal or vertical bar).
Connectivity: Exactly one incoming edge and two or more outgoing edges .
No Guards Permitted: Outgoing edges from a fork node cannot have guard conditions; all paths execute unconditionally.
Token Replication Semantics
When a single token arrives at a Fork Node, the node creates a duplicate copy of the token for each outgoing edge .
Each outgoing edge immediately offers a token to its downstream target.
Downstream actions across all outgoing branches execute concurrently (in parallel or in arbitrary interleaved sequence).
Join Nodes: Synchronizing Concurrent Threads
A Join Node synchronizes multiple concurrent flows back into a single unified flow.
Geometry and Notation
Shape: A thick solid black line segment (horizontal or vertical bar), visually identical in shape to a Fork Node.
Connectivity: Two or more incoming edges and exactly one outgoing edge .
Synchronization Semantics (Logical AND)
By default, a Join Node performs a strict logical AND synchronization .
A Join Node waits until a token is present and offered on every single incoming edge .
Arriving tokens are held in wait states at the join boundary.
Only when all incoming edges hold an offered token does the Join Node fire: it consumes one token from each incoming edge, merges them, and emits a single unified token onto its outgoing edge.
Join Specification ( joinSpec )
SysML allows modelers to override the default "wait for all" behavior by attaching a constraint note labeled joinSpec . For example, joinSpec = {flowA or (flowB and flowC)} allows the join node to fire when specific subset conditions are fulfilled.
Comparison Matrix: Decision vs. Merge vs. Fork vs. Join
Control Node Visual Symbol In / Out Cardinality Execution Paradigm Token Handling Semantics Synchronization Behavior
Decision Node Hollow Diamond ( ◇ ) 1 In → N Out Conditional Choice Selects ONE outgoing edge whose [guard] is true. Does not duplicate tokens. None (routes single token).
Merge Node Hollow Diamond ( ◇ ) N In → 1 Out Recombination of Choice Passes ANY arriving token immediately to the outgoing edge. Zero synchronization. Never waits for other inputs.
Fork Node Thick Black Bar ( ❚ ) 1 In → N Out Parallel Concurrency Replicates arriving token; sends concurrent copies down ALL outgoing edges. None (creates concurrent tokens).
Join Node Thick Black Bar ( ❚ ) N In → 1 Out Synchronization of Concurrency Consumes tokens from ALL inputs; emits ONE unified outgoing token. Full synchronization. Waits until every incoming edge has a token.
- The Two Critical Architectural Traps on the Exam
- Trap 1: The "Deadlock by Join" (Mismatched Decision and Join)
Consider a modeler who routes a flow through a Decision Node with guards [temp > 100] and [temp <= 100] . Because the guards are mutually exclusive, a token will travel down Path A or Path B, but never both .
If the modeler attempts to recombine these two paths using a Join Node (thick bar) :
The token traverses Path A and arrives at the Join Node.
The Join Node holds the token and waits for a token to arrive on Path B.
Because Path B was never activated by the Decision node, no token will ever arrive on Path B.
Result: The system enters a permanent, fatal deadlock . The Join Node hangs forever and downstream actions never execute.
Correction: Conditional paths originating from a Decision node must always recombine using a Merge Node (diamond) , never a Join Node!
Trap 2: The "Unintended Multi-Execution" (Mismatched Fork and Merge)
Conversely, consider a flow split by a Fork Node (thick bar) into two concurrent paths: Record Telemetry and Calculate Trajectory . Both paths execute in parallel and produce a token.
If the modeler attempts to recombine them using a Merge Node (diamond) :
Path 1 finishes and delivers a token to the Merge Node. The Merge Node immediately emits it downstream, causing the downstream action Transmit Report to execute.
A few milliseconds later, Path 2 finishes and delivers its token to the Merge Node. Because Merge does not synchronize, it immediately emits this second token downstream as well.
Result: Downstream actions execute twice instead of once, potentially triggering redundant commands or corrupting data.
Correction: Concurrent paths originating from a Fork node must always recombine using a Join Node (bar) to synchronize back into a single token.
Exam Pitfalls & Misconceptions
Concept Correct Rule Common Exam Trap / Distractor
Merge vs. Join Behavior A Merge Node passes any token immediately without waiting; a Join Node waits for all inputs. Believing a Merge Node waits for all alternative paths to arrive before continuing.
Decision vs. Fork Behavior A Decision Node routes one token to one branch; a Fork Node duplicates tokens across all branches. Believing a Decision Node can send tokens down multiple branches simultaneously.
Guard Placement Guards belong on the outgoing edges of Decision Nodes, enclosed in square brackets. Placing guards on the incoming edges of Join nodes or on Fork outgoing edges.
Recombining Decision Branches Decision branches must recombine at a Merge Node to avoid deadlock. Placing a Join bar downstream of a Decision diamond (causing immediate deadlock).
Loop Re-entry Repetitive feedback loops must connect to an upstream Merge Node. Connecting a loopback control flow into an Initial Node or an Action perimeter without a Merge node.