opnet

Introduction to Using OPNET Modeler®

Network R&D

Session 1572

CONFIDENTIAL ─ RESTRICTED ACCESS: This information may not be disclosed, copied, or transmitted in any format without the prior written consent of OPNET Technologies, Inc.

© 2008 OPNET Technologies, Inc.

CONFIDENTIAL ─ RESTRICTED ACCESS: This information may not be disclosed, copied, or transmitted in any format without the prior written consent of OPNET Technologies, Inc. © 2008 OPNET Technologies, Inc. 2

1572 Introduction to OPNET Modeler®

Session Goals

Learn the basics of using Modeler through a combination of lectures and labsLearn and practice Modeler methodologies and use cases Learn how to create new• Processes• Nodes• Packets• Links• Networks• …

Analyze results from a Discrete Event Simulation



Class Format

Lots of material to cover, so class will move quicklyHalf lecture; half labConference proceedings will be available on websiteClass is interactive; don’t hesitate to ask questions

Prerequisites• Ability to understand C or C++• Basic understanding of networks



Course Outline

IntroductionOverviewEvents and event list conceptsPacketsNetwork modeling Node modelingLink modeling

Running a simulationProcess modelingAnalyzing and publishing resultsAdditional features and modulesConclusion



What is NOT Covered

This session will NOT cover• Using the Standard Model Library, such as

How to configure standard protocols (ATM, Ethernet, Wireless LAN, etc.)How to perform studies such as QoS, capacity planning, traffic engineering

• Interfacing custom models with the Standard Model Library • Importing topology and traffic• Debugging process models • Process Modeling Methodology • Dynamic processes • Creating custom pipeline models• Third-party integrations• Wireless studies• System-In-The-Loop (SITL)

Above topics covered in other OPNETWORK sessions



OPNET Network R&D Solutions

OPNET Modeler is the de-facto standard for: • Network R&D • Modeling and simulation • Defense organizations• Network equipment manufacturers

Accelerate network R&D and planning: • Design wired and wireless protocols and

technologies• Test and demonstrate designs in realistic

scenarios before production• Plan mobile network deployments that accurately

incorporate terrain effects• Design wireless network protocols to optimally

support the warfighter• Assess battlefield plans in light of

communications effects



Solution Portfolio



Introduction: Agenda

Methodology and WorkflowOPNET Hierarchy• Network• Node• Process

Navigating the Project Editor• Subnets• Zooming

Simulation OutputLab: Exploring a Finished Project



Simulation Methodology

Yes

End

Start

Results statistically

useful?

No

NoResults

sufficiently detailed?

Choosing input andrunning simulations

System results accurate?

Defining input and output

Specifying the system model

No

Choosing aspectsto be modeled

Understanding your goals for the

simulation

Understanding the system



The Project/Scenario Workflow

Create projectCreate baseline scenario• Import or create topology• Import or create traffic• Choose results and reports to be collected• Run simulation• View results

Duplicate scenario• Make changes• Re-run simulation• Compare results

Iterate



The Three-Tiered OPNET Hierarchy

Three domains: Network, node, and processNode model specifies object in network domainProcess model specifies object in node domain

Process model rip_udp_v3



Network Domain: Network Objects

Network models consist of nodes, links and subnetsNodes represent network devices and groups of devices• Servers, workstations, routers, etc.• LAN nodes, IP clouds, etc.

Links represent point-to-point and bus linksIcons assist the user in quickly locating the correct nodes and linksVendor models are distinguished by a specific color and logo for each company

Generic Devices Vendor Devices



Subnet Types

Subnets

Organize network componentsRepresent actual network physical constructsHas no behavioral aspectsLogical, Stationary, mobile, or satellite



Open by selecting Topology / Open Annotation PaletteAdd rectangles, circles, lines and text to models to enhance their appearanceThis method is an effective way to graphically illustrate and document the changes made to a modelDoes not affect analysisAnnotations can be temporarily hidden

Annotation Palette



Zoom to Rectangle button on the Project Editor toolbar allows the user to define a rectangular area to magnify Zoom to Previous button returns the workspace to the previous magnification levelMouse Scroll Wheel or Page-Up and Page-Down keys for small incrementsRight-click on the workspace to open the workspace pop-up menu• Zoom in• Zoom to all• Zoom out• Zoom to selection• Zoom to window

Zooming



Node Domain

Basic building blocks (modules) include processors, queues, and transceivers• Processors are fully programmable via their process model• Queues also buffer and manage data packets• Transceivers are node interfaces

Interfaces between modules• Packet streams• Statistic wires

Receiver Transmitters

Processor

Queues

Stat WirePacket Stream



Process Domain

Process model components• State transition diagrams• Blocks of C code• OPNET Kernel Procedures (KPs) • State variables• Temporary variables

A process is an instance of a process modelProcesses can dynamically create child processesProcesses can respond to interrupts



Simulation Output

Three kinds of output• Vectors

List of time-value pairs• Scalars

List of values dependent on parametric inputNot plotted vs. time

• AnimationsPacket flowsNode movementsOutput to 3DNV

Objects have pre-defined statistics



Lab: Workspace

Go to lab bookPractice navigating the project editor• Navigate the project “project_environment_ref”• Load a map• Explore the network• Navigate subnets• Practice zooming features• Examine attributes of devices



Event List Concepts: Agenda

Event-Driven SimulationEvent List and the Simulation Time ClockSimulation KernelInterrupts Processes and InterruptsEvent List Example



Event-Driven Simulation

Events are specific activities that occur at a certain timeOPNET simulations are event-drivenSimulation time advances when an event occursA different method might be to sample at regular intervals• Disadvantages

Accuracy of results is limited by the sampling resolutionSimulation is inefficient if nothing happens for long periods



Time Event Type Module0.0 Initialize src.gen0.0 Initialize src.rte4.3 Timer expires src.gen4.3 Packet arrives src.rte

Head

Event List Concepts

Single global event listShared simulation time clockEvents scheduled in time orderEvent removed from event list when it completes



The Simulation Kernel

Manages the event listDelivers each event, in sequence, to the appropriate moduleReceives requests from processes and inserts new events in the event list



Event Generation and Cancellation

Events can be generated in several ways• BEGSIM/ENDSIM interrupts• Self interrupts• Packet arrivals (STRM interrupts)• Writing to a statwire (STAT interrupts)

Events can be cancelled before they occur



Interrupts

First event in the event list becomes an interruptSimulation Kernel delivers the interrupt to the designated moduleData associated with the interrupt can be obtained by the moduleProcessors and queues can have BEGSIM interrupts



How Does the Event List Work?

New event reaches head of event list, which causes

Simulation Kernel to deliver an interrupt to the

appropriate module

Simulation Kernel regains control from module

Process within the module gains control and

processes interrupt

Simulation Kernel deletes event from event list, allowing new event to reach

head of list



Event List Implementation

The Simulation Kernel uses an efficient proprietary algorithm tomaintain the event listEvent times are expressed as double-precision, floating-point numbers and are used to keep the event list sorted

0.01234 56789 11111 11

0.01234 56789 11111 22

0.01234 56789 11111 33

0.01234 56789 11111 44

0.01234 56789 11111 55

0.01234 56789 11111 66

0.01234 56789 11111 77

Suppose that this interrupt triggers an event to occur at 0.01234 56789 11111 75.

The Simulation Kernel minimizes the time required to place this event at the correct place on the list.



Delivery of Interrupts

When an interrupt is delivered to a module, control passes from the Simulation Kernel to the module

If the module is a queue or processor, the interrupt is delivered to the process running within the module

Other modules, such as transmitters and receivers, are covered later



Event List Concepts Reviewed

Events must exist in the event list at the start of a simulation• A processor or queue module has the begsim interrupt attribute enabled

Each event may schedule other eventsThe event list is always growing and shrinkingAn event is pending until executedA pending event can be cancelled



Forced States

Forced (green) and unforced (red) states differ significantly in execution timingIn a forced state, the process• Invokes the enter executives• Invokes the exit executives• Evaluates all condition statements• If exactly one condition statement

evaluates to true, the transition is traversed to the next state

OPNET convention: Code in enter execs only

Transition to next state


Forced (green) states

Enter execs invoked

No blocking or waiting

Exit execs invoked

Enter execs invoked

Exit execs invoked

No blocking or waiting



Unforced States

In an unforced state, the process• Invokes the enter executives• Places a marker at the middle of the

state• Releases control to the Simulation

Kernel and becomes idle• Resumes at the marker and

processes the exit execs when next invoked

Start of invocation

End of invocation

Unforced (red) states


Blocking, waitingfor invocation

Exit execs processed when invocation

occurs

Enter execs invoked

Next invocationstarts here

Blocking, wait for next invocation



Transitions Between States

After completing the exit executives, the process evaluates the conditions for all transitions from the stateOne and only one condition statement must evaluate to trueThe single true transition is taken to the next stateA transition with condition = “default” is true if and only if no other conditions are trueA transition with no condition set is termed unconditional and is always true



How a Process Handles an Interrupt

Flow diagram showing how a process handles an interrupt

Implement exit execs

Set marker; block and wait

for interrupt

Receive interrupt

Evaluate condition statements

Red state? YesFollow

transition to next state

Implement enter execs

Find marker

No



Process Model Example

Model with three forced states and one unforced state:

3. Transition occurs. 6. Transition occurs.

2. Exit execs invoked immediately. Transition condition (pk_count == 0)evaluates to true. 5. Exit execs invoked immediately.

8. Marker is placed and process stops here.

7. Enter execs invoked.4. Enter execs invoked.1. Initial interrupt delivered and the enter execs invoked.



The Simulation Kernel and Processes

Control passes between the Simulation Kernel (SK) and multiple processes (pr1, pr2, etc.), as described below:

All processesSKRemove first event from event list. Advance next event to head of list. Deliver interrupt to pr2.

SKOther processes

pr2Evaluate condition statements and transition to next state

SKAll other processes

pr1pr1 invoked at initial state. Continues executing states until a red (unforced) state is entered.Release control to SK and becomes idle

All processesSKRead first event on event list. Deliver to appropriate process (pr1)

IdleIn controlDescription



Event List Example

Consider this model:

Network model

Node model

Node model

Node model: src

Node model: dest1

Network model



Event List Example (cont.)

The network model has three nodes (src, dest1, dest2) relying on two node models (both dest nodes use the same node model)In the src node model, packets are generated at gen and sent by queue to either transmitter (tx0 / tx1)Packets then flow across a link to a destination node (dest1, dest2) where they are received (rx) and thrown out (sink)Three modules (gen, queue, and sink) have process models associated with them



The BEGSIM Interrupt

Occurs at simulation time 0.0 before any other type of interrupt

Usually initializes a module and schedules future events

Any processor or queue can have its begsim intrpt attribute enabled, resulting in an event being placed on the event list for time 0.0



Event List Example (cont.)

The begsim intrpt attribute for modules src.gen and src.queue is enabled; this places two events in the event list

Time Event Type Module0.0 BEGSIM src.gen0.0 BEGSIM src.queue

Node model



Processing the First Interrupt

Consider the process model specified by the src.gen module

Node model: src

Process model: gen



Starting the Simulation

Simulation Kernel reads the event at the head of the event list, and delivers control to the process in the src.gen moduleProcess begins execution at the initial state, marked with the black arrowProcess executes the Init state’s enter execs

Time Event Type Module0.0 BEGSIM src.gen0.0 BEGSIM src.queue



Processing the First Interrupt in Processgen (cont.)

Process model

Process model: gen



Processing the First Interrupt in Process gen (cont.)

Because Init is a forced (green) state, process immediately invokes and completes the exit execs

Process evaluates all condition statements. This state has only one departing transition which evaluates to true

Process transitions to Wait state



Process model

Processing the First Interrupt in Process gen (cont.)

Process invokes and completes the enter execs of Wait



Line 8 of the enter execs schedules a self interrupt using a KP. This adds an event to the event listSince that was the last line of the enter executives, process places a marker at the middle of WaitProcess becomes idle

Time Event Type Module0.0 BEGSIM src.gen0.0 BEGSIM src.queue4.3 SELF src.gen

Marker

Processing the First Interrupt in Processgen (cont.)



Processing the Second Interrupt at Modulesrc.queue

Simulation Kernel removes the first event and advances the next event to the head of the event list. The simulation time remains 0.0.Simulation Kernel delivers a BEGSIM interrupt to src.queue.Process in src.queue module gains control. It executes until it reaches an unforced (red) state, places a marker, and then becomes idle. (This model is not shown.)

Time Event Type Module0.0 BEGSIM src.queue4.3 SELF src.gen

First event is removed



Processing the Next Interrupt at Modulesrc.gen

Simulation Kernel removes the previous event and advances the next event to the head of the event list. The simulation time becomes 4.3 seconds.Simulation Kernel delivers the SELF interrupt to the genprocess. The process resumes at the marker in the middle of Wait.Process invokes and completes the exit execs of Wait.

Time Event Type Module4.3 SELF src.gen



Continuing the Process at gen

Process evaluates all condition statements when leaving Wait. This state has one outgoing conditional transition that evaluates to true.



Continuing the Process at gen (cont.)

Process transitions to Send.Process invokes the enter execs of Send and calls op_pk_send( ) to send a packet. This results in an event of type STRM being placed on the event list.

Time Event Type Module4.3 SELF src.gen4.3 STRM src.queue



Continuing the Process at gen (cont.)

Process immediately invokes and completes the exit execs, because Send is a forced (green) stateProcess evaluates all possible transitions. One evaluates to trueProcess transitions to WaitProcess invokes enter execs of Wait, schedules another SELF interrupt in the event list and becomes idleSimulation Kernel takes control and processes the next event in the list



Simulation Termination

Simulations terminate in one of four ways:• The event list is emptied• Simulation attribute duration expires• A process calls for termination, using the KP op_sim_end()• A fatal error occurs



How Does Time Advance?

Simulation time advances only when an event with a later time isprocessed from the event listNo simulation time occurs during the execution of a processNo time elapses during transitions between states A process model must always have an unforced (red) state so time can advance• Avoid endless looping between forced (green) states



Events and Event List Concepts: Summary

Forced and unforced states execute differentlyAny processor or queue can have the attribute begsim intrpt enabled, scheduling an event for time 0.0Control passes dynamically between the Simulation Kernel and individual processes



Packets: Agenda

Packets in ModelerPacket FormatsLab: Create a Packet FormatPacket Events



Packets

Information-carrying entities that circulate among system componentsGeneral data structures, organized into fields of user-defined informationDynamically created and destroyed as the simulation progressesA single system may rely on multiple types of packets with different formats



Packet Formats

Packets can either be unformatted or formattedUnformatted packets have no user-defined data fieldsFormatted packets have zero or more fieldsField types• Integer• Floating point• Structure• Packet• Information



Lab: Create a Formatted Packet

Create a packet with two fields• Destination Node• Source Node



Events for Packet Transmission

All packet transmissions are modeled with four events• Start of Transmission• End of Transmission• Start of Reception• End of Reception

Simulation Kernel automatically schedules these events



Packets: Summary

The basic elements for data exchange• Between modules in nodes• Between nodes in a network

Can be formatted with user-defined fieldsDynamic simulation objects



Building Models: Agenda

Creating Network Models• Drag-and-drop• Rapid configuration• Startup Wizard

Map BackgroundsAnnotationsDeriving and Creating New ModelsObject AttributesOnline Documentation



Creating Network Models

There are two ways to create new network models• Import

OPNET Products (e.g. ACE, VNE Server)Network management data (e.g., Network Node Manager)Files (e.g. router configuration files, XML)

• Manual CreationDrag-and-dropRapid configuration

Note: Topology Import Sessions • 1617: Importing IP and Layer-2 Networks with XDI • 1623: Using VNE Server® — Introduction



Rapid Configuration

Rapid configuration allows you to quickly create networks of any sizeAvailable topology configurations:• Bus• Ring• Star• Tree• Mesh• Unconnected

Specify the number of nodes, the node and link models used, how nodes will be arranged, and node locations within the workspace



Startup Wizard

The Startup Wizard can quickly configure a new scenario

There are several settings for each scenario:• Name

• Initial topology

• Network scale

• Network size

• Technologies



• View/hide maps by choosing View / Background / Set Properties• Geotiff, MapInfo, MrSID, and CADRG images automatically appear at the

correct latitude and longitude position.

Background Maps



Deriving New Models

Derive a new model based on any existing model

Can alter the attributes of the newly derived model



Device Creator

Automatically create a particular device with a specific configurationLaunched from TopologymenuSelect any number of interfaces and protocols



Object Attributes

Control aspects of object’s behaviorAre values that may vary• From one model to the next• Between objects of the same

model typeRight-click on an object and select “Edit Attributes” to view or changeCan be promoted to• Set the value at a higher layer• Specify a range of values at

runtime



Where to Get Help

Online Documentation from the Help menuModel help accessible by right-clicking object icons in the object palette or by right-clicking objects in the Project workspace and selecting “View Node Description”Tool Tips• Hold mouse over any object to get a brief description of that object

Attribute help accessible by clicking on the question mark next to the attribute



Node Modeling: Agenda

Node ModulesModule ConnectionsInterfacesNode StatisticsLab: Creating Node Models



Node Objects: Modules

Modules are the basic building blocks of node models• Processors• Queues• Transceivers

TransmittersReceivers

• Antennas



Node Objects: Processors and Queues

Processors• General-purpose building blocks of node models• Fully programmable

Queues• Offer all the functionality of processors• Can also buffer and manage a collection of data packets

Processor

Queue



Node Objects: Transceivers

Transceivers are the interfaces between objects inside a node and communication links outside it• Transmitters are the outbound interfaces• Receivers are the inbound interface

Some transceiver attributes:• Number of channels• Data rate• Supported packet formats

Bus transceiversPoint-to-point transceivers Radio transceivers

Transmitter Receiver Transmitter Receiver Transmitter Receiver

These require the “Wireless” add-on

module



Node Objects: Antennas

Antennas may be used with radio transceivers to specify antenna properties

Note: Wireless modeling is covered in other sessions• 1942 Introduction to Using 3D Network Visualizer (3DNV)• 1943 Creating Custom 3D Network Visualizations using

Modeler• 1332 Planning and Analyzing Wireless LANs• 1530 Modeling Custom Wireless Effects• 1529 Understanding WLAN Model Internals, Interfaces, and

Performance• 1941 Understanding MANET Model Internals, Interfaces, and

Performance• 1527 Accelerating Wireless Simulations Using Scalability

Techniques

Antenna



Module Connections

Packet streams carry data packets from a source to a destination module

Statistic wires carry a single data value from a source to a destination module

Logical associations tie individual transmitters and receivers together to make a transceiver pair



Node Model: Example

Node models can support:• Layering of protocol functions• Dynamic inter-module monitoring• Arbitrary node architectures

ethernet_wkstn_adv Node Model



Specifying Node Interfaces

Specify various characteristics of the node• Rename attributes• Set attribute values• Hide attributes• Specify node types• Add comments



Specifying Available Node Statistics

Specify statistics to be available from project editor

Selecting an empty field in the “Orig. Name” column opens a table of available statistics

Selecting a statistic from the “Available Statistics” table adds the statistic to the “Statistic Promotion” table



Lab: Node Modeling

The Worst National Bank wants to model the flow of bank transactions (represented as packets) from Washington, D.C. to Philadelphia• Bank transactions originate in Washington, D.C., and are routed to

Philadelphia via a modem at 9,600 bits/second.• The size of a transaction varies according to a normal distribution with a mean

size of 3,200 bits and a variance of 400 bits.• Transactions are modeled as exponential interarrivals, with a mean interarrival

time of 0.5 sec/trans.Analyze the system in steady state• Does the queue size of the WDC transmitter steadily increase?• What is the throughput (in bits/second) at the WDC transmitter?• What is the throughput (in bits/second) at the Philadelphia receiver?• What is the utilization of the DC-to-Philadelphia link?



Node Modeling: Summary

Modules include processors, queues, transceivers, and antennasModules are connected with packet streams and stat wiresNode “interfaces” include• Icon to be used• Mobility types (Fixed, mobile or satellite)• Statistics to be promoted

Lab accomplishmentsBuilt generator to send out packets (using simple_source model)Built receiver to accept and destroy packets (using sink model)



Link Modeling: Agenda

Link TypesLink EditorLab: Create a Link Model



Link Types

Link objects model physical layer effects between nodes, such asdelays, noise, etc.

A radio link, established during a simulation, can be created between any radio transmitter-receiver channel pair. Satellite and mobile nodes must use radio links. Fixed nodes may use radio links. A radio link is not drawn but is established if nodes contain radio transceivers.

A bus link transfers data among many nodes and is a shared media.

A point-to-point link transfers data between two fixed nodes.

Radio link



Link Editor

Create or modify linksChoose link typesModify attributes



Verify Links

Ensures that point-to-point and bus link connections are valid• Enough transmitters and receivers to support all of the incoming and outgoing

links • Data rates of the connected transmitter and receiver match the data rate of the

link• Transceivers support the attached link technology

It is always a good idea to use the “Verify Links” feature (Ctrl+L) before running a simulation to ensure connectivity



Lab: Creating a Link Model

Create a custom link• Point-to-point• Simplex or Duplex• Data rate of 9600 bps



Link Modeling: Summary

Link Types• Point-to-point• Bus• Radio

Created new linkVerify Links



Statistics: Agenda

Statistic CollectionConfiguring SimulationsViewing ResultsLab: Complete Bank Model and Analyze Results



Statistic Collection

Statistic Attributes

Descriptions of Statistics

Statistic Collection Modes



Statistic Attributes

Right-clicking on a statistic while in the Choose Results dialog box presents a menu of statistic attributes

Statistic attributes include:• Record Statistic Animation• Generate Live Statistic• Change Collection Mode• Change Draw Style



Statistic Collection Modes

Normal mode: Every data point is collected from a statisticSample mode: The data is collected according to a user-defined time interval or sample countBucket mode: All the data points in a bucket are collected and processed according to a user-defined parameter

MaxMinSumCountSample meanTime average



Understanding Statistics

Define the goals of the study, and as a result, understand the statistics that should be collected to get useful results

Browse available statistics and view their descriptions

Understand the default collection mode to help interpret results



Configuring Simulations

Scenarios automatically provide a default duration and random number seed for simulationsUsers can set simulation attributes by choosing “Configure Simulation” from the Simulation menu, or by clicking on the “running man” icon:



Running a Simulation

The Simulation Sequence window shows the progress of simulationElapsed time bar displays the progress of the simulation• Appears after 1,000,000 events by

defaultElapsed/Remaining Time: Real time elapsed and remaining timeSimulation Time: Simulation time elapsed and number of events processed



Viewing Results

Results can be displayed by:• Selecting the “View Results” button

on the tool bar • Selecting View Results from the

Results menu• Right-clicking the project workspace

and selecting from the pop-up menu

View Results dialog box allows the user to select the results to display.

- Note: Only the statistics you chose for collection will be available

The “Show” button in the “View Results” dialog box displays a graph of the selected statistics



Viewing Results (cont.)

Multiple graph panels can be displayed at the same timeEach panel can contain one or more traces in an Overlaid or Stackedlayout



Lab: Creating a Network

Create a new projectPlace topologyChoose StatisticsRun SimulationAnalyze Results



Checking Our Predictions

Compare actual results to expected output

Explain any differences

Modify your model as necessary



Modeling Traffic

Three traffic types• Explicit/Discrete (modeled packet-by-packet)• Flows (modeled analytically using source-to-destination pairs)• Loads (modeled analytically using a “background” load on a link)

All three types can be combined to create a Hybrid Simulation



Application Characterization Environment (ACE)

Module allows users to model their own custom networked applicationsImport real-world dataVisualize performanceDiagnose performance problemsSimulate in OPNET environment to explore solutions



Running a Simulation: Summary

Understand Available StatisticsChoose Statistics to Collect During SimulationConfigure Simulation OptionsRun SimulationView Results



Multiple Simulation Runs: Agenda

Benefits of Multiple Simulations RunsRandom Seeds vs. ExpectationConfidence IntervalsLab: Using Multiple Random Seeds



Benefits of Multiple Simulations Runs

Model Accuracy• Stochastic simulation results in richer data which takes into account varying

parameters

Save Man Hours• Multiple simulations can be run concurrently which gets results in a shorter

amount of time

Leverage Available Resources• Available processing resources can be utilized to run multiple simulations



Importance of Multiple Simulations Runs

Many simulations rely on stochastic modeling of certain elementsUsually characterized by associating probabilities with a set ofoutcomes• Traffic loads• Deference processes• Generation and placement of bit errors

Each time the simulation is run• The network topology and configuration remain the same• Outcome of random variables differ• Statistic results are unique for different outcomes



Random Seeds vs. Expectation

Stochastically modeled elements depend on a random number sourceon which to base their behavior.By "drawing" from the source, these elements can incorporate

variability into appropriate actions or decisions as they are taken. Changing the random seed changes the outcomes that are drawn from this source of random numbers.



Confidence Intervals

Used to indicate the reliability of an estimate, based on a trial or series of random trialsDetermines whether the values collected can be used with confidence to make statements about the typical behavior of the modeled system Example: With probability 0.95 one will find the parameter x between a pair of stochastic endpoints



Multiple Simulations in OPNET

Sequentially • Single runtime license

Parallel • In parallel on the same machine requiring a single runtime license• Models must be properly codified for parallel simulation

Distributed• Multiple simulations automatically distributed to other machines using

multiple runtime licenses or a site license



Lab: Using Multiple Random Seeds

At this point, the simulation has been run a single time We will now run a series of simulations using a different random seed for each run



Lab Summary

10 Simulation runsPreviously link utilization plotted w.r.t. timeMean of link utilization plotted w.r.t. random seed



Process Modeling: Agenda

Process ModelsProcess Editor• State Transitions• Executive Blocks

Kernel ProceduresExamine acb_fifoLab: Modify a Process Model



Process Models

Process models represent algorithms• Communications protocols and algorithms• Shared-resource managers• Queuing disciplines• Specialized traffic generators• Statistic-collection mechanisms• Control Processes

Process Editor provides the features for creating process models



1. Create state2. Create transition3. Set initial state 4. Edit state variable5. Edit temporary variable6. Edit header block7. Edit function block8. Edit diagnostic block9. Edit termination block10. Compile process model

1 2 3 4 5 6 7 8 9 10

Process Editor

Toolbar Buttons:



State Transitions

Transitions connect states• Conditional• Unconditional

Exactly one condition must evaluate to trueIf the condition statement (x == y) is true, the transition executive (Reset_Timers) is invoked

Transition executiveCondition statement



State Executive Blocks

Each state has two executive blocks• Enter executives are invoked upon entering a state• Exit executives are invoked before exiting a state



Introduction to Kernel Procedures

Pre-written functions for difficult, tedious, or common operations

KPs free users from addressing memory management, data structure, handling event processing, etc.

KPs focus on communication modeling

All KPs begin with prefix op_



Common Kernel Procedures

Packet Package:op_pk_create ()op_pk_create_fmt ()op_pk_copy ()op_pk_get ()op_pk_total_size_get ()op_pk_nfd_set ()op_pk_nfd_get ()op_pk_send ()op_pk_send_delayed ()op_pk_destroy ()

Subq Package:op_subq_pk_insert ()op_subq_pk_remove ()

Interrupt Package:op_intrpt_schedule_self ()op_intrpt_type ()op_intrpt_strm ()op_intrpt_code ()

Simulation and Event Packages:op_ev_cancel ()op_sim_time ()

ID, Topo and Internal Model Access Packages:op_id_self ()op_topo_parent ()op_topo_child ()op_ima_obj_attr_get ()

Distribution Package:op_dist_load ()op_dist_outcome ()

Naming convention for Kernel Procedures -op_<family name describing object >_<action>



Kernel Procedures Help

From the Help menu, select Online Documentation, and refer to the Simulation Kernel manual• Divided into sections by KP family

AnimationPacketsStatisticsEvents

• Each KP described in several paragraphs, includingPurposeSyntaxExample

When in the Process Editor:• Press <Control> + <h> to view Essential Kernel Procedures• Press <Control> + <Shift> + <h> to view All Kernel Procedures



Proto-C™

State transition diagramsC programming languageLibrary of OPNET Kernel Procedures (KPs)State variables (private to each process)Temporary variables



Example Process Model: acb_fifo

Queue process modelCharacteristics• Has a service rate, in bits/sec• FIFO queue

Active Concentrating Bit-oriented First In First Out queue• Active: Has a processor• Concentrating: Will take from many input streams and output to only one

stream• Bit-oriented: Delay is based on number of bits processed



acb_fifo: State Overview

Purpose of each state•init initializes state variables•arrival queues packets•svc_start calculates when the packet can be sent•svc_compl sends the packet•idle is the wait state



acb_fifo: idle State

Packet arrival• Packet is queued in arrival• To svc_start if not busy• Back to idle if busy

Service completion• Sends queued packet in svc_compl

To svc_start if queue nonemptyBack to idle if queue empty



acb_fifo: arrival State

Gets the incoming packetTries to queue packetDestroys packet ifqueue is full



acb_fifo: svc_start State

Begins servicing the packetSchedules an interrupt for service completion



acb_fifo: svc_compl State

Sends the serviced packetReceiving module will get control immediately



Lab: Expand the Network

The bank’s network has expanded to four source nodes, 12 switch nodes, and three destination nodesNew switch model needed with four inputs and two outputsThis switch takes an input from any input port and sends it to a random output port



Process Modeling: Summary

Process models• Finite state machines• Proto-C• acb_fifo

Kernel Procedures



Lab Description

Uses the project bank_net, to model changes in the transaction rate and measure the effects of those changesCreate modified sink process model to compute ETE delay• Get the packet• Obtain the creation time• Write out its ETE delay as a global statistic• Destroy the packet

Incorporate new sink process model into existing node modelCreate ETE delay statistic probeRun simulationFilter the “View Results” graphs to answer questions



Lab Description

Provide answers to the bank’s CIO• What is the average end-to-end delay

(ETE delay) for all transactions when the generation rate is 0.4 seconds/transaction (or 2.5 transactions/second)?

• For this generation rate, what percentage of the packets incurred an ETE delay of less than 1 second?



Analyzing and Publishing : Agenda

Collecting StatisticsConfiguring SimulationsExporting Statistic DataWeb Reports



Probe Editor

In previous chapters, statistics were selected and results collected in the Project Editor

The Probe Editor enables you to configure where information is collected and what statistics are measured

You can save collections of probes to a file for use in different scenarios



Toolbar

Probe Workspace

1. Global Statistic Probe2. Node Statistic Probe3. Link Statistic Probe4. Path Statistic Probe5. Demand Statistic Probe6. Coupled Statistic Probe7. Attribute Probe8. Automatic Animation Probe9. Statistic Animation Probe10. Custom Animation Probe11. Live Statistic Probe

1 2 3 4 5 6 7 8 9 10 11

Probe Editor



Exporting Data

Export collected statistics to a text file or spreadsheet

Spreadsheet application can be specified

If no spreadsheet application is specified the data is written to an ASCII file



Exporting Data – Spreadsheets

Right-click inside graph on desired panelSelect “Export Graph Data to Spreadsheet”Modeler launches the appropriate program with data

1

3

2



Generating Web Reports

Web Reports contain data and statistic graphicsCan be created after a simulation has runCreated in op_admin folder



Why Use Web Reports?

Allows results to be shared with non OPNET-usersAutomatically generated and present data in a manner that is easy to use, navigate, and interpretInclude a simple text summary consisting of information about SLA violations, and top-most utilized links, nodes, etc.



How to Generate Web Reports

After running a simulation, select “Generate Web Report” from the Results menu



Web Topology Export

Export network topology and configuration to HTMLUnder the Scenario menu, select “Generate Scenario Web Report”



Analyzing and Publishing: Summary

Probe EditorExporting dataTopology and data export to HTML



Wrap-Up Section: Agenda

Model LibraryTraffic TypesApplication Characterization Environment (ACE)Wireless ModuleTerrain Modeling Module



Model Library

Extensive library of standards-based and vendor models

OPNET’s Model Research and Development division designs, develops, and maintains the model library

Models are created using published standards and widely-used vendor implementations• IEEE Specifications (e.g., 802.1q, 802.3, 802.11, etc.)• ANSI Standards (e.g., X3.139, T1.513, etc.)• ATM Forum Specifications (e.g, UNI 3.1, TM 4.0, etc.)• RFC Documents (e.g., RFC-793, RFC-1058, RFC-1771, etc.)• Vendor Technologies (e.g., VLAN tagging, EIGRP, etc.)



Model Library Components

Traffic sources and sinks (workstations, servers, stations, etc.)Network devices (hubs, bridges, switches, routers, etc.)Links (SONET, PPP, FDDI, 10BaseT, ISDN, xDSL, etc.)Vendor device models (Cisco Systems, 3Com, Juniper, Lucent, HP, etc.)



Available Models

Standard Models• Essential models that support the majority of OPNET users• Generic• Vendor (Cisco, Lucent, Marconi, etc.)

Specialized Models• Models of interest to more focused communities within the OPNET user base• They are available on a fee/license basis• Current specialized models include

UMTSDOCSISIPv6Circuit SwitchingMPLSPNNI



Modeler Wireless

Wireless nodes and protocolsNode mobility• Trajectory• Orbit (for satellite nodes)

RF effectsTerrain EffectsModeler Wireless for Defense also includes:• 3D Network Visualizer• HLA• TIREM propagation models



Accelerate OPNET Modeler ProjectsKey application areas:• Build network topologies programmatically • Construct custom workflows to facilitate model configuration• Customize network visualization• Create custom workflows to selectively enable Modeler functionality

OPNET Development Kit (ODK)



C/C++ APIsHighlights• Custom Network data import/export• OPNET Advanced Graphical Interface• Wizard-driven topology creation and configuration• Custom Visualization• Report generation and export

ODK Overview



ODK enables a user to develop custom mechanisms for importing topology, traffic and configuration data from text files, databases, spreadsheets, etc.

Programmatically Build Network Topologies



Use ODK’s dialog box editor and APIs to construct workflows that simplify the configuration process

Example uses of ODK in IT Guru, SP Guru, and Modeler products• “Create DES Application

Demands”• “Configure Routing Protocols”• “Configure VLANS for

Selected Nodes”• Active Attributes

Construct Custom Workflows



ODK can be used to define custom visualizations to provide a quick “top level” view of network configuration

“Color Links by Utilization”“Visualize IP Routing Protocols”

Custom Network Visualizations



Tailor the UI to narrow access to required features, and customize workflows to support the target use cases

Customized network management applications• Slimmed down version of Modeler

Example usesSpectral optical design solutionMany consulting projects

Create Custom Workflows Using a Limited GUI



Questions



OPNET Web Site

http://www.opnet.comServices• Training• Consulting

Support Center• FAQs• Licenses• Mailing List• Contributed models and papers• Updates (software, models, documentation)• Tech Support• Login assistance



Documentation References

Modeler TutorialsModel User GuidesMethodologies and Case StudiesFAQs on www.opnet.com• 78: How can I map more than one dimension into the code in

op_intrpt_schedule_self ()? • 166: What mechanisms can be used by the model developer to share data

among processes without using invocations or interrupts?• 182: How do I get the “beginsim intrpt” attribute enabled?• 1091: How do I track what line of code is causing a syntax error and/or other

compilation errors?• 1209: How can I generate distribution outcomes from my own function instead

of standard distributions or an external file?• Many many others (over 1400 FAQs)



Related OPNETWORK Sessions

Recommended OPNETWORK sessions• 1574: Modeling and Simulation Using Advanced Modeler Features• 1432: Modeling Applications with the ACE Whiteboard• Model usage sessions (ATM, TCP, etc.)• Process Modeling

1502: Debugging Simulation Models – Intro1503: Debugging Simulation Models – Advanced1501: Process Modeling Methodology/Dynamic Processes1505: Building Traffic Source Models

• Wireless1530: Modeling Custom Wireless Effects1527: Accelerating Wireless Simulations Using Scalability Techniques



Take-Away Points

OPNET simulations are event drivenOPNET modeling hierarchy• Network• Node• Process

Model design is modularResults can be displayed in many waysAlmost everything can be customized to fit your needs

opnet

Documents

confidential

prior written

enter execs

simulation

event typebegsim

process immediately

event list

evaluate condition