merge

src/devices/mesh/dot11s/airtime-metric.cc

@@ -23,15 +23,53 @@
 #include "ns3/wifi-mode.h"
 namespace ns3 {
 namespace dot11s {
+NS_OBJECT_ENSURE_REGISTERED (AirtimeLinkMetricCalculator);
+TypeId
+AirtimeLinkMetricCalculator::GetTypeId ()
+{
+  static TypeId tid = TypeId ("ns3::dot11s::AirtimeLinkMetricCalculator")
+    .SetParent<Object> ()
+    .AddConstructor<AirtimeLinkMetricCalculator> ()
+    .AddAttribute ("overheadNanosec",
+        "Overhead expressed in nanoseconds:DIFS+ 2* SIFS + 2* PREAMBLE + 2* ACK",
+        UintegerValue (108000),
+        MakeUintegerAccessor (&AirtimeLinkMetricCalculator::m_overheadNanosec),
+        MakeUintegerChecker<uint32_t> (1)
+        )
+    .AddAttribute ("testLengt",
+        "Rate should be estimated using test length.",
+        UintegerValue (1024),
+        MakeUintegerAccessor (&AirtimeLinkMetricCalculator::m_testLength),
+        MakeUintegerChecker<uint16_t> (1)
+        )
+    .AddAttribute ("dot11HeaderLengt",
+        "Length of the 802.11 header",
+        UintegerValue (36),
+        MakeUintegerAccessor (&AirtimeLinkMetricCalculator::m_headerLength),
+        MakeUintegerChecker<uint16_t> (0)
+        )
+    .AddAttribute ("dot11sHeaderLength",
+        "Length of the mesh header",
+        UintegerValue (6),
+        MakeUintegerAccessor (&AirtimeLinkMetricCalculator::m_meshHeaderLength),
+        MakeUintegerChecker<uint16_t> (0)
+        );
+  return tid;
+} 
 uint32_t
 AirtimeLinkMetricCalculator::CalculateMetric(Mac48Address peerAddress, Ptr<MeshWifiInterfaceMac> mac)
 {
   WifiRemoteStation * station = mac->GetStationManager ()->Lookup(peerAddress);
   NS_ASSERT(station != 0);
-  Ptr<Packet> test_frame = Create<Packet> (test_length);
-  uint32_t rate = station->GetDataMode(test_frame, test_length+header_length).GetDataRate ();
-  uint32_t payload_nanosec = (uint32_t) ((double) (test_length * 8) * 1e9 / ((double)rate));
-  uint32_t metric = (uint32_t) (((double) (payload_nanosec + overhead_nanosec)) / 102.4 * (station->GetAvgSlrc () + 1));
+  Ptr<Packet> test_frame = Create<Packet> (m_testLength+ m_headerLength+ m_meshHeaderLength);
+  uint32_t rate = station->GetDataMode(test_frame, m_testLength + m_headerLength + m_meshHeaderLength).GetDataRate ();
+  uint32_t payload_nanosec = (uint32_t) ((double) ((m_testLength + m_meshHeaderLength) * 8) * 1e9 / ((double)rate));
+  uint32_t header_nanosec = (uint32_t)(
+      (double) (m_headerLength * 8 * 1e9) / ((double) mac->GetStationManager () -> GetBasicMode (0).GetDataRate ())
+      );
+  uint32_t metric = (uint32_t) (
+      ((double) (payload_nanosec + header_nanosec + m_overheadNanosec)) / 10240 * (station->GetAvgSlrc () + 1)
+      );
   return metric;
 }
 } //namespace dot11s

src/devices/mesh/dot11s/airtime-metric.h

@@ -23,21 +23,28 @@
 #include "ns3/mesh-wifi-interface-mac.h"
 namespace ns3 {
 namespace dot11s {
-class AirtimeLinkMetricCalculator : public RefCountBase
+/**
+ * \ingroup dot11s
+ * 
+ * \brief airtime link metric calculator
+ * \details airtime = (o + bt/r)* (1+avgrerycounter), where o is
+ * overhead, bt - is the tess length, r - the current rate of the
+ * packet, expressed in units of 10.24 us
+ */
+class AirtimeLinkMetricCalculator : public Object
 {
   public:
-    friend class MeshWifiInterfaceMac;
+    static TypeId GetTypeId ();
     uint32_t CalculateMetric(Mac48Address peerAddress, Ptr<MeshWifiInterfaceMac> mac);
   private:
-    ///\Microseconds of overhead:
-    static const uint32_t overhead_nanosec = 
-      (34   //DIFS
-      +9*2  //SIFS
-      +16*2 //Preamble
-      +24)  //Ack
-      *1000; //nanoseconds
-    static const uint32_t test_length = 1024;
-    static const uint32_t header_length = 36;
+    //\brief Overhead expressed in nanoseconds:DIFS+ 2* SIFS + 2*PREAMBLE + 2* ACK
+    uint32_t m_overheadNanosec;
+    ///\brief Bt value
+    uint32_t m_testLength;
+    ///\brief header length (used in overhead)
+    uint16_t m_headerLength;
+    ///\brief meshHeader length (6 octets ussialy)
+    uint16_t m_meshHeaderLength;
 };
 } //namespace dot11s
 } //namespace ns3

src/devices/mesh/dot11s/dot11s-helper.cc

@@ -67,7 +67,7 @@ MeshWifiHelper::CreateInterface (const WifiPhyHelper &phyHelper, Ptr<Node> node)
   device->SetMac (mac);
   device->SetPhy (phy);
   device->SetRemoteStationManager (manager);
-  Ptr<AirtimeLinkMetricCalculator> metric = Create <AirtimeLinkMetricCalculator> ();
+  Ptr<AirtimeLinkMetricCalculator> metric = CreateObject <AirtimeLinkMetricCalculator> ();
   mac->SetLinkMetricCallback (MakeCallback(&AirtimeLinkMetricCalculator::CalculateMetric, metric));
   /*
   if (channel > 0)

src/devices/mesh/dot11s/hwmp-mac-plugin.cc

@@ -60,13 +60,15 @@ HwmpMacPlugin::Receive (Ptr<Packet> packet, const WifiMacHeader & header)
       NS_ASSERT (false);
     }
     packet->RemoveHeader(meshHdr);
-    m_stats.recvData ++;
-    m_stats.recvDataBytes += packet->GetSize ();
+    m_stats.rxData ++;
+    m_stats.rxDataBytes += packet->GetSize ();
     //TODO: address extension
     Mac48Address destination;
+    Mac48Address source;
     switch (meshHdr.GetAddressExt ())
     {
       case 0:
+        source = header.GetAddr4 ();
         destination = header.GetAddr3 ();
         break;
       default:
@@ -78,17 +80,17 @@ HwmpMacPlugin::Receive (Ptr<Packet> packet, const WifiMacHeader & header)
       NS_ASSERT(false);
       return false;
     }
-    tag.SetTtl (meshHdr.GetMeshTtl () - 1);
+    tag.SetTtl (meshHdr.GetMeshTtl ());
     if(m_protocol->GetAddress() != destination)
       packet->AddPacketTag(tag);
     if (destination == Mac48Address::GetBroadcast ())
-      if(m_protocol->DropDataFrame (meshHdr.GetMeshSeqno (), header.GetAddr4 ()) )
+      if(m_protocol->DropDataFrame (meshHdr.GetMeshSeqno (), source))
         return false;
   }
   if(header.IsAction())
   {
-    m_stats.recvMgt ++;
-    m_stats.recvMgtBytes += packet->GetSize ();
+    m_stats.rxMgt ++;
+    m_stats.rxMgtBytes += packet->GetSize ();
     WifiMeshActionHeader actionHdr;
     packet->RemoveHeader (actionHdr);
     WifiMeshActionHeader::ActionValue actionValue = actionHdr.GetAction ();
@@ -99,7 +101,7 @@ HwmpMacPlugin::Receive (Ptr<Packet> packet, const WifiMacHeader & header)
       case WifiMeshActionHeader::PATH_REQUEST:
         {
           IePreq preq;
-          m_stats.recvPreq ++;
+          m_stats.rxPreq ++;
           packet->RemoveHeader (preq);
           if(preq.GetOriginatorAddress () == m_protocol->GetAddress ())
             return false;
@@ -112,7 +114,7 @@ HwmpMacPlugin::Receive (Ptr<Packet> packet, const WifiMacHeader & header)
       case WifiMeshActionHeader::PATH_REPLY:
         {
           IePrep prep;
-          m_stats.recvPrep ++;
+          m_stats.rxPrep ++;
           packet->RemoveHeader (prep);
           if(prep.GetTtl () == 0)
             return false;
@@ -123,7 +125,7 @@ HwmpMacPlugin::Receive (Ptr<Packet> packet, const WifiMacHeader & header)
       case WifiMeshActionHeader::PATH_ERROR:
         {
           IePerr perr;
-          m_stats.recvPerr ++;
+          m_stats.rxPerr ++;
           packet->RemoveHeader (perr);
           m_protocol->ReceivePerr (perr, header.GetAddr2 (), m_ifIndex, header.GetAddr3 ());
           return false;
@@ -146,8 +148,8 @@ HwmpMacPlugin::UpdateOutcomingFrame (Ptr<Packet> packet, WifiMacHeader & header,
      //do it this way to silence compiler
      NS_ASSERT (false);
   }
-  m_stats.sentData ++;
-  m_stats.sentDataBytes += packet->GetSize ();
+  m_stats.txData ++;
+  m_stats.txDataBytes += packet->GetSize ();
   MeshHeader meshHdr;
   meshHdr.SetMeshSeqno(tag.GetSeqno());
   meshHdr.SetMeshTtl(tag.GetTtl());
@@ -213,9 +215,9 @@ HwmpMacPlugin::SendOnePreq ()
   for(std::vector<Mac48Address>::const_iterator i = receivers.begin (); i != receivers.end (); i ++)
   {
     hdr.SetAddr1 (*i);
-    m_stats.sentPreq ++;
-    m_stats.sentMgt ++;
-    m_stats.sentMgtBytes += packet->GetSize ();
+    m_stats.txPreq ++;
+    m_stats.txMgt ++;
+    m_stats.txMgtBytes += packet->GetSize ();
     m_parent->SendManagementFrame(packet, hdr);
   }
   //erase queue
@@ -252,9 +254,9 @@ HwmpMacPlugin::SendOnePerr()
   for(std::vector<Mac48Address>::const_iterator i = m_myPerr.receivers.begin (); i != m_myPerr.receivers.end (); i ++)
   {
     hdr.SetAddr1 (*i);
-    m_stats.sentPerr ++;
-    m_stats.sentMgt ++;
-    m_stats.sentMgtBytes += packet->GetSize ();
+    m_stats.txPerr ++;
+    m_stats.txMgt ++;
+    m_stats.txMgtBytes += packet->GetSize ();
     m_parent->SendManagementFrame(packet, hdr);
   }
   m_myPerr.perr.ResetPerr ();
@@ -281,9 +283,9 @@ HwmpMacPlugin::SendPrep (IePrep prep, Mac48Address receiver)
   hdr.SetAddr2 (m_parent->GetAddress ());
   hdr.SetAddr3 (m_protocol->GetAddress ());
   //Send Management frame
-  m_stats.sentPrep ++;
-  m_stats.sentMgt ++;
-  m_stats.sentMgtBytes += packet->GetSize ();
+  m_stats.txPrep ++;
+  m_stats.txMgt ++;
+  m_stats.txMgtBytes += packet->GetSize ();
   m_parent->SendManagementFrame(packet, hdr);
 }
 void
@@ -315,20 +317,20 @@ void
 HwmpMacPlugin::Statistics::Print (std::ostream & os) const
 {
   os << "<Statistics "
-    "sentPreq= \"" << sentPreq << "\"\n"
-    "sentPrep=\"" << sentPrep << "\"\n"
-    "sentPerr=\"" << sentPerr << "\"\n"
-    "recvPreq=\"" << recvPreq << "\"\n"
-    "recvPrep=\"" << recvPrep << "\"\n"
-    "recvPerr=\"" << recvPerr << "\"\n"
-    "sentMgt=\"" << sentMgt << "\"\n"
-    "sentMgtBytes=\"" << (double)sentMgtBytes  / 1024.0 << "K\"\n"
-    "recvMgt=\"" << recvMgt << "\"\n"
-    "recvMgtBytes=\"" << (double)recvMgtBytes / 1204.0 << "K\"\n"
-    "sentData=\"" << sentData << "\"\n"
-    "sentDataBytes=\"" << (double)sentDataBytes / 1024.0 << "K\"\n"
-    "recvData=\"" << recvData << "\"\n"
-    "recvDataBytes=\"" << (double)recvDataBytes / 1024.0 << "K\"/>\n";
+    "txPreq= \"" << txPreq << "\"\n"
+    "txPrep=\"" << txPrep << "\"\n"
+    "txPerr=\"" << txPerr << "\"\n"
+    "rxPreq=\"" << rxPreq << "\"\n"
+    "rxPrep=\"" << rxPrep << "\"\n"
+    "rxPerr=\"" << rxPerr << "\"\n"
+    "txMgt=\"" << txMgt << "\"\n"
+    "txMgtBytes=\"" << (double)txMgtBytes  / 1024.0 << "K\"\n"
+    "rxMgt=\"" << rxMgt << "\"\n"
+    "rxMgtBytes=\"" << (double)rxMgtBytes / 1204.0 << "K\"\n"
+    "txData=\"" << txData << "\"\n"
+    "txDataBytes=\"" << (double)txDataBytes / 1024.0 << "K\"\n"
+    "rxData=\"" << rxData << "\"\n"
+    "rxDataBytes=\"" << (double)rxDataBytes / 1024.0 << "K\"/>\n";
 }
 void
 HwmpMacPlugin::Report (std::ostream & os) const

src/devices/mesh/dot11s/hwmp-mac-plugin.h

@@ -104,36 +104,36 @@ private:
   ///\{
   struct Statistics
   {
-    uint16_t sentPreq;
-    uint16_t recvPreq;
-    uint16_t sentPrep;
-    uint16_t recvPrep;
-    uint16_t sentPerr;
-    uint16_t recvPerr;
-    uint16_t sentMgt;
-    uint32_t sentMgtBytes;
-    uint16_t recvMgt;
-    uint32_t recvMgtBytes;
-    uint16_t sentData;
-    uint32_t sentDataBytes;
-    uint16_t recvData;
-    uint32_t recvDataBytes;
+    uint16_t txPreq;
+    uint16_t rxPreq;
+    uint16_t txPrep;
+    uint16_t rxPrep;
+    uint16_t txPerr;
+    uint16_t rxPerr;
+    uint16_t txMgt;
+    uint32_t txMgtBytes;
+    uint16_t rxMgt;
+    uint32_t rxMgtBytes;
+    uint16_t txData;
+    uint32_t txDataBytes;
+    uint16_t rxData;
+    uint32_t rxDataBytes;
     void Print (std::ostream & os) const;
     Statistics () : 
-      sentPreq (0), 
-      recvPreq (0),
-      sentPrep (0),
-      recvPrep (0),
-      sentPerr (0),
-      recvPerr (0),
-      sentMgt (0),
-      sentMgtBytes (0),
-      recvMgt (0),
-      recvMgtBytes (0),
-      sentData (0),
-      sentDataBytes (0),
-      recvData (0),
-      recvDataBytes (0)
+      txPreq (0), 
+      rxPreq (0),
+      txPrep (0),
+      rxPrep (0),
+      txPerr (0),
+      rxPerr (0),
+      txMgt (0),
+      txMgtBytes (0),
+      rxMgt (0),
+      rxMgtBytes (0),
+      txData (0),
+      txDataBytes (0),
+      rxData (0),
+      rxDataBytes (0)
       {}
   };
   Statistics m_stats;

src/devices/mesh/dot11s/hwmp-protocol.cc

@@ -210,7 +210,7 @@ HwmpProtocol::RequestRoute (
     //Filling TAG:
     if(destination == Mac48Address::GetBroadcast ())
       tag.SetSeqno (m_dataSeqno++);
-    tag.SetTtl (m_maxTtl+1);
+    tag.SetTtl (m_maxTtl);
   }
   else
   {
@@ -219,14 +219,17 @@ HwmpProtocol::RequestRoute (
       NS_ASSERT(false);
       return false;
     }
-    if (tag.GetTtl () == 0)
-      return false;
     tag.DecrementTtl ();
+    if (tag.GetTtl () == 0)
+    {
+      m_stats.droppedTtl ++;
+      return false;
+    }
   }
   if (destination == Mac48Address::GetBroadcast ())
   {
-    m_stats.forwardedBroadcast ++;
-    m_stats.forwardedBytes += packet->GetSize ();
+    m_stats.txBroadcast ++;
+    m_stats.txBytes += packet->GetSize ();
     //channel IDs where we have already sent broadcast:
     std::vector<uint16_t> channels;
     for(HwmpPluginMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin ++)
@@ -270,8 +273,8 @@ HwmpProtocol::ForwardUnicast(uint32_t  sourceIface, const Mac48Address source, c
   {
     //reply immediately:
     routeReply (true, packet, source, destination, protocolType, result.ifIndex);
-    m_stats.forwardedUnicast ++;
-    m_stats.forwardedBytes += packet->GetSize ();
+    m_stats.txUnicast ++;
+    m_stats.txBytes += packet->GetSize ();
     return true;
   }
   if (sourceIface != GetMeshPoint ()->GetIfIndex())
@@ -633,6 +636,8 @@ HwmpProtocol::SetNeighboursCallback(Callback<std::vector<Mac48Address>, uint32_t
 bool
 HwmpProtocol::DropDataFrame(uint32_t seqno, Mac48Address source)
 {
+  if(source == GetAddress ())
+    return true;
   std::map<Mac48Address, uint32_t,std::less<Mac48Address> >::const_iterator i = m_lastDataSeqno.find (source);
   if (i == m_lastDataSeqno.end ())
     m_lastDataSeqno[source] = seqno;
@@ -766,8 +771,8 @@ HwmpProtocol::ReactivePathResolved (Mac48Address dst)
     packet.pkt->RemovePacketTag(tag);
     tag.SetAddress (result.retransmitter);
     packet.pkt->AddPacketTag (tag);
-    m_stats.forwardedUnicast ++;
-    m_stats.forwardedBytes += packet.pkt->GetSize ();
+    m_stats.txUnicast ++;
+    m_stats.txBytes += packet.pkt->GetSize ();
     packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
   }
 }
@@ -788,8 +793,8 @@ HwmpProtocol::ProactivePathResolved ()
     NS_ASSERT (packet.pkt->PeekPacketTag(tag));
     tag.SetAddress (result.retransmitter);
     packet.pkt->AddPacketTag (tag);
-    m_stats.forwardedUnicast ++;
-    m_stats.forwardedBytes += packet.pkt->GetSize ();
+    m_stats.txUnicast ++;
+    m_stats.txBytes += packet.pkt->GetSize ();
     packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
   }
 }
@@ -940,9 +945,10 @@ HwmpProtocol::GetAddress ()
 void HwmpProtocol::Statistics::Print (std::ostream & os) const
 {
   os << "<Statistics "
-    "forwardedUnicast=\"" << forwardedUnicast << "\" "
-    "forwardedBroadcast=\"" << forwardedBroadcast << "\" "
-    "forwardedBytes=\"" << forwardedBytes / 1024 << "K\" "
+    "txUnicast=\"" << txUnicast << "\" "
+    "txBroadcast=\"" << txBroadcast << "\" "
+    "txBytes=\"" << txBytes / 1024 << "K\" "
+    "droppedTtl=\"" << droppedTtl << "\" "
     "totalQueued=\"" << totalQueued << "\" "
     "totalDropped=\"" << totalDropped << "\"/>\n";
 }

src/devices/mesh/dot11s/hwmp-protocol.h

@@ -142,14 +142,15 @@ private:
   ///\{
   struct Statistics
   {
-    uint16_t forwardedUnicast;
-    uint16_t forwardedBroadcast;
-    uint32_t forwardedBytes;
+    uint16_t txUnicast;
+    uint16_t txBroadcast;
+    uint32_t txBytes;
+    uint16_t droppedTtl;
     uint16_t totalQueued;
     uint16_t totalDropped;
 
     void Print (std::ostream & os) const;
-    Statistics () : forwardedUnicast (0), forwardedBroadcast (0), forwardedBytes (0), totalQueued (0), totalDropped (0) {}
+    Statistics () : txUnicast (0), txBroadcast (0), txBytes (0), droppedTtl (0), totalQueued (0), totalDropped (0) {}
   };
   Statistics m_stats;
   ///\}

src/devices/mesh/dot11s/peer-link.cc

@@ -580,10 +580,10 @@ PeerLink::Report (std::ostream & os) const
     "peerInterfaceAddress=\"" << m_peerAddress << "\"\n"
     "peerMeshPointAddress=\"" << m_peerMeshPointAddress << "\"\n"
     "metricOfTheLink=\"" << m_macPlugin->GetLinkMetric(m_peerAddress) << "\"\n"
-    "m_lastBeacon=\"" << m_lastBeacon.GetMilliSeconds () << "ms\"\n"
-    "m_localLinkId=\"" << m_localLinkId << "\"\n"
-    "m_peerLinkId=\"" << m_peerLinkId << "\"\n"
-    "m_assocId=\"" << m_assocId << "\"\n"
+    "lastBeacon=\"" << m_lastBeacon.GetMilliSeconds () << "ms\"\n"
+    "localLinkId=\"" << m_localLinkId << "\"\n"
+    "peerLinkId=\"" << m_peerLinkId << "\"\n"
+    "assocId=\"" << m_assocId << "\"\n"
     "dot11MeshMaxRetries=\"" << m_dot11MeshMaxRetries << "\"\n"
     "dot11MeshRetryTimeout=\"" << m_dot11MeshRetryTimeout.GetMilliSeconds () << "ms\"\n"
     "dot11MeshHoldingTimeout=\"" << m_dot11MeshHoldingTimeout.GetMilliSeconds () << "ms\"\n"

src/devices/mesh/dot11s/peer-management-plugin.cc

@@ -84,8 +84,8 @@ PeerManagerMacPlugin::Receive (Ptr<Packet> const_packet, const WifiMacHeader & h
     // If can not handle - just return;
     if(actionHdr.GetCategory () != WifiMeshActionHeader::MESH_PEERING_MGT)
       return m_protocol->IsActiveLink(m_ifIndex,header.GetAddr2());
-    m_stats.recvMgt ++;
-    m_stats.recvMgtBytes += packet->GetSize ();
+    m_stats.rxMgt ++;
+    m_stats.rxMgtBytes += packet->GetSize ();
     Mac48Address peerAddress = header.GetAddr2 ();
     Mac48Address peerMpAddress = header.GetAddr3 ();
     PeerLinkFrameStart::PlinkFrameStartFields fields;
@@ -121,17 +121,17 @@ PeerManagerMacPlugin::Receive (Ptr<Packet> const_packet, const WifiMacHeader & h
     //Check taht frame subtype corresponds peer link subtype
     if(peerElement.SubtypeIsOpen ())
     {
-      m_stats.recvOpen ++;
+      m_stats.rxOpen ++;
       NS_ASSERT(actionValue.peerLink == WifiMeshActionHeader::PEER_LINK_OPEN);
     }
     if(peerElement.SubtypeIsConfirm ())
     {
-      m_stats.recvConfirm ++;
+      m_stats.rxConfirm ++;
       NS_ASSERT(actionValue.peerLink == WifiMeshActionHeader::PEER_LINK_CONFIRM);
     }
     if(peerElement.SubtypeIsClose ())
     {
-      m_stats.recvClose ++;
+      m_stats.rxClose ++;
       NS_ASSERT(actionValue.peerLink == WifiMeshActionHeader::PEER_LINK_CLOSE);
     }
     //Deliver Peer link management frame to protocol:
@@ -197,7 +197,7 @@ PeerManagerMacPlugin::SendPeerLinkManagementFrame(
   WifiMeshActionHeader actionHdr;
   if (peerElement.SubtypeIsOpen ())
     {
-      m_stats.sendOpen ++;
+      m_stats.txOpen ++;
       WifiMeshActionHeader::ActionValue action;
       action.peerLink = WifiMeshActionHeader::PEER_LINK_OPEN;
       fields.subtype = WifiMeshActionHeader::PEER_LINK_OPEN;
@@ -205,7 +205,7 @@ PeerManagerMacPlugin::SendPeerLinkManagementFrame(
     }
   if (peerElement.SubtypeIsConfirm ())
     {
-      m_stats.sendConfirm ++;
+      m_stats.txConfirm ++;
       WifiMeshActionHeader::ActionValue action;
       action.peerLink = WifiMeshActionHeader::PEER_LINK_CONFIRM;
       fields.aid = aid;
@@ -214,7 +214,7 @@ PeerManagerMacPlugin::SendPeerLinkManagementFrame(
     }
   if (peerElement.SubtypeIsClose ())
     {
-      m_stats.sendClose ++;
+      m_stats.txClose ++;
       WifiMeshActionHeader::ActionValue action;
       action.peerLink = WifiMeshActionHeader::PEER_LINK_CLOSE;
       fields.subtype = WifiMeshActionHeader::PEER_LINK_CLOSE;
@@ -224,8 +224,8 @@ PeerManagerMacPlugin::SendPeerLinkManagementFrame(
   plinkFrame.SetPlinkFrameStart(fields);
   packet->AddHeader (plinkFrame);
   packet->AddHeader (actionHdr);
-  m_stats.sentMgt ++;
-  m_stats.sentMgtBytes += packet->GetSize ();
+  m_stats.txMgt ++;
+  m_stats.txMgtBytes += packet->GetSize ();
   // Wifi Mac header:
   WifiMacHeader hdr;
   hdr.SetAction ();
@@ -261,18 +261,18 @@ PeerManagerMacPlugin::SetBeaconShift(Time shift)
   m_parent->ShiftTbtt (shift);
 }
 PeerManagerMacPlugin::Statistics::Statistics () :
-  sendOpen (0),
-  sendConfirm (0),
-  sendClose (0),
-  recvOpen (0),
-  recvConfirm (0),
-  recvClose (0),
+  txOpen (0),
+  txConfirm (0),
+  txClose (0),
+  rxOpen (0),
+  rxConfirm (0),
+  rxClose (0),
   dropped (0),
   brokenMgt (0),
-  sentMgt (0),
-  sentMgtBytes (0),
-  recvMgt (0),
-  recvMgtBytes (0),
+  txMgt (0),
+  txMgtBytes (0),
+  rxMgt (0),
+  rxMgtBytes (0),
   beaconShift (0)
 {
 }
@@ -280,18 +280,18 @@ void
 PeerManagerMacPlugin::Statistics::Print (std::ostream & os) const
 {
   os << "<Statistics "
-    "sendOpen=\"" << sendOpen << "\"\n"
-    "sendConfirm=\"" << sendConfirm << "\"\n"
-    "sendClose=\"" << sendClose << "\"\n"
-    "recvOpen=\"" << recvOpen << "\"\n"
-    "recvConfirm=\"" << recvConfirm << "\"\n"
-    "recvClose=\"" << recvClose << "\"\n"
+    "txOpen=\"" << txOpen << "\"\n"
+    "txConfirm=\"" << txConfirm << "\"\n"
+    "txClose=\"" << txClose << "\"\n"
+    "rxOpen=\"" << rxOpen << "\"\n"
+    "rxConfirm=\"" << rxConfirm << "\"\n"
+    "rxClose=\"" << rxClose << "\"\n"
     "dropped=\"" << dropped << "\"\n"
     "brokenMgt=\"" << brokenMgt << "\"\n"
-    "sentMgt=\"" << sentMgt << "\"\n"
-    "sentMgtBytes=\"" << (double)sentMgtBytes /1024.0 << "\"\n"
-    "recvMgt=\"" << recvMgt << "\"\n"
-    "recvMgtBytes=\"" << (double)recvMgtBytes / 1024.0 << "K\"\n"
+    "txMgt=\"" << txMgt << "\"\n"
+    "txMgtBytes=\"" << (double)txMgtBytes /1024.0 << "\"\n"
+    "rxMgt=\"" << rxMgt << "\"\n"
+    "rxMgtBytes=\"" << (double)rxMgtBytes / 1024.0 << "K\"\n"
     "beaconShift=\"" << beaconShift << "\"/>\n";
 }
 void

src/devices/mesh/dot11s/peer-management-plugin.h

@@ -105,18 +105,18 @@ private:
   ///\}
   //Keeps statistics
   struct Statistics {
-    uint16_t sendOpen;
-    uint16_t sendConfirm;
-    uint16_t sendClose;
-    uint16_t recvOpen;
-    uint16_t recvConfirm;
-    uint16_t recvClose;
+    uint16_t txOpen;
+    uint16_t txConfirm;
+    uint16_t txClose;
+    uint16_t rxOpen;
+    uint16_t rxConfirm;
+    uint16_t rxClose;
     uint16_t dropped;
     uint16_t brokenMgt;
-    uint16_t sentMgt;
-    uint32_t sentMgtBytes;
-    uint16_t recvMgt;
-    uint32_t recvMgtBytes;
+    uint16_t txMgt;
+    uint32_t txMgtBytes;
+    uint16_t rxMgt;
+    uint32_t rxMgtBytes;
     uint16_t beaconShift;
     
     Statistics ();

src/devices/mesh/mesh-wifi-interface-mac.cc

@@ -643,11 +643,11 @@ void
 MeshWifiInterfaceMac::Statistics::Print (std::ostream & os) const
 {
   os << "<Statistics "
-    "recvBeacons=\"" << recvBeacons << "\" "
-    "sentFrames=\"" << sentFrames << "\" "
-    "sentBytes=\"" << (double)sentBytes / 1024.0 << "K\" "
-    "recvFrames=\"" << recvFrames << "\" "
-    "recvBytes=\"" << (double)recvBytes / 1024.0 << "K\"/>\n";
+    "rxBeacons=\"" << recvBeacons << "\" "
+    "txFrames=\"" << sentFrames << "\" "
+    "txBytes=\"" << (double)sentBytes / 1024.0 << "K\" "
+    "rxFrames=\"" << recvFrames << "\" "
+    "rxBytes=\"" << (double)recvBytes / 1024.0 << "K\"/>\n";
 }
 void
 MeshWifiInterfaceMac::Report (std::ostream & os) const