Changeset 12060 for source/ariba/overlay/messages

Timestamp:

Jun 19, 2013, 11:05:49 AM (11 years ago)

Author:

hock@…

Message:

Reintegrate branch: 20130111-hock-message_classes

improvements:

• new message classes (reboost, zero-copy)
• "fast path" for direct links (skip overlay layer)
• link-properties accessible from the application
• SystemQueue can call boost::bind functions
• protlib compatibility removed (32bit overhead saved in every message)
• addressing2
• AddressDiscovery discoveres only addresses on which we're actually listening
• ariba serialization usage reduced (sill used in OverlayMsg)
• Node::connect, easier and cleaner interface to start-up ariba from the application
• ariba configs via JSON, XML, etc (boost::property_tree)
• keep-alive overhead greatly reduced
• (relayed) overlay links can actually be closed now
• lost messages are detected in most cases
• notification to the application when link is transformed into direct-link
• overlay routing: send message to second best hop if it would be dropped otherwise
• SequenceNumbers (only mechanisms, so for: upward compatibility)
• various small fixes

regressions:

• bluetooth is not yet working again
• bootstrap modules deactivated
• liblog4xx is not working (use cout-logging)

This patch brings great performance and stability improvements at cost of backward compatibility.
Also bluetooth and the bootstrap modules have not been ported to the new interfaces, yet.

Location:

source/ariba/overlay/messages

Files:

• JoinReply.cpp (modified) (2 diffs)
• JoinReply.h (modified) (6 diffs)
• OverlayMsg.h (modified) (17 diffs)

source/ariba/overlay/messages/JoinReply.cpp

@@ -44 +44 @@
 vsznDefault(JoinReply);
 
-JoinReply::JoinReply(const SpoVNetID _spovnetid, const OverlayParameterSet _param, bool _joinAllowed, const EndpointDescriptor _bootstrapEp)
-        : spovnetid( _spovnetid ), param( _param ), joinAllowed( _joinAllowed ), bootstrapEp( _bootstrapEp ){
+JoinReply::JoinReply(const SpoVNetID _spovnetid, const OverlayParameterSet _param, bool _joinAllowed)
+        : spovnetid( _spovnetid ), param( _param ), joinAllowed( _joinAllowed )
+{
 }
 
@@ -64 +65 @@
 }
 
-const EndpointDescriptor& JoinReply::getBootstrapEndpoint(){
-        return bootstrapEp;
-}
+//const EndpointDescriptor& JoinReply::getBootstrapEndpoint(){
+//      return bootstrapEp;
+//}
 
 }} // ariba::overlay

source/ariba/overlay/messages/JoinReply.h

@@ -40 +40 @@
 #define JOIN_REPLY_H__
 
-#include "ariba/utility/messages.h"
+//#include "ariba/utility/messages.h"
+#include "ariba/utility/messages/Message.h"
 #include "ariba/utility/serialization.h"
 #include "ariba/utility/types/SpoVNetID.h"
 #include "ariba/utility/types/NodeID.h"
 #include "ariba/utility/types/OverlayParameterSet.h"
-#include "ariba/communication/EndpointDescriptor.h"
+//#include "ariba/communication/EndpointDescriptor.h"
 
 using ariba::utility::OverlayParameterSet;
@@ -51 +52 @@
 using ariba::utility::SpoVNetID;
 using ariba::utility::NodeID;
-using ariba::communication::EndpointDescriptor;
+//using ariba::communication::EndpointDescriptor;
 
 namespace ariba {
@@ -64 +65 @@
         OverlayParameterSet param; //< overlay parameters
         bool joinAllowed; //< join successfull or access denied
-        EndpointDescriptor bootstrapEp; //< the endpoint for bootstrapping the overlay interface
+//      EndpointDescriptor bootstrapEp; //< the endpoint for bootstrapping the overlay interface
 
 public:
@@ -70 +71 @@
                 const SpoVNetID _spovnetid = SpoVNetID::UNSPECIFIED,
                 const OverlayParameterSet _param = OverlayParameterSet::DEFAULT,
-                bool _joinAllowed = false,
-                const EndpointDescriptor _bootstrapEp = EndpointDescriptor::UNSPECIFIED()
+                bool _joinAllowed = false  /*,
+                const EndpointDescriptor _bootstrapEp = EndpointDescriptor::UNSPECIFIED()*/
         );
 
@@ -79 +80 @@
         const OverlayParameterSet& getParam();
         bool getJoinAllowed();
-        const EndpointDescriptor& getBootstrapEndpoint();
+//      const EndpointDescriptor& getBootstrapEndpoint();
 };
 
@@ -86 +87 @@
 sznBeginDefault( ariba::overlay::JoinReply, X ) {
         uint8_t ja = joinAllowed;
-        X && &spovnetid && param && bootstrapEp && ja;
+        X && &spovnetid && param;
+//      X && bootstrapEp;
+        X && ja;
         if (X.isDeserializer()) joinAllowed = ja;
 } sznEnd();

source/ariba/overlay/messages/OverlayMsg.h

@@ -47 +47 @@
 #include "ariba/utility/types/NodeID.h"
 #include "ariba/utility/types/LinkID.h"
-#include "ariba/communication/EndpointDescriptor.h"
-
+// #include <ariba/utility/misc/sha1.h>
+#include "ariba/overlay/SequenceNumber.h"
 
 namespace ariba {
@@ -57 +57 @@
 using ariba::utility::ServiceID;
 using ariba::utility::Message;
-using ariba::communication::EndpointDescriptor;
+//using ariba::communication::EndpointDescriptor;
 using_serialization;
 
@@ -64 +64 @@
  * between nodes.
  *
- * @author Sebastian Mies <mies@tm.uka.de>
+ * @author Sebastian Mies <mies@tm.uka.de>, Mario Hock
  */
 class OverlayMsg: public Message { VSERIALIZEABLE;
@@ -75 +75 @@
                 maskTransfer    = 0x10, ///< bit mask for transfer messages
                 typeData        = 0x11, ///< message contains data for higher layers
+                typeMessageLost = 0x12, ///< message contains info about a dropped message
 
                 // join signaling
@@ -87 +88 @@
                 typeLinkUpdate  = 0x33, ///< update message for link association
                 typeLinkDirect  = 0x34, ///< direct connection has been established
-                typeLinkAlive   = 0x35, ///< keep-alive message
+                typeKeepAlive   = 0x35, ///< keep-alive message
+                typeKeepAliveReply   = 0x36, ///< keep-alive message (replay)
+                typeLinkClose   = 0x37,
 
                 /// DHT routed messages
@@ -100 +103 @@
                 maskDHTResponse = 0x50, ///< bit mask for dht responses
                 typeDHTData     = 0x51, ///< DHT get data
+        
+        /// misc message types
+        typePing        = 0x44,
+        typePong        = 0x45,
 
                 // topology signaling
@@ -105 +112 @@
                 typeSignalingEnd = 0xFF    ///< end of the signaling types
         };
+    
+    /// message flags (uint8_t)
+    enum flags_
+    {
+        flagRelayed         = 1 << 0,
+        flagRegisterRelay   = 1 << 1,
+        flagRouteRecord     = 1 << 2,
+        flagSeqNum1         = 1 << 3,
+        flagSeqNum2         = 1 << 4,
+        flagAutoLink        = 1 << 5,
+        flagLinkMessage     = 1 << 6,
+        flagHasMoreFlags    = 1 << 7
+    };
 
         /// default constructor
@@ -114 +134 @@
                 const LinkID& _sourceLink      = LinkID::UNSPECIFIED,
                 const LinkID& _destinationLink = LinkID::UNSPECIFIED )
-        :       type(type), flags(0), hops(0), ttl(10),
+    :   type(type), flags(0), extended_flags(0), hops(0), ttl(10), priority(0),
                 service(_service),
                 sourceNode(_sourceNode), destinationNode(_destinationNode),
@@ -125 +145 @@
         // copy constructor
         OverlayMsg(const OverlayMsg& rhs)
-        :       type(rhs.type), flags(rhs.flags), hops(rhs.hops), ttl(rhs.ttl),
-                service(rhs.service),
+    :   type(rhs.type), flags(rhs.flags), extended_flags(rhs.extended_flags), 
+        hops(rhs.hops), ttl(rhs.ttl),
+                priority(rhs.priority), service(rhs.service),
                 sourceNode(rhs.sourceNode), destinationNode(rhs.destinationNode),
                 sourceLink(rhs.sourceLink), destinationLink(rhs.destinationLink),
@@ -149 +170 @@
         }
 
+        /// priority ------------------------------------------------------------------
+        
+        uint8_t getPriority() const {
+            return priority;
+        }
+        
+        void setPriority(uint8_t priority) {
+            this->priority = priority;
+        }
+        
         /// flags ------------------------------------------------------------------
 
         bool isRelayed() const {
-                return (flags & 0x01)!=0;
+        return (flags & flagRelayed)!=0;
         }
 
         void setRelayed( bool relayed = true ) {
-                if (relayed) flags |= 1; else flags &= ~1;
+        if (relayed) flags |= flagRelayed; else flags &= ~flagRelayed;
         }
 
         bool isRegisterRelay() const {
-                return (flags & 0x02)!=0;
+                return (flags & flagRegisterRelay)!=0;
         }
 
         void setRegisterRelay( bool relayed = true ) {
-                if (relayed) flags |= 0x02; else flags &= ~0x02;
+        if (relayed) flags |= flagRegisterRelay; else flags &= ~flagRegisterRelay;
         }
 
         bool isRouteRecord() const {
-                return (flags & 0x04)!=0;
+                return (flags & flagRouteRecord)!=0;
         }
 
         void setRouteRecord( bool route_record = true ) {
-                if (route_record) flags |= 0x04; else flags &= ~0x04;
+        if (route_record) flags |= flagRouteRecord; else flags &= ~flagRouteRecord;
         }
 
         bool isAutoLink() const {
-                return (flags & 0x80) == 0x80;
+        return (flags & flagAutoLink) == flagAutoLink;
         }
 
         void setAutoLink(bool auto_link = true ) {
-                if (auto_link) flags |= 0x80; else flags &= ~0x80;
+        if (auto_link) flags |= flagAutoLink; else flags &= ~flagAutoLink;
         }
 
         bool isLinkMessage() const {
-                return (flags & 0x40)!=0;
+                return (flags & flagLinkMessage)!=0;
         }
 
         void setLinkMessage(bool link_info = true ) {
-                if (link_info) flags |= 0x40; else flags &= ~0x40;
-        }
-
-        bool containsSourceEndpoint() const {
-                return (flags & 0x20)!=0;
-        }
-
-        void setContainsSourceEndpoint(bool contains_endpoint) {
-                if (contains_endpoint) flags |= 0x20; else flags &= ~0x20;
-        }
+        if (link_info) flags |= flagLinkMessage; else flags &= ~flagLinkMessage;
+        }
+        
+        bool hasExtendedFlags() const {
+        return (flags & flagHasMoreFlags) == flagHasMoreFlags;
+    }
 
         /// number of hops and time to live ----------------------------------------
@@ -264 +291 @@
                 this->destinationLink = link;
                 setLinkMessage();
-        }
-
-        void setSourceEndpoint( const EndpointDescriptor& endpoint ) {
-                sourceEndpoint = endpoint;
-                setContainsSourceEndpoint(true);
-        }
-
-        const EndpointDescriptor& getSourceEndpoint() const {
-                return sourceEndpoint;
         }
 
@@ -284 +302 @@
                 destinationLink = dummyLink;
                 hops = 0;
+                routeRecord.clear();
         }
 
@@ -294 +313 @@
                         routeRecord.push_back(node);
         }
+        
+        /// sequence numbers
+        bool hasShortSeqNum() const
+    {
+        return (flags & (flagSeqNum1 | flagSeqNum2)) == flagSeqNum1;
+    }
+    
+    bool hasLongSeqNum() const
+    {
+        return (flags & (flagSeqNum1 | flagSeqNum2)) == flagSeqNum2;
+    }
+    
+    void setSeqNum(const SequenceNumber& sequence_number)
+    {
+        this->seqnum = sequence_number;
+        
+        // short seqnum
+        if ( sequence_number.isShortSeqNum() )
+        {
+            flags |= flagSeqNum1;
+            flags &= ~flagSeqNum2;
+        }
+        // longseqnum
+        else if ( sequence_number.isShortSeqNum() )
+        {
+            flags &= ~flagSeqNum1;
+            flags |= flagSeqNum2;
+        }
+        // no seqnum
+        else
+        {
+            flags &= ~flagSeqNum1;
+            flags &= ~flagSeqNum2;
+        }
+    }
+    
+    const SequenceNumber& getSeqNum() const
+    {
+        return seqnum;
+    }
+    
 
 private:
-        uint8_t type, flags, hops, ttl;
+        uint8_t type, flags, extended_flags, hops, ttl, priority;
         ServiceID service;
         NodeID sourceNode;
@@ -302 +362 @@
         LinkID sourceLink;
         LinkID destinationLink;
-        EndpointDescriptor sourceEndpoint;
+//      EndpointDescriptor sourceEndpoint;
         vector<NodeID> routeRecord;
+    SequenceNumber seqnum;
 };
 
@@ -311 +372 @@
 sznBeginDefault( ariba::overlay::OverlayMsg, X ){
         // header
-        X && type && flags && hops && ttl;
+        X && type && flags;
+    
+    if ( hasExtendedFlags() )
+        X && extended_flags;
+    
+    X && hops && ttl;
 
         // addresses
         X && &service && &sourceNode && &destinationNode;
+        
+        // priority
+        X && priority;
 
         // message is associated with a end-to-end link
@@ -320 +389 @@
                 X && &sourceLink && &destinationLink;
 
-        // message is associated with a source end-point
-        if (containsSourceEndpoint())
-                X && sourceEndpoint;
-
+    
+    /* seqnum */
+    // serialize
+    if ( X.isSerializer() )
+    {
+        if ( hasShortSeqNum() )
+        {
+            uint32_t short_seqnum;
+            short_seqnum = seqnum.getShortSeqNum();
+            X && short_seqnum;
+        }
+        if ( hasLongSeqNum() )
+        {
+            uint64_t long_seqnum;
+            long_seqnum = seqnum.getLongSeqNum();
+            X && long_seqnum;
+        }
+    }
+    // deserialize
+    else
+    {
+        if ( hasShortSeqNum() )
+        {
+            uint32_t short_seqnum;
+            X && short_seqnum;
+            seqnum = ariba::overlay::SequenceNumber(short_seqnum);
+        }
+        if ( hasLongSeqNum() )
+        {
+            uint64_t long_seqnum;
+            X && long_seqnum;
+            seqnum = ariba::overlay::SequenceNumber(long_seqnum);
+        }        
+    }
+    
+    
         // message should record its route
         if (isRouteRecord()) {
@@ -333 +434 @@
 
         // payload
-        X && Payload();
+//      X && Payload();
 } sznEnd();