OMNET++
Outline
• Introduction
• Overview
• The NED Language
• Simple Modules
What Is OMNeT++?
• Object-oriented modular discrete event network
simulation framework
• modeling of wired and wireless communication networks
• protocol modeling
• modeling of queueing networks
• modeling of multiprocessors and other distributed hardware
systems
• validating of hardware architectures
• evaluating performance aspects of complex software systems
What Is OMNeT++?
• Object-oriented modular discrete event network
simulation framework
• Components (modules) are programmed in C++
• Assembled into larger components and models using a
high-level language (NED)
Modeling Concepts
Gates
• Input and output interfaces
Connection
• Spanning hierarchy levels are not permitted
• Propagation delay, data rate and bit error rate, can be assigned
Main features
• Hierarchical Modules
• Top level module is the system module
• Depth of module nesting is unlimited
• Model structure is described in OMNeT++'s NED language
• User implements the simple modules in C++, using the OMNeT++
simulation class library
• Module Types
• Both simple and compound modules are instances of module types
Main features
• Messages
• Modules communicate by exchanging messages
• Frames or packets in a computer network
• Jobs or customers in a queuing network
• Gates
• Input and output interfaces of modules
• messages are sent out through output gates and arrive through
input gates
• Links (connection)
• Created within a single level of the module hierarchy
Main features
• Modeling of Packet Transmissions
• Data rate, propagation delay, bit error rate and packet error rate
• Parameters
• Can be assigned in either the NED files or the configuration file
omnetpp.ini
• Used to customize simple module behavior, and to parameterize
the model topology
• Topology Description Method
• User defines the structure of the model in NED language
descriptions
The NED Language
• A communication network
Defines a network
//Net6.ned
network Network
{
submodules:
node1: Node;
node2: Node;
node3: Node;
...
connections:
node1.port++ <-->
node2.port++ <-->
node4.port++ <-->
...
}
//omnetpp.ini
[General]
network = Network
new gate
{datarate=100Mbps;} <--> node2.port++;
{datarate=100Mbps;} <--> node4.port++;
{datarate=100Mbps;} <--> node6.port++;
Introducing a Channel
network Network
{
types:
channel C extends ned.DatarateChannel {
datarate = 100Mbps;
}
submodules:
node1: Node;
node2: Node;
node3: Node;
...
connections:
node1.port++ <--> C <--> node2.port++;
node2.port++ <--> C <--> node4.port++;
node4.port++ <--> C <--> node6.port++;
...
}
The App, Routing, and Queue Simple
Modules
simple App
{
parameters:
int destAddress;
...
@display("i=block/browser");
gates:
sending
input in;
output out;
}
simple Routing
{
...
}
simple Queue
{
...
}
App.ned, Routing.ned and Queue.ned
and receiving application packets
The Node Compound Module
module Node
{
parameters:
int address;
@display("i=misc/node_vs,gold");
gates:
size will be determined implicitly
inout port[];
submodules:
bidirectional connections
app: App;
routing: Routing;
queue[sizeof(port)]: Queue;
connections:
routing.localOut --> app.in;
routing.localIn <-- app.out;
for i=0..sizeof(port)-1 {
routing.out[i] --> queue[i].in;
routing.in[i] <-- queue[i].out;
queue[i].line <--> port[i];
}
}
by the number of neighbours
Simple Modules
• Simple modules are programmed in C++, using the
OMNeT++ class library
• Discrete Event Simulation
• start of a packet transmission
• end of a packet transmission
• expiry of a retransmission timeout
initialize -- this includes building the model and
inserting initial events to FES(Future Event Set)
while (FES not empty and simulation not yet complete)
{
retrieve first event from FES
t:= timestamp of this event
process event
(processing may insert new events in FES or delete existing ones)
}
finish simulation (write statistical results, etc.)
Components, Simple Modules, Channels
Defining Simple Module Types
// file: HelloModule.cc
#include <omnetpp.h>
// file: HelloModule.ned
simple HelloModule
{
gates:
input in;
}
class HelloModule : public cSimpleModule
{
protected:
virtual void initialize();
virtual void handleMessage(cMessage *msg);
};
// register module class with `\opp`
Define_Module(HelloModule);
void HelloModule::initialize()
{
ev << "Hello World!\n";
}
called for every message that arrives at the module
void HelloModule::handleMessage(cMessage *msg)
{
delete msg; // just discard everything we receive
}
handleMessage()
• send() family of functions
• to send messages to other modules
• scheduleAt()
• to schedule an event (the module “sends a message to itself”)
• cancelEvent()
• to delete an event scheduled with scheduleAt()
• Cannot use the receive() and wait() functions
Protocol Models
class FooProtocol : public cSimpleModule
{
protected:
// state variables
// ...
virtual void processMsgFromHigherLayer(cMessage *packet);
virtual void processMsgFromLowerLayer(FooPacket *packet);
virtual void processTimer(cMessage *timer);
virtual void initialize();
virtual void handleMessage(cMessage *msg);
};
// ...
void FooProtocol::handleMessage(cMessage *msg)
{
if (msg->isSelfMessage())
processTimer(msg);
else if (msg->arrivedOn("fromNetw"))
processMsgFromLowerLayer(check_and_cast<FooPacket *>(msg));
else
processMsgFromHigherLayer(msg);
}
activity()
• receive()
• to receive messages (events)
• wait()
• to suspend execution for some time (model time)
• send() family of functions
• to send messages to other modules
• scheduleAt()
• to schedule an event (the module “sends a message to itself”)
• cancelEvent()
• to delete an event scheduled with scheduleAt()
• end()
• to finish execution of this module (same as exiting the activity()
function)
activity()
void Sink::activity()
{
while(true)
{
msg = receive();
delete msg;
}
}