Context Navigation

close Warning: BrowserModule failed with ConfigurationError: Look in the Trac log for more information.

Changes between Version 4 and Version 5 of OverSimDevelop

Timestamp:: Aug 15, 2008, 12:16:48 PM (16 years ago)
Author:: heep
Comment:: --

Legend:

: Unmodified
: Added
: Removed
: Modified

OverSimDevelop

-              v4
+              v5
 !OverSim nodes are the equivalent of individual terminals in the simulation environment. Nodes are based on a multi-tiered module hierarchy similar to OSI network layers (e.g. transport, overlay, application). The most used node type is called SimpleOverlayHost, and its tiers are structured as follows:
+PICTURE MISSING
 The UDP module is an implementation of the transport layer, and is in charge of communication between nodes. Above it is the overlay (KBR) tier, where the overlay module will be located. It communicates with other overlay nodes through the UDP layer, and exposes its services to the application layer above it. On the third tier is the application layer, which uses the services provided by the overlay module. Application modules may also use UDP directly if necessary. Other tiers may be activated above the application if required, these connect to the tier below and to the UDP module.
 …
 The user can set custom values for module parameters in the file omnetpp.ini, or in default.ini for general default values, both located in the Simulation folder (see Section 5). Parameters are hierarchic, separated by dots for each layer. For example, setting a parameter for a specific overlay module in a node can be done as follows:
+{{{ SimpleOverlay.overlayTerminal[5].overlay.myParam1 = 1024 }}}
+In this example, we are working with the network SimpleOverlay. From there, we need node number 5, and then its overlay module. For that module, we'll set the parameter myParam1 to 1024.  This case, however, is too specific. We may not always work with the SimpleOverlay network. Or we may need that parameter to be set for all nodes. For those cases the wildcards “*” and “**” are of use. For example:
+{{{ *.overlayTerminal[5].overlay.myParam1 = 1024 }}}[[BR]]
+{{{ **.overlay.myParam1 = 1024 }}}
+“*” replaces exactly one step of the hierarchy (or a part of a name), while “**” replaces any number of steps. In the first case, “*” means that the parameter is set for any network (first step). In the second case, “**” means the parameter is set for any network, and any node in it (first and second steps). Wildcards should be used sparingly, since it makes complicated for other users to calculate the scope, and may end up causing unexpected results (including rewriting other parameters).
+{{{
+SimpleOverlay.overlayTerminal[5].overlay.myParam1 = 1024
+}}}
+In this example, we are working with the network SimpleOverlay. From there, we need node number 5, and then its overlay module. For that module, we'll set the parameter myParam1 to 1024.  This case, however, is too specific. We may not always work with the SimpleOverlay network. Or we may need that parameter to be set for all nodes. For those cases the wildcards * and ** are of use. For example:
+{{{
+*.overlayTerminal[5].overlay.myParam1 = 1024
+**.overlay.myParam1 = 1024
+}}}
+* replaces exactly one step of the hierarchy (or a part of a name), while ** replaces any number of steps. In the first case, * means that the parameter is set for any network (first step). In the second case, ** means the parameter is set for any network, and any node in it (first and second steps). Wildcards should be used sparingly, since it makes complicated for other users to calculate the scope, and may end up causing unexpected results (including rewriting other parameters).
 Should a module parameter not be set in either omnetpp.ini or default.ini, or match any wildcard, !OverSim will prompt the user to enter a value for each instance of the module. For simulations with a big amount of nodes, setting each parameter individually quickly becomes overwhelming. Therefore, it is recommended that every module parameter be assigned a default value in default.ini.
 …
 == 3.1 Important attributes ==
+{{{ cModule *thisTerminal; }}}: Pointer to the overlay module.[[BR]]
+{{{ NodeHandle thisNode; }}}: Information about the overlay node (IP address, port and overlay key).[[BR]]
+{{{ BootstrapOracle* bootstrapOracle; }}} : Pointer to a database of registered overlay nodes, to be used for bootstrapping.[[BR]]
+{{{ NotificationBoard* notificationBoard; }}} : Pointer to the notification board, which is used to generate node events.[[BR]]
+{{{
+#!cpp
+cModule *thisTerminal;
+}}}
+Pointer to the overlay module.
+{{{
+#!cpp
+NodeHandle thisNode;
+}}}
+Information about the overlay node (IP address, port and overlay key).[[BR]]
+{{{
+#!cpp
+BootstrapOracle* bootstrapOracle;
+}}}
+Pointer to a database of registered overlay nodes, to be used for bootstrapping.[[BR]]
+{{{
+#!cpp
+NotificationBoard* notificationBoard;
+}}}
+Pointer to the notification board, which is used to generate node events.[[BR]]
 == 3.2 Initialization and finalization ==
 …
 {{{
+#!cpp
 void initialize(int stage);
 }}}
 …
 {{{
+#!cpp
 void initializeOverlay(int stage);
 }}}
 …
 {{{
+#!cpp
 void join(OverlayKey nodeID);
 }}}
 …
 {{{
+#!cpp
 void joinOverlay();
 }}}
 …
 {{{
+#!cpp
 void setOverlayReady(bool ready);
 }}}
 …
 {{{
+#!cpp
 void finishOverlay();
 }}}
 …
 {{{
+#!cpp
 sendMessageToUDP(const TransportAddress& dest, BaseOverlayMessage* msg);
 }}}
 …
 {{{
+#!cpp
 void handleUDPMessage(BaseOverlayMessage* msg);
 }}}
 …
 {{{
+#!cpp
 void sendMessageToApp(cMessage *msg);
 }}}
 …
 {{{
+#!cpp
 void handleAppMessage(cMessage* msg);
 }}}
 …
 {{{
+#!cpp
 void sendToKey(const OverlayKey& key, BaseOverlayMessage* message,
                int numSiblings = 1,
 …
 {{{
+#!cpp
 NodeVector* findNode( const OverlayKey& key, int numRedundantNodes, int numSiblings, BaseOverlayMessage* msg = NULL);
 }}}
 …
 {{{
+#!cpp
 bool isSiblingFor(const NodeHandle& node, const OverlayKey& key, int numSiblings, bool* err);
 }}}
 …
 {{{
+#!cpp
 bool handleFailedNode(const TransportAddress& failed);
 }}}
 …
 {{{
+#!cpp
 inline uint32_t sendUdpRpcCall(const TransportAddress& dest,
                                    BaseCallMessage* msg,
 …
 Timeout is the time to wait until a call is declared as lost, retries is the amount of times to retry a lost call.
 !RpcId is an RPC identifier to differentiate between calls.
+!RpcListener is a listener that will be notified for call events.
+{{{
+!RpcListener is a listener object that will be notified for responses and timout events.
+{{{
+#!cpp
 inline uint32_t sendRouteRpcCall(CompType destComp,
                                  const TransportAddress& dest,
 …
 Timeout is the time to wait until a call is declared as lost, retries is the amount of times to retry a lost call.
 !RpcId is an RPC identifier to differentiate between calls.
+!RpcListener is a listener that will be notified for call events.
+{{{
+!RpcListener is a listener object that will be notified for responses and timout events.
+{{{
+#!cpp
 inline uint32_t sendInternalRpcCall(CompType destComp,
                                     BaseCallMessage* msg,
 …
 Timeout is the time to wait until a call is declared as lost, retries is the amount of times to retry a lost call.
 !RpcId is an RPC identifier to differentiate between calls.
 !RpcListener is a listener that will be notified for call events.
+!RpcListener is a listener object that will be notified for responses and timout events.
 == 3.5.2 Receiving Remote Procedure Calls ==
 {{{
+#!cpp
 bool handleRpc(BaseCallMessage* msg);
 }}}
 …
 {{{
+#!cpp
     RPC_SWITCH_START( msg )
     RPC_DELEGATE( Join, rpcJoin );
 …
 {{{
+#!cpp
 void handleRpcTimeout( BaseCallMessage* msg, const TransportAddress& dest, int rpcId, const OverlayKey& destKey);
 }}}
 …
 == 3.5.3 Replying to Remote Procedure Calls ==
 {{{
+#!cpp
 void sendRpcResponse(BaseCallMessage* call, BaseResponseMessage* response);
 }}}
 …
 {{{
+#!cpp
 void handleRpcResponse( BaseResponseMessage* msg, int rpcId, simtime_t rtt );
 }}}
 …
 {{{
+#!cpp
 void pingNode(const TransportAddress& dest,
               simtime_t timeout = -1,
 …
 {{{
+#!cpp
 void pingResponse(PingResponse* response, cPolymorphic* context, int rpcId, simtime_t rtt);
 }}}
 …
 {{{
+#!cpp
 void pingTimeout(PingCall* call, const TransportAddress& dest, cPolymorphic* context, int rpcId);
 }}}
 …
 The first line of the configuration file is the inclusion of the default values. That is done by adding the following line:
+{{{ include ./default.ini }}}[[BR]]
+{{{
+include ./default.ini
+}}}
 Each simulation environment class is defined as a run. A configuration file can contain different amounts of runs, each with a different number. We need to set up the network in that run. There are two base networks: SimpleUnderlay and Ipv4Underlay. !SimpleUnderlay is a simplified flat network where each node is assigned coordinates, packet latencies are calculated based on the distance of the source and destination node coordinates, and each nodes are directly connected to one another. Ipv4Underlay emulates real-life networks and contain hierarchies of nodes, routers, and backbones.  The network type is set with the first-tier parameter network. Network modules can be accessed under the names of !SimpleNetwork for !SimpleUnderlay and Ipv4Network for Ipv4Underlay.  The module in charge of building the network is called underlayConfigurator.
 …
 # First churn
 *.churnGenerator[0].tier1Type = "MyClientModule"        // module name of the application tier
 *.churnGenerator[0].overlayType = "MyOverlay"   // module name of the overlay
+*.churnGenerator[0].tier1Type = "MyClientModule"  // module name of the application tier
+*.churnGenerator[0].overlayType = "MyOverlay"     // module name of the overlay
 # Second churn
 *.churnGenerator[1].tier1Type = "MyServerModule"        // module name of the application tier
 *.churnGenerator[1].overlayType = "MyOverlay"   // module name of the overlay
+*.churnGenerator[1].tier1Type = "MyServerModule"  // module name of the application tier
+*.churnGenerator[1].overlayType = "MyOverlay"     // module name of the overlay
 }}}
 …
 Change the “all:” section accordingly by adding your folder to the list.
 Now run “./makemake” and “make” in the root folder. That should compile your new modules.
+Now run {{{ ./makemake }}} and {{{ make }}} in the root folder. That should compile your new modules.
 In order to run it, you need to setup your simulation run in omnetpp.ini as explained in Section 5. Make sure that you selected default values for all parameters in default.ini, or you'll be prompted for a value when the simulation begins - for each instance of the parameter. To start !OverSim, enter the directory Simulations and run :
+{{{ ../bin/OverSim [-f customConfigFile] [-r runNumber] }}}[[BR]]
+{{{
+../bin/OverSim [-f customConfigFile] [-r runNumber]
+}}}
 If you don't select a run number, if the GUI is enabled, you'll be prompted for a run number. If not, all the runs in omnetpp.ini (or the given custom config file) will be run.
+'''Have fun!