Overview

  Sample Use Cases for Event-Based Generation of Entities

  Overview

  Procedure for Generating Entities at Specified Times

  Role of Attributes in SimEvents Models

  Blocks That Set Attributes

  Attribute Value Support

  Example: Setting Attributes

  Writing Functions to Manipulate Attributes

  Using Block Diagrams to Manipulate Attributes

  Counting Departures Across the Simulation

  Counting Departures per Time Instant

  Resetting a Counter Upon an Event

  Associating Each Entity with Its Index

  Overview of the Entity-Combining Operation

  Example: Waiting to Combine Entities

  Example: Copying Timers When Combining Entities

  Example: Managing Data in Composite Entities

  Sample Use Cases

  Modeling Notes

  Types of Supported Events

  Signal-Based Events

  Function Calls

  Overview of Example

  Start of Simulation

  Generation of First Entity

  Generation of Second Entity

  Completion of Service Time

  Generation of Third Entity

  Generation of Fourth Entity

  Completion of Service Time

  Techniques for Observing Events

  Example: Observing Service Completions

  Example: Detecting Collisions by Comparing Events

  Role of Explicitly Generated Events

  Generating Events When Other Events Occur

  Generating Events Using Intergeneration Times

  Reasons to Manipulate Events

  Blocks for Manipulating Events

  Creating a Union of Multiple Events

  Translating Events to Control the Processing Sequence

  Conditionalizing Events

  Using Nearby Breakpoints to Focus on a Particular Time

  For Further Information

  Procedure for Assigning Event Priorities

  Tips for Choosing Event Priority Values

  Procedure for Specifying Equal-Priority Behavior

  Overview of Example

  Arbitrary Resolution of Signal Updates

  Selecting a Port First

  Generating Entities First

  Randomly Selecting a Sequence

  Overview of the Example

  Default Behavior

  Deferring Gate Events

  Deferring Subsystem Execution to the Event Calendar

  Overview of Event-Based Signals

  Comparison with Time-Based Signals

  Generating Random Event-Based Signals

  Examples of Random Event-Based Signals

  Generating Random Time-Based Signals

  Behavior of the Event-Based Sequence Block

  Generating Sequences Based on Arbitrary Events

  Specifying Initial Values of Event-Based Signals

  Example: Resampling a Signal Based on Events

  Behavior of the Discrete Event Signal to Workspace Block

  Example: Sending Queue Length to the Workspace

  Using the To Workspace Block with Event-Based Signals

  Zero-Duration Values of Signals

  Importance of Zero-Duration Values

  Detecting Zero-Duration Values

  Overview of LIFO Queues

  Example: Waiting Time in LIFO Queue

  Behavior of the Priority Queue Block

  Example: FIFO and LIFO as Special Cases of a Priority Queue

  Example: Serving Preferred Customers First

  Definition of Preemption

  Criteria for Preemption

  Residual Service Time

  Queuing Disciplines for Preemptive Servers

  Example: Preemption by High-Priority Entities

  Blocks that Model Multiple Servers

  Example: M/M/5 Queuing System

  Server States

  Using a Gate to Implement a Failure State

  Using Stateflow Charts to Implement a Failure State

  Specifying an Initial Port Selection

  Using the Storage Option to Prevent Latency Problems

  Overview of Use of Embedded MATLAB Function Blocks

  Example: Choosing the Shortest Queue

  Example: Varying Fluid Flow Rate Based on Batching Logic

  Overview of Use of Logic Blocks

  Example: Using Servers in Shifts

  Example: Choosing the Shortest Queue Using Logic Blocks

  For Further Examples

  Overview of Gate Behavior

  Types of Gate Blocks

  Behavior of Enabled Gate Block

  Example: Controlling Joint Availability of Two Servers

  Behavior of Release Gate Block

  Example: Synchronizing Service Start Times with the Clock

  Example: Opening a Gate Upon Entity Departures

  Effect of Combining Gates

  Example: First Entity as a Special Case

  Schematic Illustrating Procedure

  Step 1: Designate the Entity Path

  Step 2: Specify the Timeout Interval

  Step 3: Specify Destinations for Timed-Out Entities

  Linear Path for Timeouts

  Branched Path for Timeouts

  Feedback Path for Timeouts

  Common Requirements for Handling Timed-Out Entities

  Techniques for Handling Timed-Out Entities

  Example: Dropped and Timed-Out Packets

  Example: Rerouting Timed-Out Entities to Expedite Handling

  Overview of Timing Issues

  Timing for the End of the Simulation

  Timing for a Statistical Computation

  Timing for Choosing a Port Using a Sequence

  Overview of Discrete Event Subsystems

  Purpose of Discrete Event Subsystems

  Processing Sequence for Events in Discrete Event Subsystems

  Setting Up Signal-Based Discrete Event Subsystems

  Signal-Based Events That Control Discrete Event Subsystems

  Example: Comparing the Lengths of Two Queues

  Example: Normalizing a Statistic to Use for Routing

  Example: Ending the Simulation Upon an Event

  Example: Sending Unrepeated Data to the MATLAB Workspace

  Example: Focusing on Events, Not Values

  Example: Detecting Changes from Empty to Nonempty

  Example: Logging Data About the First Entity on a Path

  Overview of Entity-Departure Subsystems

  Accessing Blocks for Entity-Departure Subsystems

  Setting Up Entity-Departure Subsystems

  Example: Using Entity-Based Timing for Choosing a Port

  Example: Performing a Computation on Selected Entity Paths

  Using Function-Call Subsystems in Discrete-Event Simulations

  Use Cases for Function-Call Subsystems

  Setting Up Function-Call Subsystems in SimEvents Models

  Sources of Data for Plotting

  Inserting and Connecting Scope Blocks

  Connections Among Points in Plots

  Varying Axis Limits Automatically

  Caching Data in Scopes

  Examples Using Scope Blocks

  Customizing Plots

  Exporting Plots

  Overview of Example

  Model Exhibiting Correct Timing

  Model Exhibiting Latency

  Overview

  Statistics for Data Analysis

  Statistics for Run-Time Control

  Statistics-Related Parameters in Block Dialog Boxes

  Accessing Statistics Throughout the Simulation

  Accessing Statistics When Stopping or Pausing Simulation

  Overview of Approaches to Custom Statistics

  Graphical Block-Diagram Approach

  Coded Approach

  Post-Simulation Analysis

  Example: Fraction of Dropped Messages

  Example: Computing a Time Average of a Signal

  Example: Resetting an Average Periodically

  Overview of Timers

  Basic Example Using Timer Blocks

  Basic Procedure for Using Timer Blocks

  Timing Multiple Entity Paths with One Timer

  Restarting a Timer from Zero

  Timing Multiple Processes Independently

  Connection Between Random Numbers and Seeds

  Making Results Repeatable by Storing Sets of Seeds

  Setting Seed Values Programmatically

  Sharing Seeds Among Models

  Working with Seeds Not in SimEvents Blocks

  Choosing Seed Values

  Overview

  Setting a Fixed Stop Time

  Stopping Upon Processing a Fixed Number of Entities

  Stopping Upon Reaching a Particular State

  Failure State of Server

  Go-Back-N ARQ Model

  Debugger Command Prompt

  Simulation Log in the Debugger

  Identifiers in the Debugger

  Significance of Independent Operations

  Independent Operations

  Consequences of Independent Operations

  How to End the Debugger Session

  Comparison of Simulation Control Functions

  Overview of Stepping

  How to Step

  Choosing the Granularity of a Step

  Tips for Stepping Through the Simulation

  Viewing the Current Operation

  Obtaining Information Associated with the Current Operation

  Inspecting Entities

  Inspecting Blocks

  Inspecting Events

  Obtaining Identifiers of Entities, Blocks, and Events

  Comparison of Variables with Inspection Displays

  Functions That Return Debugging Information in Variables

  How to Create Variables Using State Inspection Functions

  Tips for Manipulating Structures and Cell Arrays

  Example: Finding the Number of Entities in Busy Servers

  For Further Information

  Customizable Information in the Simulation Log

  Tips for Choosing Appropriate Detail Settings

  Effect of Detail Settings on Stepping

  How to View Current Detail Settings

  How to Change Detail Settings

  How to Save and Restore Detail Settings

  Executing Commands Automatically When the Debugger Starts

  Creating Shortcuts for Debugger Commands

  What Is a Breakpoint?

  Identifying a Point of Interest

  Setting a Breakpoint

  Viewing All Breakpoints

  Running the Simulation Until the Next Breakpoint

  Ignoring or Removing Breakpoints

  Unexpectedly Simultaneous Events

  Unexpectedly Nonsimultaneous Events

  Unexpected Processing Sequence for Simultaneous Events

  Time-Based Block Not Recognizing Certain Trigger Edges

  Incorrect Timing of Signals

  Unexpected Use of Old Value of Signal

  Effect of Initial Condition on Signal Loops

  Loops in Entity Paths Without Sufficient Storage Capacity

  Unexpected Timing of Random Signal

  Unexpected Correlation of Random Processes

  Objective

  Prerequisites

  Procedure

  See Also

  Objective

  Model Designer and Model User Roles

  Procedure for Model Designer

  Procedure for Model User

  Comparison of Approaches

  Adapting Existing Models and MATLAB Code to Work with Rapid Simulation

  Objective

  Procedure

  See Also

  Objective

  Prerequisites

  Procedure

  For Further Information

  Event-Based Data for Rapid Simulations

  Varying the Stream of Random Numbers

  Varying Intergeneration Times

  Varying Attribute Values

  Varying Service Times

  Varying Timeout Intervals

  Varying Event-Based Signals

  Example Scenario

  Prerequisites

  Steps in the Example

  Results

  Example Scenario

  Prerequisites

  Steps in the Example

  Results

  Example Scenario

  Prerequisites

  Steps in the Example

  Results

  Processing Sequence for Simultaneous Events

  Role of the Event Calendar

  For Further Information

  Detection of Signal Updates

  Effect of Simultaneous Operations

  Resolving the Set of Operations

  Specifying Event Priorities to Resolve Simultaneous Signal Updates

  Resolving Simultaneous Signal Updates Without Specifying Event Priorities

  For Further Information

  Overview

  Permitting Large Finite Numbers of Simultaneous Events

  Overview of Notifications and Queries

  Querying Whether a Subsequent Block Can Accept an Entity

  Notifying Blocks About Status Changes

  Overview of Signal Input Ports of SimEvents Blocks

  Notifying Ports

  Monitoring Ports

  Reactive Ports

  Overview of Interleaving of Block Operations

  How Interleaving of Block Operations Occurs

  Example: Sequence of Departures and Statistical Updates

  Techniques for Working with Multivalued Signals

  Example: Using a #n Signal as a Trigger

  Determining the Update Sequence

  Example: Detecting Changes in the Last-Updated Signal

  Storage Blocks

  Nonstorage Blocks

  SimEvents Pane Overview

  Execution order

  Seed for event randomization

  Maximum events per block

  Maximum events per model

  Diagnostics Pane Overview

  Attribute output delayed relative to entities

  Response to function call delayed relative to entities

  Statistical output delayed relative to entities

  Modification of attribute values used for decision making

  Identical seeds for random number generators