Attachment #1267 for bug #938

View | Details | Raw Unified | Return to bug 938
Collapse All | Expand All




# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
# by quotes) that should identify the project.

PROJECT_NAME           = "ns-3 "

# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or

# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90

FILE_PATTERNS          = *.h \
                         *.cc
                         node-list.cc

# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.

# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.

EXCLUDE                =
                         src/olsr/model/olsr-repositories.h \
                         src/core/model/high-precision.h \
                         src/core/model/high-precision-128.h \
                         src/core/model/high-precision-double.h

# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
# directories that are symbolic links (a Unix filesystem feature) are excluded

# directories that contain example code fragments that are included (see
# the \include command).

EXAMPLE_PATH           = src/aodv/examples \
                         src/bridge/examples \
                         src/click/examples \
                         src/config-store/examples \
                         src/core/examples \
                         src/csma/examples \
                         src/csma-layout/examples \
                         src/dsdv/examples \
                         src/emu/examples \
                         src/energy/examples \
                         src/flow-monitor/examples \
                         src/internet/examples \
                         src/lte/examples \
                         src/mesh/examples \
                         src/mobility/examples \
                         src/mpi/examples \
                         src/netanim/examples \
                         src/network/examples \
                         src/nix-vector-routing/examples \
                         src/olsr/examples \
                         src/openflow/examples \
                         src/point-to-point/examples \
                         src/propagation/examples \
                         src/spectrum/examples \
                         src/tap-bridge/examples \
                         src/template/examples \
                         src/tools/examples \
                         src/topology-read/examples \
                         src/uan/examples \
                         src/virtual-net-device/examples \
                         src/visualizer/examples \
                         src/wifi/examples \
                         src/wimax/examples

# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp

(-)a/src/core/model/command-line.h (-3 / +9 lines)

Lines 37-45	Link Here

 * CommandLine::AddValue but the most important functionality

 * CommandLine::AddValue but the most important functionality

 * provided by this class is that it can be used to set the

 * provided by this class is that it can be used to set the

 * 'initial value' of every attribute in the system with the

 * 'initial value' of every attribute in the system with the

 * '\--TypeIdName::AttributeName=value' syntax and it can be used

 * \verbatim

 * to set the value of every GlobalValue in the system with

 *   --TypeIdName::AttributeName=value

 * the \--GlobalValueName=value syntax.

 * \endverbatim

 * syntax and it can be used to set the value of every GlobalValue

 * in the system with the

 * \verbatim

 *   --GlobalValueName=value

 * \endverbatim

 * syntax.

*/

*/

class CommandLine

class CommandLine

(-)a/src/core/model/names.cc (-2 / +2 lines)

Lines 463-470	Link Here

463

  NameNode *node = &m_root;

463

  NameNode *node = &m_root;

464

465

//

465

//

466

  // The string <remaining> is now composed entirely of path segments in the

466

  // The string <remaining> is now composed entirely of path segments in

467

  // /Names name space and we have eaten the leading slash. e.g.,

467

  // the /Names name space and we have eaten the leading slash. e.g.,

468

  // remaining = "ClientNode/eth0"

468

  // remaining = "ClientNode/eth0"

469

//

469

//

470

  // The start of the search is always at the root of the name space.

470

  // The start of the search is always at the root of the name space.

(-)a/src/core/model/nstime.h (+2 lines)

Lines 359-364	Link Here

359

360

/**

360

/**

361

   * \param timeUnit the unit of the value to return

361

   * \param timeUnit the unit of the value to return

362

   * \return int64_t time value

362

363

   * Convert the input time into an integer value according to the requested

364

   * Convert the input time into an integer value according to the requested

364

   * time unit.

365

   * time unit.

Lines 390-395	Link Here

390

391

/**

392

/**

392

   * \param timeUnit the unit of the value to return

393

   * \param timeUnit the unit of the value to return

394

   * \return double time value

393

395

394

   * Convert the input time into a floating point value according to the requested

396

   * Convert the input time into a floating point value according to the requested

395

   * time unit.

397

   * time unit.

(-)a/src/core/model/test.h (-1 / +1 lines)

Lines 937-943	Link Here

937

938

public:

938

public:

939

/**

939

/**

940

   * \enum TestType

940

   * \enum Type

941

   * \brief Type of test.

941

   * \brief Type of test.

942

*/

942

*/

943

  enum Type {

943

  enum Type {




public:
  typedef Ipv4RoutingProtocol::UnicastForwardCallback UnicastForwardCallback;
  typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback;
  /// c-tor
  QueueEntry (Ptr<const Packet> pa = 0, Ipv4Header const & h = Ipv4Header (),
              UnicastForwardCallback ucb = UnicastForwardCallback (),
              ErrorCallback ecb = ErrorCallback ())

  {
    return ((m_packet == o.m_packet) && (m_header.GetDestination () == o.m_header.GetDestination ()) && (m_expire == o.m_expire));
  }
  ///\name Fields
  // \{
  UnicastForwardCallback GetUnicastForwardCallback () const
  {

  }
  // \}
private:
  /// Data packet
  Ptr<const Packet> m_packet;
  /// IP header
  Ipv4Header m_header;
  /// Unicast forward callback
  UnicastForwardCallback m_ucb;
  /// Error callback
  ErrorCallback m_ecb;
  /// Expire time for queue entry
  Time m_expire;
};
/**

class PacketQueue
{
public:
  /// Default c-tor
  PacketQueue ()
  {
  }
  /// Push entry in queue, if there is no entry with the same packet and destination address in queue.
  bool Enqueue (QueueEntry & entry);
  /// Return first found (the earliest) entry for given destination
  bool Dequeue (Ipv4Address dst, QueueEntry & entry);
  /// Remove all packets with destination IP address dst
  void DropPacketWithDst (Ipv4Address dst);
  /// Finds whether a packet with destination dst exists in the queue
  bool Find (Ipv4Address dst);
  /// Get count of packets with destination dst in the queue
  uint32_t
  GetCountForPacketsWithDst (Ipv4Address dst);
  /// Number of entries
  uint32_t GetSize ();
  ///\name Fields
  // \{
  uint32_t GetMaxQueueLen () const
  {


private:
  std::vector<QueueEntry> m_queue;
  /// Remove all expired entries
  void Purge ();
  /// Notify that packet is dropped from queue by timeout
  void Drop (QueueEntry en, std::string reason);
  /// The maximum number of packets that we allow a routing protocol to buffer.
  uint32_t m_maxLen;
  /// The maximum number of packets that we allow per destination to buffer.
  uint32_t m_maxLenPerDst;
  /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds.
  Time m_queueTimeout;
  static bool IsEqual (QueueEntry en, const Ipv4Address dst)
  {

(-)a/src/dsdv/model/dsdv-packet.h (-3 / +3 lines)

Lines 98-106	Link Here

    return m_dstSeqNo;

    return m_dstSeqNo;

100

private:

100

private:

101

  Ipv4Address m_dst;     // /< Destination IP Address

101

  Ipv4Address m_dst; ///< Destination IP Address

102

  uint32_t m_hopCount;     // /< Number of Hops

102

  uint32_t m_hopCount; ///< Number of Hops

103

  uint32_t m_dstSeqNo;     // /< Destination Sequence Number

103

  uint32_t m_dstSeqNo; ///< Destination Sequence Number

104

};

104

};

105

static inline std::ostream & operator<< (std::ostream& os, const DsdvHeader & packet)

105

static inline std::ostream & operator<< (std::ostream& os, const DsdvHeader & packet)

106




namespace dsdv {
NS_OBJECT_ENSURE_REGISTERED (RoutingProtocol);

/// UDP Port for DSDV control traffic
const uint32_t RoutingProtocol::DSDV_PORT = 269;

/// Tag used by DSDV implementation
struct DeferredRouteOutputTag : public Tag
{
  /// Positive if output device is fixed in RouteOutput
  int32_t oif;

  DeferredRouteOutputTag (int32_t o = -1)




  GetTypeId (void);
  static const uint32_t DSDV_PORT;

  /// c-tor
  RoutingProtocol ();
  virtual
  ~RoutingProtocol ();
  virtual void
  DoDispose ();

  ///\name From Ipv4RoutingProtocol
  // \{
  Ptr<Ipv4Route> RouteOutput (Ptr<Packet> p, const Ipv4Header &header, Ptr<NetDevice> oif, Socket::SocketErrno &sockerr);
  bool RouteInput (Ptr<const Packet> p, const Ipv4Header &header, Ptr<const NetDevice> idev, UnicastForwardCallback ucb,

  virtual void NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address);
  virtual void SetIpv4 (Ptr<Ipv4> ipv4);
  // \}
  ///\name Methods to handle protocol parameters
  // \{
  void SetEnableBufferFlag (bool f);
  bool GetEnableBufferFlag () const;

  // \}

private:
  ///\name Protocol parameters.
  // \{
  /// Holdtimes is the multiplicative factor of PeriodicUpdateInterval for which the node waits since the last update
  /// before flushing a route from the routing table. If PeriodicUpdateInterval is 8s and Holdtimes is 3, the node
  /// waits for 24s since the last update to flush this route from its routing table.
  uint32_t Holdtimes;
  /// PeriodicUpdateInterval specifies the periodic time interval between which the a node broadcasts
  /// its entire routing table.
  Time m_periodicUpdateInterval;
  /// SettlingTime specifies the time for which a node waits before propagating an update.
  /// It waits for this time interval in hope of receiving an update with a better metric.
  // /\}
  Time m_settlingTime;
  /// Nodes IP address
  Ipv4Address m_mainAddress;
  /// IP protocol
  Ptr<Ipv4> m_ipv4;
  /// Raw socket per each IP interface, map socket -> iface address (IP + mask)
  std::map<Ptr<Socket>, Ipv4InterfaceAddress> m_socketAddresses;
  /// Loopback device used to defer route requests until a route is found
  Ptr<NetDevice> m_lo;
  /// Main Routing table for the node
  RoutingTable m_routingTable;
  /// Advertised Routing table for the node
  RoutingTable m_advRoutingTable;
  /// The maximum number of packets that we allow a routing protocol to buffer.
  uint32_t m_maxQueueLen;
  /// The maximum number of packets that we allow per destination to buffer.
  uint32_t m_maxQueuedPacketsPerDst;
  /// The maximum period of time that a routing protocol is allowed to buffer a packet for.
  Time m_maxQueueTime;
  /// A "drop front on full" queue used by the routing layer to buffer packets to which it does not have a route.
  PacketQueue m_queue;
  /// Flag that is used to enable or disable buffering
  bool EnableBuffering;
  /// Flag that is used to enable or disable Weighted Settling Time
  bool EnableWST;
  /// This is the wighted factor to determine the weighted settling time
  double m_weightedFactor;
  /// This is a flag to enable route aggregation. Route aggregation will aggregate all routes for
  /// 'RouteAggregationTime' from the time an update is received by a node and sends them as a single update .
  bool EnableRouteAggregation;
  /// Parameter that holds the route aggregation time interval
  Time m_routeAggregationTime;
  /// Unicast callback for own packets
  UnicastForwardCallback m_scb;
  /// Error callback for own packets
  ErrorCallback m_ecb;
  // \}

private:
  /// Start protocol operation
  void
  Start ();
  /// Queue packet untill we find a route
  void
  DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);
  /// Look for any queued packets to send them out
  void
  LookForQueuedPackets (void);
  /**

   */
  void
  SendPacketFromQueue (Ipv4Address dst, Ptr<Ipv4Route> route);
  /// Find socket with local interface address iface
  Ptr<Socket>
  FindSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const;
  ///\name Receive dsdv control packets
  // \{
  /// Receive and process dsdv control packet
  void
  RecvDsdv (Ptr<Socket> socket);
  // \}
  void
  Send (Ptr<Ipv4Route>, Ptr<const Packet>, const Ipv4Header &);
  /// Create loopback route for given header
  Ptr<Ipv4Route>
  LoopbackRoute (const Ipv4Header & header, Ptr<NetDevice> oif) const;
  /**

   */
  Time
  GetSettlingTime (Ipv4Address dst);
  /// Sends trigger update from a node
  void
  SendTriggeredUpdate ();
  /// Broadcasts the entire routing table for every PeriodicUpdateInterval
  void
  SendPeriodicUpdate ();
  void
  MergeTriggerPeriodicUpdates ();
  /// Notify that packet is dropped for some reason
  void
  Drop (Ptr<const Packet>, const Ipv4Header &, Socket::SocketErrno);
  /// Timer to trigger periodic updates from a node
  Timer m_periodicUpdateTimer;
  /// Timer used by the trigger updates in case of Weighted Settling Time is used
  Timer m_triggeredExpireTimer;
};





class RoutingTableEntry
{
public:
  /// c-tor
  RoutingTableEntry (Ptr<NetDevice> dev = 0, Ipv4Address dst = Ipv4Address (), u_int32_t m_seqNo = 0,
                     Ipv4InterfaceAddress iface = Ipv4InterfaceAddress (), u_int32_t hops = 0, Ipv4Address nextHop = Ipv4Address (),
                     Time lifetime = Simulator::Now (), Time SettlingTime = Simulator::Now (), bool changedEntries = false);

  Print (Ptr<OutputStreamWrapper> stream) const;

private:
  ///\name Fields
  // \{
  /// Destination Sequence Number
  uint32_t m_seqNo;
  /// Hop Count (number of hops needed to reach destination)
  uint32_t m_hops;
  /**
   * \brief Expiration or deletion time of the route

   *   - output device
   */
  Ptr<Ipv4Route> m_ipv4Route;
  /// Output interface address
  Ipv4InterfaceAddress m_iface;
  /// Routing flags: valid, invalid or in search
  RouteFlags m_flag;
  /// Time for which the node retains an update with changed metric before broadcasting it.
  /// A node does that in hope of receiving a better update.
  Time m_settlingTime;
  /// Flag to show if any of the routing table entries were changed with the routing update.
  uint32_t m_entriesChanged;
  //\}
};

/**

class RoutingTable
{
public:
  /// c-tor
  RoutingTable ();
  /**
   * Add routing table entry if it doesn't yet exist in routing table

  LookupRoute (Ipv4Address id, RoutingTableEntry & rt, bool forRouteInput);
  /**
   * Updating the routing Table with routing table entry rt
   * \param rt routing table entry
   * \return true on success
   */
  bool
  Update (RoutingTableEntry & rt);
  /**
   * Lookup list of addresses for which nxtHp is the next Hop address
   * \param nxtHp nexthop's address for which we want the list of destinations
   * \param dstList is the list that will hold all these destination addresses
   */
  void

   */
  void
  GetListOfAllRoutes (std::map<Ipv4Address, RoutingTableEntry> & allRoutes);
  /// Delete all route from interface with address iface
  void
  DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface);
  /// Delete all entries from routing table
  void
  Clear ()
  {
    m_ipv4AddressEntry.clear ();
  }
  /// Delete all outdated entries if Lifetime is expired
  void
  Purge (std::map<Ipv4Address, RoutingTableEntry> & removedAddresses);
  /// Print routing table
  void
  Print (Ptr<OutputStreamWrapper> stream) const;
  /// Provides the number of routes present in that nodes routing table.
  uint32_t
  RoutingTableSize ();
  /**
  * Add an event for a destination address so that the update to for that destination is sent
  * after the event is completed.
  * \param address destination address for which this event is running.
  * \param id unique eventid that was generated.
  */
  bool
  AddIpv4Event (Ipv4Address address, EventId id);
  /**
  * Clear up the entry from the map after the event is completed
  * \param address destination address for which this event is running.
  * \return true on success
  */
  bool

  /**
  * Force delete an update waiting for settling time to complete as a better update to
  * same destination was received.
  * \param address destination address for which this event is running.
  * \return true on success
  */
  bool

  /**
  * Force delete an update waiting for settling time to complete as a better update to
  * same destination was received.
  * \param address destination address for which this event is running.
  * \return true on finding out that an event is already running for that destination address.
  */
  bool
  ForceDeleteIpv4Event (Ipv4Address address);
  /**
    * Get the EcentId associated with that address.
    * \param address destination address for which this event is running.
    * \return EventId on finding out an event is associated else return NULL.
    */
  EventId
  GetEventId (Ipv4Address address);
  ///\name Handle life time of invalid route
  // \{
  Time Getholddowntime () const
  {

  // \}

private:
  ///\name Fields
  // \{
  /// an entry in the routing table.
  std::map<Ipv4Address, RoutingTableEntry> m_ipv4AddressEntry;
  /// an entry in the event table.
  std::map<Ipv4Address, EventId> m_ipv4Events;
  ///
  Time m_holddownTime;
  // \}
};

(-)a/src/internet/model/ipv4-header.h (-1 / +1 lines)

Lines 111-117	Link Here

111

};

111

};

112

/**

112

/**

113

   * \brief Set ECN Field

113

   * \brief Set ECN Field

114

   * \param ECN Type

114

   * \param ecn ECN Type

115

*/

115

*/

116

  void SetEcn (EcnType ecn);

116

  void SetEcn (EcnType ecn);

117

/**

117

/**

(-)a/src/internet/model/nsc-tcp-socket-impl.cc (-1 / +1 lines)

Lines 136-142	Link Here

136

       * when DeAllocate is called, it will call into

136

       * when DeAllocate is called, it will call into

137

       * Ipv4EndPointDemux::Deallocate which triggers

137

       * Ipv4EndPointDemux::Deallocate which triggers

138

       * a delete of the associated endPoint which triggers

138

       * a delete of the associated endPoint which triggers

139

       * in turn a call to the method ::Destroy below

139

       * in turn a call to the method NscTcpSocketImpl::Destroy below

140

       * will will zero the m_endPoint field.

140

       * will will zero the m_endPoint field.

141

*/

141

*/

142

      NS_ASSERT (m_endPoint != 0);

142

      NS_ASSERT (m_endPoint != 0);

(-)a/src/internet/model/udp-socket-impl.cc (-1 / +1 lines)

Lines 84-90	Link Here

       * when DeAllocate is called, it will call into

       * when DeAllocate is called, it will call into

       * Ipv4EndPointDemux::Deallocate which triggers

       * Ipv4EndPointDemux::Deallocate which triggers

       * a delete of the associated endPoint which triggers

       * a delete of the associated endPoint which triggers

       * in turn a call to the method ::Destroy below

       * in turn a call to the method UdpSocketImpl::Destroy below

       * will will zero the m_endPoint field.

       * will will zero the m_endPoint field.

*/

*/

      NS_ASSERT (m_endPoint != 0);

      NS_ASSERT (m_endPoint != 0);

(-)a/src/mesh/helper/mesh-stack-installer.h (-1 / +2 lines)

Lines 28-34	Link Here

 * \brief Prototype for class, which helps to install MAC-layer

 * \brief Prototype for class, which helps to install MAC-layer

 * routing stack to ns3::MeshPointDevice

 * routing stack to ns3::MeshPointDevice

 * \details You need to create a  MeshPointDevice and attach all

 * You need to create a MeshPointDevice and attach all

 * interfaces to it, than call Install method

 * interfaces to it, than call Install method

*/

*/

class MeshStack : public Object

class MeshStack : public Object




/**
 * \ingroup dot11s
 *
 * \brief Airtime link metric calculator
 *
 * Airtime link metric is defined in 11B.10 of 802.11s Draft D3.0 as:
 *
 * airtime = (O + Bt/r)* (1 + average retry counter), where:
 * - o  -- the PHY dependent channel access which includes frame headers, training sequences,
 * o  -- the PHY dependent channel access which includes frame headers, training sequences,
 *       access protocol frames, etc.
 * - bt -- the test packet length in bits (8192 by default),
 * - r  -- the current bitrate of the packet,
 *
 * Final result is expressed in units of 0.01 Time Unit = 10.24 us (as required by 802.11s draft)
 */

(-)a/src/mesh/model/dot11s/hwmp-tag.h (-1 / +1 lines)

Lines 34-40	Link Here

 * \brief Hwmp tag implements interaction between HWMP

 * \brief Hwmp tag implements interaction between HWMP

 * protocol and MeshWifiMac

 * protocol and MeshWifiMac

 * \details Hwmp tag keeps the following:

 * Hwmp tag keeps the following:

 * 1. When packet is passed from Hwmp to 11sMAC:

 * 1. When packet is passed from Hwmp to 11sMAC:

 *  - retransmitter address,

 *  - retransmitter address,

 *  - TTL value,

 *  - TTL value,

(-)a/src/mesh/model/dot11s/peer-link-frame.h (-3 / +3 lines)

Lines 34-42	Link Here

/**

/**

 * \ingroup dot11s

 * \ingroup dot11s

 * \brief 802.11s Peer link management frame:

 * \brief 802.11s Peer link management frame

 * \details included the following (see chapters 7.4.12.1-7.4.12.3 of

 * 802.11s):

 * Peer link management frame included the following (see chapters 7.4.12.1-7.4.12.3 of 802.11s):

 * - Subtype field

 * - Subtype field

 * - Association ID field

 * - Association ID field

 * - Supported rates

 * - Supported rates




  PeerLink& operator= (const PeerLink &);
  PeerLink (const PeerLink &);

  /// The number of interface I am associated with
  uint32_t m_interface;
  /// pointer to MAC plugin, which is responsible for peer management
  Ptr<PeerManagementProtocolMac> m_macPlugin;
  /// Peer address
  Mac48Address m_peerAddress;
  /// Mesh point address, equal to peer address in case of single
  /// interface mesh point
  Mac48Address m_peerMeshPointAddress;
  /// My ID of this link
  uint16_t m_localLinkId;

  EventId  m_beaconLossTimer;
  uint16_t m_maxBeaconLoss;
  uint16_t m_maxPacketFail;
  // \}
  /// How to report my status change
  SignalStatusCallback m_linkStatusCallback;
};




  PeerManagementProtocolMac (uint32_t interface, Ptr<PeerManagementProtocol> protocol);
  ~PeerManagementProtocolMac ();
  ///\name Inherited from plugin abstract class
  // \{
  void SetParent (Ptr<MeshWifiInterfaceMac> parent);
  bool Receive (Ptr<Packet> packet, const WifiMacHeader & header);
  bool UpdateOutcomingFrame (Ptr<Packet> packet, WifiMacHeader & header, Mac48Address from, Mac48Address to);
  void UpdateBeacon (MeshWifiBeacon & beacon) const;
  // \}
  ///\name Statistics
  // \{
  void Report (std::ostream &) const;
  void ResetStats ();
  uint32_t GetLinkMetric (Mac48Address peerAddress);
  // \}
private:
  PeerManagementProtocolMac& operator= (const PeerManagementProtocolMac &);
  PeerManagementProtocolMac (const PeerManagementProtocolMac &);

  friend class PeerManagementProtocol;
  friend class PeerLink;
  ///\name Create peer link management frames
  // \{
  /**
   * \brief This structure keeps all fields in peer link management frame,
   * which are not subclasses of WifiInformationElement
   */
  struct PlinkFrameStart
  {
    uint8_t subtype;

  Ptr<Packet> CreatePeerLinkOpenFrame ();
  Ptr<Packet> CreatePeerLinkConfirmFrame ();
  Ptr<Packet> CreatePeerLinkCloseFrame ();
  /// Parses the start of the frame, where no WifiInformationElements exist
   * \brief This structure keeps all fields in peer link management frame,
   * which are not subclasses of WifiInformationElement
   */
  /// \name Parses the start of the frame, where there are no
  /// WifiInformationElements exist
  PlinkFrameStart ParsePlinkFrame (Ptr<const Packet> packet);
  // \}
  ///  Closes link when a proper number of successive transmissions have failed
  void TxError (WifiMacHeader const &hdr);
  void TxOk (WifiMacHeader const &hdr);
  /// BCA functionality
  void SetBeaconShift (Time shift);
  void SetPeerManagerProtcol (Ptr<PeerManagementProtocol> protocol);
  void SendPeerLinkManagementFrame (

    IePeerManagement peerElement,
    IeConfiguration meshConfig
    );
  ///\brief debug only, used to print established links
  Mac48Address GetAddress () const;
  ///\name Statistics
  // \{
  struct Statistics
  {
    uint16_t txOpen;

  struct Statistics m_stats;
  ///\}
  ///\name Information about MAC and protocol:
  // \{
  Ptr<MeshWifiInterfaceMac> m_parent;
  uint32_t m_ifIndex;
  Ptr<PeerManagementProtocol> m_protocol;
  // \}
};

} // namespace dot11s




   * \param beaconTiming beacon timing element (needed by BCA)
   */
  void ReceiveBeacon (uint32_t interface, Mac48Address peerAddress, Time beaconInterval, Ptr<IeBeaconTiming> beaconTiming);
  // \}
  /**
   * \brief Methods that handle Peer link management frames
   * interaction:

   * \brief Checks if there is established link
   */
  bool IsActiveLink (uint32_t interface, Mac48Address peerAddress);
  // \}
  ///\name Interface to other protocols (MLME)
  // \{
  /// Set peer link status change callback
  void SetPeerLinkStatusCallback (Callback<void, Mac48Address, Mac48Address, uint32_t, bool> cb);
  /// Find active peer link by my interface and peer interface MAC

  void Report (std::ostream &) const;
  void ResetStats ();
private:
  /**
   * \name Private structures
   * \{
   */
  /// Keeps information about beacon of peer station: beacon interval, association ID, last time we have received a beacon

  typedef std::map<uint32_t, BeaconsOnInterface> BeaconInfoMap;
  ///\brief this vector keeps pointers to MAC-plugins
  typedef std::map<uint32_t, Ptr<PeerManagementProtocolMac> > PeerManagementProtocolMacMap;
  // \}
private:
  PeerManagementProtocol& operator= (const PeerManagementProtocol &);
  PeerManagementProtocol (const PeerManagementProtocol &);

   */
  Time TuToTime (uint32_t x);
  uint32_t TimeToTu (Time x);
  // \}

  /// Aux. method to register open links
  void NotifyLinkOpen (Mac48Address peerMp, Mac48Address peerIface, Mac48Address myIface, uint32_t interface);

  bool m_enableBca;
  /// Beacon can be shifted at [-m_maxBeaconShift; +m_maxBeaconShift] TUs
  uint16_t m_maxBeaconShift;
  /// Last beacon at each interface
  std::map<uint32_t, Time> m_lastBeacon;
  /// Beacon interval at each interface
  std::map<uint32_t, Time> m_beaconInterval;

  /**

  LinkEventCallback m_linkCloseTraceSrc;

  ///\name Statistics:
  // \{
  struct Statistics {
    uint16_t linksTotal;
    uint16_t linksOpened;

    void Print (std::ostream & os) const;
  };
  struct Statistics m_stats;
  // \}
};

} // namespace dot11s

(-)a/src/mesh/model/mesh-wifi-beacon.h (-1 / +1 lines)

Lines 58-64	Link Here

   * \param mpAddress is mesh point address

   * \param mpAddress is mesh point address

*/

*/

  WifiMacHeader CreateHeader (Mac48Address address, Mac48Address mpAddress);

  WifiMacHeader CreateHeader (Mac48Address address, Mac48Address mpAddress);

  ///Returns a beacon interval of wifi beacon

  /// Returns a beacon interval of wifi beacon

  Time GetBeaconInterval () const;

  Time GetBeaconInterval () const;

  /// Create frame = { beacon header + all information elements sorted by ElementId () }

  /// Create frame = { beacon header + all information elements sorted by ElementId () }

  Ptr<Packet> CreatePacket ();

  Ptr<Packet> CreatePacket ();




  virtual ~MeshWifiInterfaceMac ();

  ///\name Inherited from WifiMac
  // \{
  virtual void  Enqueue (Ptr<const Packet> packet, Mac48Address to, Mac48Address from);
  virtual void  Enqueue (Ptr<const Packet> packet, Mac48Address to);
  virtual bool  SupportsSendFrom () const;
  virtual void  SetLinkUpCallback (Callback<void> linkUp);
  // \}
  ///\name Each mesh point interfaces must know the mesh point address
  // \{
  void SetMeshPointAddress (Mac48Address);
  Mac48Address GetMeshPointAddress () const;
  // \}
  ///\name Beacons
  // \{
  /// Set maximum initial random delay before first beacon
  void SetRandomStartDelay (Time interval);
  /// Set interval between two successive beacons

   * \attention User of ShiftTbtt () must take care to not shift it to the past.
   */
  void ShiftTbtt (Time shift);
  // \}

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

  /** \name Channel switching
   *

   *
   * Number of channels to use must be limited elsewhere.
   */
  // \{
  /// Current channel Id
  uint16_t GetFrequencyChannel () const;
  /// Switch channel
  void SwitchFrequencyChannel (uint16_t new_id);
  // \}

  /// To be used by plugins sending management frames.
  void SendManagementFrame (Ptr<Packet> frame, const WifiMacHeader& hdr);

  bool CheckSupportedRates (SupportedRates rates) const;
  /// \return list of supported bitrates
  SupportedRates GetSupportedRates () const;
  ///\name Metric Calculation routines:
  // \{
  void SetLinkMetricCallback (Callback<uint32_t, Mac48Address, Ptr<MeshWifiInterfaceMac> > cb);
  uint32_t GetLinkMetric (Mac48Address peerAddress);
  // \}
  ///\brief Statistics:
  void Report (std::ostream &) const;
  void ResetStats ();

  typedef std::vector<Ptr<MeshWifiInterfaceMacPlugin> > PluginList;

  ///\name Mesh timing intervals
  // \{
  /// Beaconing interval.
  Time m_beaconInterval;
  /// Maximum delay before first beacon
  Time m_randomStart;
  /// Time for the next frame
  Time m_tbtt;
  // \}

  /// Mesh point address
  Mac48Address m_mpAddress;

  PluginList m_plugins;
  Callback<uint32_t, Mac48Address, Ptr<MeshWifiInterfaceMac> > m_linkMetricCallback;
  ///\name Statistics:
  // \{
  struct Statistics
  {
    uint16_t recvBeacons;

    Statistics ();
  };
  Statistics m_stats;
  // \}
  /// Current PHY standard: needed to configure metric
  WifiPhyStandard m_standard;
};




 * were serialized in the byte buffer. The maintenance of metadata is
 * optional and disabled by default. To enable it, you must call
 * Packet::EnablePrinting and this will allow you to get non-empty
 * output from Packet::Print. If you wish to only enable
 * checking of metadata, and do not need any printing capability, you can
 * call Packet::EnableChecking: its runtime cost is lower than
 * Packet::EnablePrinting.
 *
 * - The set of tags contain simulation-specific information which cannot
 * be stored in the packet byte buffer because the protocol headers or trailers

  /**
   * By default, packets do not keep around enough metadata to
   * perform the operations requested by the Print methods. If you
   * want to be able the Packet::Print method, 
   * you need to invoke this method at least once during the 
   * simulation setup and before any packet is created.
   */

(-)a/src/olsr/model/olsr-repositories.h (-2 / +1 lines)

Lines 21-28	Link Here

*/

*/

///

///

/// \file	olsr-repositories.h

/// \brief Here are defined all data structures needed by an OLSR node.

/// \brief	Here are defined all data structures needed by an OLSR node.

///

///

#ifndef OLSR_REPOSITORIES_H

#ifndef OLSR_REPOSITORIES_H






///
/// \brief Implementation of OLSR agent and related classes.
/// \brief	Implementation of OLSR agent and related classes.
///
/// This is the main file of this software because %OLSR's behaviour is
/// implemented here.

                              receiverIfaceAddr, inetSourceAddr.GetIpv4 ());
            }
        }
	
    }

  // After processing all OLSR messages, we must recompute the routing table

  // MPR computation should be done for each interface. See section 8.3.1
  // (RFC 3626) for details.
  MprSet mprSet;
	

  // N is the subset of neighbors of the node, which are
  // neighbor "of the interface I"

          N.push_back (*neighbor);
        }
    }

  // N2 is the set of 2-hop neighbors reachable from "the interface
  // I", excluding:
  // (i)   the nodes only reachable by members of N with willingness WILL_NEVER


  // 2. Calculate D(y), where y is a member of N, for all nodes in N.
  // (we do this later)

  // 3. Add to the MPR set those nodes in N, which are the *only*
  // nodes to provide reachability to a node in N2.
  std::set<Ipv4Address> coveredTwoHopNeighbors;

          twoHopNeigh++;
        }
    }

  // 4. While there exist nodes in N2 which are not covered by at
  // least one node in the MPR set:
  while (N2.begin () != N2.end ())


  // 1. All the entries from the routing table are removed.
  Clear ();

  // 2. The new routing entries are added starting with the
  // symmetric neighbors (h=1) as the destination nodes.
  const NeighborSet &neighborSet = m_state.GetNeighbors ();


  // 4. For each entry in the multiple interface association base
  // where there exists a routing entry such that:
  // R_dest_addr == I_main_addr (of the multiple interface association entry)
  // AND there is no routing entry such that:
  // R_dest_addr == I_iface_addr
  const IfaceAssocSet &ifaceAssocSet = m_state.GetIfaceAssocSet ();
  for (IfaceAssocSet::const_iterator it = ifaceAssocSet.begin ();
       it != ifaceAssocSet.end (); it++)

{
  const olsr::MessageHeader::Tc &tc = msg.GetTc ();
  Time now = Simulator::Now ();

  // 1. If the sender interface of this message is not in the symmetric
  // 1-hop neighborhood of this node, the message MUST be discarded.
  const LinkTuple *link_tuple = m_state.FindSymLinkTuple (senderIface, now);
  if (link_tuple == NULL)
    return;

  // 2. If there exist some tuple in the topology set where:
  //    T_last_addr == originator address AND
  //    T_seq       >  ANSN,

    m_state.FindNewerTopologyTuple (msg.GetOriginatorAddress (), tc.ansn);
  if (topologyTuple != NULL)
    return;

  // 3. All tuples in the topology set where:
  //    T_last_addr == originator address AND
  //    T_seq       <  ANSN
  // MUST be removed from the topology set.
  m_state.EraseOlderTopologyTuples (msg.GetOriginatorAddress (), tc.ansn);


    {
      const Ipv4Address &addr = *i;
      // 4.1. If there exist some tuple in the topology set where:
      //      T_dest_addr == advertised neighbor main address, AND
      //      T_last_addr == originator address,
      // then the holding time of that tuple MUST be set to:
      //      T_time      =  current time + validity time.
      TopologyTuple *topologyTuple =
        m_state.FindTopologyTuple (addr, msg.GetOriginatorAddress ());


        {
          // 4.2. Otherwise, a new tuple MUST be recorded in the topology
          // set where:
          //      T_dest_addr = advertised neighbor main address,
          //      T_last_addr = originator address,
          //      T_seq       = ANSN,
          //      T_time      = current time + validity time.
          TopologyTuple topologyTuple;;
          topologyTuple.destAddr = addr;
          topologyTuple.lastAddr = msg.GetOriginatorAddress ();

                    " the message MUST be discarded.");
      return;
    }

  // 2. For each interface address listed in the MID message
  for (std::vector<Ipv4Address>::const_iterator i = mid.interfaceAddresses.begin ();
       i != mid.interfaceAddresses.end (); i++)

                    " from " << olsrMessage.GetOriginatorAddress () << " because it is duplicated");
      return;
    }

  // If the sender interface address is an interface address
  // of a MPR selector of this node and ttl is greater than 1,
  // the message must be retransmitted

          retransmitted = true;
        }
    }

  // Update duplicate tuple...
  if (duplicated != NULL)
    {


  std::vector<olsr::MessageHeader::Hello::LinkMessage>
  &linkMessages = hello.linkMessages;

  const LinkSet &links = m_state.GetLinks ();
  for (LinkSet::const_iterator link_tuple = links.begin ();
       link_tuple != links.end (); link_tuple++)

///        in HNA messages sent by the node.
///        If this method is called more than once, entries from the old
///        association are deleted before entries from the new one are added.
/// \param routingTable the Ipv4StaticRouting routing table to be associated.
///
void
RoutingProtocol::SetRoutingTableAssociation (Ptr<Ipv4StaticRouting> routingTable)

}

///
/// \brief Updates Link Set according to a new received HELLO message
/// (following RFC 3626 specification). Neighbor Set is also updated if needed.
void
RoutingProtocol::LinkSensing (const olsr::MessageHeader &msg,
                              const olsr::MessageHeader::Hello &hello,

  NS_LOG_DEBUG ("@" << now.GetSeconds () << ": Olsr node " << m_mainAddress
                    << ": LinkSensing(receiverIface=" << receiverIface
                    << ", senderIface=" << senderIface << ") BEGIN");

  NS_ASSERT (msg.GetVTime () > Seconds (0));
  LinkTuple *link_tuple = m_state.FindLinkTuple (senderIface);
  if (link_tuple == NULL)

      NS_LOG_LOGIC ("Existing link tuple already exists => will update it");
      updated = true;
    }

  link_tuple->asymTime = now + msg.GetVTime ();
  for (std::vector<olsr::MessageHeader::Hello::LinkMessage>::const_iterator linkMessage =
         hello.linkMessages.begin ();

}

///
/// \brief Updates the Neighbor Set according to the information contained in
/// a new received HELLO message (following RFC 3626).
void
RoutingProtocol::PopulateNeighborSet (const olsr::MessageHeader &msg,
                                      const olsr::MessageHeader::Hello &hello)



///
/// \brief Updates the 2-hop Neighbor Set according to the information contained
/// in a new received HELLO message (following RFC 3626).
void
RoutingProtocol::PopulateTwoHopNeighborSet (const olsr::MessageHeader &msg,
                                            const olsr::MessageHeader::Hello &hello)

  Time now = Simulator::Now ();

  NS_LOG_DEBUG ("Olsr node " << m_mainAddress << ": PopulateTwoHopNeighborSet BEGIN");

  for (LinkSet::const_iterator link_tuple = m_state.GetLinks ().begin ();
       link_tuple != m_state.GetLinks ().end (); link_tuple++)
    {



///
/// \brief Updates the MPR Selector Set according to the information contained in
/// a new received HELLO message (following RFC 3626).
void
RoutingProtocol::PopulateMprSelectorSet (const olsr::MessageHeader &msg,
                                         const olsr::MessageHeader::Hello &hello)

  NS_LOG_FUNCTION (this);

  Time now = Simulator::Now ();

  typedef std::vector<olsr::MessageHeader::Hello::LinkMessage> LinkMessageVec;
  for (LinkMessageVec::const_iterator linkMessage = hello.linkMessages.begin ();
       linkMessage != hello.linkMessages.end ();


#if 0
///
/// \brief Drops a given packet because it couldn't be delivered to the corresponding
/// destination by the MAC layer. This may cause a neighbor loss, and appropiate
/// actions are then taken.
///
/// \param p the packet which couldn't be delivered by the MAC layer.
///

  double now              = Simulator::Now ();
  struct hdr_ip* ih       = HDR_IP (p);
  struct hdr_cmn* ch      = HDR_CMN (p);

  debug ("%f: Node %d MAC Layer detects a breakage on link to %d\n",
         now,
         OLSR::node_id (ra_addr ()),
         OLSR::node_id (ch->next_hop ()));

  if ((u_int32_t)ih->daddr () == IP_BROADCAST) {
      drop (p, DROP_RTR_MAC_CALLBACK);
      return;
    }

  OLSR_link_tuple* link_tuple = state_.find_link_tuple (ch->next_hop ());
  if (link_tuple != NULL) {
      link_tuple->lost_time () = now + OLSR_NEIGHB_HOLD_TIME;

}

///
/// \brief This function is invoked when a link tuple is updated. Its aim is to
/// also update the corresponding neighbor tuple if it is needed.
///
/// \param tuple the link tuple which has been updated.
///

//         OLSR::node_id(ra_addr()),
//         OLSR::node_id(tuple->neighborMainAddr),
//         ((tuple->status() == OLSR_STATUS_SYM) ? "sym" : "not_sym"));

  m_state.EraseNeighborTuple (tuple);
  IncrementAnsn ();
}


///
/// \brief Deletes the entry whose destination address is given.
/// \param dest address of the destination node.
///
void
RoutingProtocol::RemoveEntry (Ipv4Address const &dest)


///
/// \brief Looks up an entry for the specified destination address.
/// \param dest destination address.
/// \param outEntry output parameter to hold the routing entry result, if fuond
/// \return true if found, false if not found
///
bool
RoutingProtocol::Lookup (Ipv4Address const &dest,

}

///
/// \brief Finds the appropiate entry which must be used in order to forward
/// a data packet to a next hop (given a destination).
///
/// Imagine a routing table like this: [A,B] [B,C] [C,C]; being each pair of the
/// form [dest addr,next-hop addr]. In this case, if this function is invoked with

/// to forward a data packet destined to A. That is, C is a neighbor of this node,
/// but B isn't. This function finds the appropiate neighbor for forwarding a packet.
///
/// \param entry the routing table entry which indicates the destination node
/// we are interested in.
/// \return the appropiate routing table entry which indicates the next
/// hop which must be used for forwarding a data packet, or NULL
/// if there is no such entry.
///
bool
RoutingProtocol::FindSendEntry (RoutingTableEntry const &entry,

///
/// If an entry for the given destination existed, it is deleted and freed.
///
/// \param dest address of the destination node.
/// \param next address of the next hop node.
/// \param iface address of the local interface.
/// \param dist distance to the destination node.
///
void
RoutingProtocol::AddEntry (Ipv4Address const &dest,

#endif  //NS3_LOG_ENABLE
}

} // namespace olsr
} // namespace ns3



(-)a/src/olsr/model/olsr-state.cc (-1 / +1 lines)

Lines 21-27	Link Here

*/

*/

///

///

/// \file	OlsrState.cc

/// \file	olsr-state.cc

/// \brief	Implementation of all functions needed for manipulating the internal

/// \brief	Implementation of all functions needed for manipulating the internal

///		state of an OLSR node.

///		state of an OLSR node.

///

///

(-)a/src/propagation/model/propagation-loss-model.h (-3 / +3 lines)

Lines 56-62	Link Here

/**

/**

   * \brief Enables a chain of loss models to act on the signal

   * \brief Enables a chain of loss models to act on the signal

   * \param The next PropagationLossModel to add to the chain

   * \param next The next PropagationLossModel to add to the chain

   * This method of chaining propagation loss models only works commutatively

   * This method of chaining propagation loss models only works commutatively

   * if the propagation loss of all models in the chain are independent

   * if the propagation loss of all models in the chain are independent

Lines 516-523	Link Here

516

   * \brief Set loss (in dB, positive) between pair of ns-3 objects

516

   * \brief Set loss (in dB, positive) between pair of ns-3 objects

517

   * (typically, nodes).

517

   * (typically, nodes).

518

519

   * \param ma          Source mobility model

519

   * \param a ma          Source mobility model

520

   * \param mb          Destination mobility model

520

   * \param b mb          Destination mobility model

521

   * \param loss        a -> b path loss, positive in dB

521

   * \param loss        a -> b path loss, positive in dB

522

   * \param symmetric   If true (default), both a->b and b->a paths will be affected

522

   * \param symmetric   If true (default), both a->b and b->a paths will be affected

523

*/

523

*/

(-)a/src/spectrum/helper/adhoc-aloha-noack-ideal-phy-helper.h (-5 / +1 lines)

Lines 37-47	Link Here

/**

/**

 * \ingroup spectrum

 * \ingroup spectrum

 * \brief create the AlohaNoackNetDevice

 * create the NetDevice depicted in the figure

 * @image html HdOfdmAlohaNoAck.png

*/

*/

class AdhocAlohaNoackIdealPhyHelper

class AdhocAlohaNoackIdealPhyHelper




  /**
   *
   *
   * @param lhs the base
   * @param rhs the exponent
   *
   * @return each value in base raised to the exponent
   */
  friend SpectrumValue Pow (const SpectrumValue& lhs, double rhs);


  /**
   *
   *
   * @param lhs the base
   * @param rhs the exponent
   *
   * @return the value in base raised to each value in the exponent
   */
  friend SpectrumValue Pow (double lhs, const SpectrumValue& rhs);

  /**
   *

double Norm (const SpectrumValue& x);
double Sum (const SpectrumValue& x);
double Prod (const SpectrumValue& x);
SpectrumValue Pow (const SpectrumValue& lhs, double rhs);
SpectrumValue Pow (double lhs, const SpectrumValue& rhs);
SpectrumValue Log10 (const SpectrumValue& arg);
SpectrumValue Log2 (const SpectrumValue& arg);
SpectrumValue Log (const SpectrumValue& arg);


} // namespace ns3





  NetDeviceContainer Install (NodeContainer c) const;
  /**
   * \param c a set of nodes
   * \param channel a channel to use
   * \param c a set of nodes
   *
   * For each of the input nodes, a new ns3::UanNetDevice is attached
   * to the shared input channel. Each ns3::UanNetDevice is also


  /**
   * \param node a node where to install the uan components
   * \param channel a channel to use
   *
   * Create a default uan stack with:
   * - default channel, ideal propagation and default noise model

(-)a/src/uan/model/uan-phy.h (-1 / +1 lines)

Lines 169-175	Link Here

169

public:

169

public:

170

  static TypeId GetTypeId (void);

170

  static TypeId GetTypeId (void);

171

172

  // / Enum defining possible Phy states

172

  /// Enum defining possible Phy states

173

  enum State

173

  enum State

174

175

    IDLE, CCABUSY, RX, TX, SLEEP

175

    IDLE, CCABUSY, RX, TX, SLEEP

(-)a/src/uan/model/uan-tx-mode.h (-1 / +1 lines)

Lines 200-206	Link Here

200

*/

200

*/

201

std::istream &operator >> (std::istream &is, UanModesList &ml);

201

std::istream &operator >> (std::istream &is, UanModesList &ml);

202

203

///UanModesList is attribute value

203

/// UanModesList is attribute value

204

ATTRIBUTE_HELPER_HEADER (UanModesList);

204

ATTRIBUTE_HELPER_HEADER (UanModesList);

205

206

} // namespace ns3

206

} // namespace ns3

(-)a/src/wifi/model/interference-helper.h (-1 / +1 lines)

Lines 121-127	Link Here

121

122

  double m_noiseFigure; /**< noise figure (linear) */

122

  double m_noiseFigure; /**< noise figure (linear) */

123

  Ptr<ErrorRateModel> m_errorRateModel;

123

  Ptr<ErrorRateModel> m_errorRateModel;

124

  ///Experimental: needed for energy duration calculation

124

  /// Experimental: needed for energy duration calculation

125

  NiChanges m_niChanges;

125

  NiChanges m_niChanges;

126

  double m_firstPower;

126

  double m_firstPower;

127

  bool m_rxing;

127

  bool m_rxing;

(-)a/src/wifi/model/wifi-information-element-vector.h (-1 / +1 lines)

Lines 46-52	Link Here

  WifiInformationElementVector ();

  WifiInformationElementVector ();

  ~WifiInformationElementVector ();

  ~WifiInformationElementVector ();

  ///\name Inherited from Header

  ///\name Inherited from Header

  //\{

  // \{

  static TypeId GetTypeId ();

  static TypeId GetTypeId ();

  TypeId GetInstanceTypeId () const;

  TypeId GetInstanceTypeId () const;

  virtual uint32_t GetSerializedSize () const;

  virtual uint32_t GetSerializedSize () const;




   */
  static WifiMode GetPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble);

  /**
   * 
   * 
   * \param payloadMode the WifiMode use for the transmission of the payload
   * \param preamble the type of preamble
   * 
   * \return the duration of the PLCP header in microseconds
   */

  static uint32_t GetPlcpPreambleDurationMicroSeconds (WifiMode payloadMode, WifiPreamble preamble);

  /** 
   * \param size the number of bytes in the packet to send
   * \param payloadMode the WifiMode use for the transmission of the payload
   * \param preamble the type of preamble 
   * 
   * \return the duration of the payload in microseconds
   */




   * because it resets time of last update.
   */
  double CalculateAveragingCoefficient ();
  /// averaging coefficient depends on the memory time
  Time m_memoryTime;
  /// when last update has occured
  Time m_lastUpdate;
  /// moving percentage of failed frames
  double m_failAvg;
};

/**
 * \ingroup wifi
 * \brief hold a list of per-remote-station state.
 * \ingroup wifi
 *
 * \sa ns3::WifiRemoteStation.
 */




  m_downlinkBursts->push_back (std::make_pair (dlMapIe, burst));
}

/**
 * \brief A DownLink Scheduler for rtPS Flows
 *
 * The DL Scheduler assigns the available bandwidth in the following order:
 * - IR Connections
 * - Broadcast Connections
 * - Basic and Primary Connections
 * - UGS Connections
 * - rtPS Connections
 * - nrtPS Connections
 * - BE Connections
 * All rtPS flows that have packets in the queue can transmit at least one
 * packet, according to the available bandwidth.
 */
void
BSSchedulerRtps::Schedule (void)
{
  /**
   * \brief  A DownLink Scheduler for rtPS Flows
   *
   * The DL Scheduler assigns the available bandwidth in the following order:
   *         - IR Connections
   *         - Broadcast Connections
   *         - Basic and Primary Connections
   *         - UGS Connections
   * - rtPS Connections
   *         - nrtPS Connections
   *         - BE Connections
   * All rtPS flows that have packets in the queue can transmit at least one
   * packet, according to the available bandwidth.
   */

  uint32_t availableSymbols = GetBs ()->GetNrDlSymbols ();


Return to bug 938