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 Connection Spanning hierarchy levels are not permitted Propagation delay, data rate and bit error rate, can be assigned Gates Input and output interfaces

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++ {datarate=100Mbps;} node2.port++; node2.port++ {datarate=100Mbps;} node4.port++; node4.port++ {datarate=100Mbps;} node6.port++;... } //omnetpp.ini [General] network = Network new gate

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 gates: input in; output out; } simple Routing {... } simple Queue {... } sending and receiving application packets App.ned, Routing.ned and Queue.ned

The Node Compound Module module Node { parameters: int gates: inout port[]; submodules: 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]; } size will be determined implicitly by the number of neighbours bidirectional connections

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 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"; } void HelloModule::handleMessage(cMessage *msg) { delete msg; // just discard everything we receive } called for every message that arrives at the module // file: HelloModule.ned simple HelloModule { gates: input in; }

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 (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; }