Changes between Version 17 and Version 18 of OverSimDevelop

Timestamp:

Apr 20, 2009, 10:24:41 AM (16 years ago)

Author:

heep

Comment:

--

OverSimDevelop

@@ -256 +256 @@
 // initializeApp is called when the module is being created.
 // Use this function instead of the constructor for initializing variables.
-void MyApplication::initializeApp(int stage) {
-
+void MyApplication::initializeApp(int stage)
+{
     // initializeApp will be called twice, each with a different stage.
     // stage can be either MIN_STAGE_APP (this module is being created), or MAX_STAGE_APP (all modules were created).
@@ -289 +289 @@
 // finalize is called when the module is being destroyed
 
-void MyApplication::finishApp() {
-
+void MyApplication::finishApp()
+{
     // first we'll delete our timer
 
@@ -317 +317 @@
 
         for (int i = 0; i < numToSend; i++) {
-
             OverlayKey randomKey(intuniform(1, largestKey)); // let's create a random key
 
@@ -362 +361 @@
 // Unhandled or unknown packets can be safely deleted here.
 
-void MyApplication::handleUDPMessage(cMessage* msg) {
+void MyApplication::handleUDPMessage(cMessage* msg)
+{
     // we are only expecting messages of type MyMessage
 
@@ -387 +387 @@
 #!cpp
 class MyOverlay : public BaseOverlay {
-public:
-
+  public:
     // Routing parameters
     int myKey;               // our overlay key
@@ -408 +407 @@
     // obligatory: called when we need the next hop to route a packet to the given key
     NodeVector* findNode(const OverlayKey& key,             // key to route to
-                                 int numRedundantNodes,     // how many candidates for next hop we want (see getMaxNumSiblings)
-                                 int numSiblings,           // how many siblings we'll return (?) (see getMaxRedundantNodes)
-                                 BaseOverlayMessage* msg);  // message being routed
+                         int numRedundantNodes,             // how many candidates for next hop we want (see getMaxNumSiblings)
+                         int numSiblings,                   // how many siblings we'll return (?) (see getMaxRedundantNodes)
+                         BaseOverlayMessage* msg);          // message being routed
 
     // obligatory: In general, called when we need to know whether node is amongst numSiblings closest nodes to key.
     // But normally it is called with node set to this node, and asking whether this node is responsible for key.
     bool isSiblingFor(const NodeHandle& node,               // which node (usually thisNode) we're referring to
-                                 const OverlayKey& key,     // key in question
-                                 int numSiblings,           // how many siblings we're querying about
-                                 bool* err);                // set to false when we couldn't determine the range
+                      const OverlayKey& key,                // key in question
+                      int numSiblings,                      // how many siblings we're querying about
+                      bool* err);                           // set to false when we couldn't determine the range
 
     // obligatory: Set the maximum number of siblings that can be queried about (usually 1)
@@ -479 +478 @@
 // Return whether we know if the given node is responsible for the key
 bool MyOverlay::isSiblingFor(const NodeHandle& node,
-                                 const OverlayKey& key,
-                                 int numSiblings,
-                                 bool* err)
+                             const OverlayKey& key,
+                             int numSiblings,
+                             bool* err)
 {
     if (node == thisNode && key == thisNode.key) { // is it our node and our key?
@@ -491 +490 @@
 // Return the next step for the routing of the given message
 NodeVector *MyOverlay::findNode(const OverlayKey& key,
-                                 int numRedundantNodes,
-                                 int numSiblings,
-                                 BaseOverlayMessage* msg)
+                                int numRedundantNodes,
+                                int numSiblings,
+                                BaseOverlayMessage* msg)
 {
     NodeVector* nextHops;
@@ -674 +673 @@
 Now we need to build !OverSim. There are two types of builds: debug (no optimizations, include debug information) and release (optimizations, with reduced debug information). Go to the root folder and type one of the following:
 
+{{{
+#!sh
 make MODE=release   # release mode
 make MODE=debug     # debug mode
 make                # also sets debug mode
+}}}
 
 That should compile your new modules. To clear all compiled files, use make clean as usual.
@@ -771 +773 @@
 {{{
 #!cpp
-    void MyOverlay::getNeighbors(const OverlayKey &neighborKey) {
-        MyNeighborCall *msg = new MyNeighborCall();
-        msg->setDestinationKey(neighborKey);
-
-        // The function we'll be using to send an RPC is sendRouteRpcCall.
-        // The first value is to which tier we'll be talking. Can be either OVERLAY_COMP, TIER1_COMP, TIER2_COMP, and so on.
-        // The second parameter is the node to which we'll send the message. Can be either an OverlayKey or a TransportAddress.
-        // The third parameter is the message.
-        sendRouteRpcCall(OVERLAY_COMP, neighborKey, msg);
+void MyOverlay::getNeighbors(const OverlayKey &neighborKey)
+{
+    MyNeighborCall *msg = new MyNeighborCall();
+    msg->setDestinationKey(neighborKey);
+
+    // The function we'll be using to send an RPC is sendRouteRpcCall.
+    // The first value is to which tier we'll be talking. Can be either OVERLAY_COMP, TIER1_COMP, TIER2_COMP, and so on.
+    // The second parameter is the node to which we'll send the message. Can be either an OverlayKey or a TransportAddress.
+    // The third parameter is the message.
+    sendRouteRpcCall(OVERLAY_COMP, neighborKey, msg);
+}
+}}}
+
+Now, let's see how the RPC calls are implemented:
+
+{{{
+#!cpp
+// Handle an incoming Call message
+// Only delete msg if the RPC is handled here, and you won't respond using sendRpcResponse!
+
+bool MyOverlay::handleRpcCall(BaseCallMessage *msg) {
+    
+    // There are many macros to simplify the handling of RPCs. The full list is in <OverSim>/src/common/RpcMacros.h.
+    
+    // start a switch
+    RPC_SWITCH_START(msg);
+        
+    // enters the following block if the message is of type MyNeighborCall (note the shortened parameter!)
+    RPC_ON_CALL(MyNeighbor) {
+        MyNeighborCall *mrpc = (MyNeighborCall*)msg;          // get Call message
+        MyNeighborResponse *rrpc = new MyNeighborResponse();  // create response
+        rrpc->setRespondingNode(thisNode);
+        rrpc->setPrevNeighbor(prevNode);
+        rrpc->setNextNeighbor(nextNode);
+            
+        // now send the response. sendRpcResponse can automatically tell where to send it to.
+        // note that sendRpcResponse will delete mrpc (aka msg)!
+        sendRpcResponse(mrpc, rrpc);
+    
+        RPC_HANDLED = true;  // set to true, since we did handle this RPC (default is false)
     }
-}}}
-
-Now, let's see how the RPC calls are implemented:
-
-{{{
-#!cpp
-    // Handle an incoming Call message
-    // Only delete msg if the RPC is handled here, and you won't respond using sendRpcResponse!
-
-    bool MyOverlay::handleRpcCall(BaseCallMessage *msg) {
-        
-        // There are many macros to simplify the handling of RPCs. The full list is in <OverSim>/src/common/RpcMacros.h.
-        
-        // start a switch
-        RPC_SWITCH_START(msg);
-        
-        // enters the following block if the message is of type MyNeighborCall (note the shortened parameter!)
-        RPC_ON_CALL(MyNeighbor) {
-            MyNeighborCall *mrpc = (MyNeighborCall*)msg;          // get Call message
-
-            MyNeighborResponse *rrpc = new MyNeighborResponse();  // create response
-            rrpc->setRespondingNode(thisNode);
-            rrpc->setPrevNeighbor(prevNode);
-            rrpc->setNextNeighbor(nextNode);
-            
-            // now send the response. sendRpcResponse can automatically tell where to send it to.
-            // note that sendRpcResponse will delete mrpc (aka msg)!
-            sendRpcResponse(mrpc, rrpc);
-    
-            RPC_HANDLED = true;  // set to true, since we did handle this RPC (default is false)
-        }
-
-        // end the switch
-        RPC_SWITCH_END();
-
-        // return whether we handled the message or not.
-        // don't delete unhandled messages!
-        return RPC_HANDLED;
-    }
-
-    // Called when an RPC we sent has timed out.
-    // Don't delete msg here!
-
-    void MyOverlay::handleRpcTimeout(BaseCallMessage* msg,
-                             const TransportAddress& dest,
-                             cPolymorphic* context, int rpcId,
-                             const OverlayKey&) 
-    {
-        // Same macros as in handleRpc
-
-        // start a switch
-        RPC_SWITCH_START(msg);
-        
+
+    // end the switch
+    RPC_SWITCH_END();
+
+    // return whether we handled the message or not.
+    // don't delete unhandled messages!
+    return RPC_HANDLED;
+}
+
+// Called when an RPC we sent has timed out.
+// Don't delete msg here!
+void MyOverlay::handleRpcTimeout(BaseCallMessage* msg,
+                                 const TransportAddress& dest,
+                                 cPolymorphic* context, int rpcId,
+                                 const OverlayKey&) 
+{
+    // Same macros as in handleRpc
+
+    // start a switch
+    RPC_SWITCH_START(msg);        
         // enters the following block if the message is of type MyNeighborCall (note the shortened parameter!)
         RPC_ON_CALL(MyNeighbor) {
@@ -839 +839 @@
             callbackTimeout(mrpc->getDestinationKey());           // call our interface function
         }
-        // end the switch
-        RPC_SWITCH_END();
-    }
+    // end the switch
+    RPC_SWITCH_END();
+}
 
     // Called when we receive an RPC response from another node.
     // Don't delete msg here!
 
-    void MyOverlay::handleRpcResponse(BaseResponseMessage* msg,
-                              cPolymorphic* context,
-                              int rpcId,
-                              simtime_t rtt)
-    {
-        // The macros are here similar. Just use RPC_ON_RESPONSE instead of RPC_ON_CALL.
-
-        // start a switch
-        RPC_SWITCH_START(msg);
-        
+void MyOverlay::handleRpcResponse(BaseResponseMessage* msg,
+                                  cPolymorphic* context,
+                                  int rpcId,
+                                  simtime_t rtt)
+{
+    // The macros are here similar. Just use RPC_ON_RESPONSE instead of RPC_ON_CALL.
+
+    // start a switch
+    RPC_SWITCH_START(msg);        
         // enters the following block if the message is of type MyNeighborResponse (note the shortened parameter!)
         RPC_ON_RESPONSE(MyNeighbor) {
@@ -863 +862 @@
                         mrpc->getNextNeighbor());                         // call our interface function
         }
-        // end the switch
-        RPC_SWITCH_END();
-    }
+    // end the switch
+    RPC_SWITCH_END();
+}
 }}}