From Nsnam
Jump to: navigation, search

Main Page - Current Development - Developer FAQ - Tools - Related Projects - Project Ideas - Summer Projects

Installation - Troubleshooting - User FAQ - HOWTOs - Samples - Models - Education - Contributed Code - Papers

This page describes NS-3 effort aimed for wireless mobile ad hoc (aka mesh) networks simulation.


The ultimate goal is to create a playground for MAC-layer mesh networking protocols simulation and evaluation.

IEEE 802.11s draft protocols will be implemented as a short term goal.

Model & Architecture

Nodes of the mesh network are mesh points. Each mesh point has several dedicated wireless interfaces, working together to stay connected with its neighbors. Operation of the entire mesh network is provided by coordinated work of several layer 2 mesh protocols. This protocols are supposed to implement unicast and multicast routing, neighbor (aka peer) discovery and management, spectrum management, etc. Note that there are many possible ways to solve each of this tasks, see e.g. this overwhelming list of ad-hoc routing protocols. Distinct protocols are supposed to outperform the others in distinct mobility and traffic conditions, network densities and sizes, QoS requirements and so on.

So, the mesh model architecture must support

  1. arbitrary number of interfaces and protocols installed on single mesh point and
  2. relatively simple addition/removal of mesh L2 protocols.

The toplevel view of proposed architecture is shown on the figure below:

Ns3 mesh toplevel.png

From the layer 3 point of view, mesh point (class MeshPointDevice) looks like usual network device. Note, that any other devices can be installed on the same node, e.g. Wifi access point seems to be useful.

From the layer 2 point of view, MeshPointDevice is a multiplexer of several wireless devices (class WifiNetDevice). Each interface has its own "high" MAC (class MeshWifiInterfaceMac) and channel. Instead of implementing all known L2 mesh protocols, MeshWifiInterfaceMac implemenets only basic functions: ad-hoc WiFi MAC + beacon generation and runtime extensions mechanism -- plugins (class MeshWifiInterfaceMacPlugin).

Every mesh L2 protocol (let it be Foo protocol) is implemented by two classes:

  1. class FooMeshL2Protocol is tied to MeshPointDevice and implements station-level protocol logic.
  2. class FooMeshInterfaceMacPlugin is tied to each MeshWifiInterfaceMac and extends its functions to support corresponding protocol.

The interface between FooMeshL2Protocol and FooMeshInterfaceMacPlugin is not restricted here, but it is recommended for MAC-level plugin to parse/make specific management frames and run interface specific state machine, while station level protocol doesn't known frame details but implements protocol logic, global state and MLME.

Next section describes current implementation of this architecture in more details.


Class MeshPointDevice

Mesh point device is the coordinator of all its interfaces and the fixing point for all mesh L2 protocols. All mesh protocols are supposed to be tied with mesh point. MeshPointDevice implements NetDevice interface for layer 3 protocols interaction.

Single routing protocol (subclass of MeshL2RoutingProtocol, see below) must be selected to allow route discovery. All frames will first pass through the routing protocol to resolve route information before forwarding down to interface(s).

Apart of NetDevice interface, MeshPointDevice public interface looks like:

// Interfaces: 

/// Attach new interface to the station. Interface must support 48-bit MAC address and SendFrom method.
void AddInterface (Ptr< NetDevice > iface)
/// Number of interfaces
uint32_t GetNInterfaces () const
/// Interface access
Ptr< NetDevice > GetInterface (uint32_t id) const

// Protocols:

/// Register routing protocol to be used. Protocol must be already installed on this mesh point. 
void SetRoutingProtocol (Ptr< MeshL2RoutingProtocol > protocol)	

Class MeshL2RoutingProtocol

This is an abstract interface for all unicast mesh routing protocols. The async. route request interface is copied from IP routing, MeshL2RoutingProtocol public interface is:

/// Route reply callback. Last uint32_t is interface number to forward packet, or ALL interfaces.
typedef Callback< void, bool, Ptr< Packet >, Mac48Address, Mac48Address, uint16_t, uint32_t > RouteReplyCallback;
/// Request a route
virtual bool RequestRoute (uint32_t sourceIface, 
                           Mac48Address source, Mac48Address destination, 
                           Ptr< Packet > packet, 
                           uint16_t protocolType, 
                           RouteReplyCallback routeReply) = 0;

RequestRoute is supposed to annotate route information as some protocol-specific tag(s) on the packet to send. Then, corresponding MAC plugin (see below) is responsible to read this tag(s) and correctly update frame header.

Classes MeshWifiInterfaceMac and MeshInterfaceMacPlugin

MeshWifiInterfaceMac is a modification of high level of WiFi MAC implementing basic functions inherited from WifiMac, beaconing and plugins. Beacons are periodically sent, beacon send time can be adjusted to avoid beacon collisions.

Each MAC plugin must define three pure virtual methods inherited from MeshInterfaceMacPlugin:

/// Process received frame. \return false if frame should be dropped.
virtual bool Receive (Ptr< Packet > packet, const WifiMacHeader &header) = 0;

/// Update frame before forwarding it down. \return false if frame should be dropped.
virtual bool UpdateOutcomingFrame (Ptr< Packet > packet, WifiMacHeader &header, Mac48Address from, Mac48Address to) const = 0 ;

/// Update beacon before it will be formed and sent.
virtual void UpdateBeacon (MeshWifiBeacon &beacon) const = 0;

Then plugin is installed to the MeshWifiInterfaceMac:

/// Install plugin. TODO return unique ID to allow unregister plugins. 
void InstallPlugin (Ptr< MeshWifiInterfaceMacPlugin > plugin);

and its methods are used in the following way:


When MeshWifiInterfaceMac receives frame, it asks all registered plugins to process it, in pseudocode:

MeshWifiInterfaceMac::Receive (Ptr<Packet> packet, WifiMacHeader const *header)
  for all plugins 
      bool drop = ! plugin->Receive(packet, header);   
      if (drop) return;

  // Forward data up
  if (header->IsData())
    ForwardUp(packet, header->GetAddr4(), header->GetAddr3());


Before forwarding frame down, MeshWifiInterfaceMac asks all registered plugins to update it, in pseudocode:

MeshWifiInterfaceMac::ForwardDown (Ptr<Packet> packet, Mac48Address from, Mac48Address to)
  // 1. Create wifi header. Address 1 is unknwon here. Routing plugin is responsible to correctly set it.
  WifiMacHeader header = CreateHeader(from, to);
  // 2. Filter packet through all installed plugins
  for all plugins {
      bool drop = ! plugin->UpdateOutcomingFrame(packet, header, from, to);
      if (drop) return;  // plugin drops frame
  // 3. Assert that address1 is set. Assert will fail e.g. if there is no installed routing plugin.
  // 4. Queue frame
  Queue(packet, header);


Beacons are supposed to be collectively used by distinct (may be all) protocols. All plugins are invited to add information elements to beacon:

MeshWifiInterfaceMac::SendBeacon ()
  // 1. Create beacon header
  MeshWifiBeacon beacon (GetSsid (), GetSupportedRates (), m_beaconInterval.GetMicroSeconds ());
  // 2. Ask all plugins to add their specific information elements to beacon
  for all plugins
      plugin->UpdateBeacon (beacon);
  // 3. Queue beacon frame
  Queue (beacon.CreatePacket(), beacon.CreateHeader(GetAddress()));
  // 4. Schedule next beacon
  ScheduleNextBeacon ();

Here MeshWifiBeacon is a container of information elements, see IEEE 802.11-2007.

IEEE 802.11s Protocols

Two mesh protocols of 802.11s draft: Peer Management Protocol and Hybrid Wireless Mesh [Routing] Protocol (HWMP) are implemented using the framework described above in the devices/mesh/dot11s module.

Wireshark dissector

Patch to Wireshark 1.0.7, allowing nice 802.11s management frames and headers representation is included -- Media:Wireshark-1.0.7-dot11s.patch.