Attachment #1721 for bug #938

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

(-)a/src/flow-monitor/helper/flow-monitor-helper.h (-15 / +35 lines)

Lines 31-68	Link Here

class AttributeValue;

class AttributeValue;

class Ipv4FlowClassifier;

class Ipv4FlowClassifier;

/// \brief Helper to enable IPv4 flow monitoring on a set of Nodes

/**

 * \ingroup flow-monitor

 * \brief Helper to enable IPv4 flow monitoring on a set of Nodes

*/

class FlowMonitorHelper

class FlowMonitorHelper

public:

public:

  /// \brief Construct a FlowMonitorHelper class which makes it easier to

  /// configure and use the FlowMonitor

  FlowMonitorHelper ();

  FlowMonitorHelper ();

  /// \brief Dispose of objects allocated by the helper

  ~FlowMonitorHelper ();

  ~FlowMonitorHelper ();

  /// \brief Set an attribute for the to-be-created FlowMonitor object

/**

   * \brief Set an attribute for the to-be-created FlowMonitor object

   * \param n1 attribute name

   * \param v1 attibute value

*/

  void SetMonitorAttribute (std::string n1, const AttributeValue &v1);

  void SetMonitorAttribute (std::string n1, const AttributeValue &v1);

  /// \brief Enable flow monitoring on a set of nodes

/**

  /// \param nodes A NodeContainer holding the set of nodes to work with.

   * \brief Enable flow monitoring on a set of nodes

   * \param nodes A NodeContainer holding the set of nodes to work with.

   * \returns a pointer to the FlowMonitor object

*/

  Ptr<FlowMonitor> Install (NodeContainer nodes);

  Ptr<FlowMonitor> Install (NodeContainer nodes);

  /// \brief Enable flow monitoring on a single node

/**

  /// \param node A Ptr<Node> to the node on which to enable flow monitoring.

   * \brief Enable flow monitoring on a single node

   * \param node A Ptr<Node> to the node on which to enable flow monitoring.

   * \returns a pointer to the FlowMonitor object

*/

  Ptr<FlowMonitor> Install (Ptr<Node> node);

  Ptr<FlowMonitor> Install (Ptr<Node> node);

  /// \brief Enable flow monitoring on all nodes

/**

   * \brief Enable flow monitoring on all nodes

   * \returns a pointer to the FlowMonitor object

*/

  Ptr<FlowMonitor> InstallAll ();

  Ptr<FlowMonitor> InstallAll ();

  /// \brief Retrieve the FlowMonitor object created by the Install* methods

/**

   * \brief Retrieve the FlowMonitor object created by the Install* methods

   * \returns a pointer to the FlowMonitor object

*/

  Ptr<FlowMonitor> GetMonitor ();

  Ptr<FlowMonitor> GetMonitor ();

  /// \brief Retrieve the FlowClassifier object created by the Install* methods

/**

   * \brief Retrieve the FlowClassifier object created by the Install* methods

   * \returns a pointer to the FlowClassifier object

*/

  Ptr<FlowClassifier> GetClassifier ();

  Ptr<FlowClassifier> GetClassifier ();

private:

private:

  ObjectFactory m_monitorFactory;

  ObjectFactory m_monitorFactory;       //!< Object factory

  Ptr<FlowMonitor> m_flowMonitor;

  Ptr<FlowMonitor> m_flowMonitor;       //!< the FlowMonitor object

  Ptr<FlowClassifier> m_flowClassifier;

  Ptr<FlowClassifier> m_flowClassifier; //!< the FlowClassifier object

};

};

} // namespace ns3

} // namespace ns3





namespace ns3 {

/**
 * \ingroup flow-monitor
 * \brief Abstract identifier of a packet flow
 */
typedef uint32_t FlowId;

/**
 * \ingroup flow-monitor
 * \brief Abstract identifier of a packet within a flow
 */
typedef uint32_t FlowPacketId;


/// \ingroup flow-monitor
/// Provides a method to translate raw packet data into abstract
/// ``flow identifier'' and ``packet identifier'' parameters.  These
/// identifiers are unsigned 32-bit integers that uniquely identify a
/// flow and a packet within that flow, respectively, for the whole

class FlowClassifier : public SimpleRefCount<FlowClassifier>
{
private:
  FlowId m_lastNewFlowId; //!< Last known Flow ID

  /// Defined and not implemented to avoid misuse
  FlowClassifier (FlowClassifier const &);
  /// Defined and not implemented to avoid misuse
  /// \returns
  FlowClassifier& operator= (FlowClassifier const &);

public:

  FlowClassifier ();
  virtual ~FlowClassifier ();

  /// Serializes the results to an std::ostream in XML format
  /// \param os the output stream
  /// \param indent number of spaces to use as base indentation level
  virtual void SerializeToXmlStream (std::ostream &os, int indent) const = 0;

protected:
  /// Returns a new, unique Flow Identifier
  /// \returns a new FlowId
  FlowId GetNewFlowId ();

};

(-)a/src/flow-monitor/model/flow-monitor.h (-27 / +68 lines)

Lines 34-47	Link Here

namespace ns3 {

namespace ns3 {

/// \defgroup flow-monitor Flow Monitor

/**

/// \brief  Collect and store performance data from a simulation

 * \defgroup flow-monitor Flow Monitor

 * \brief  Collect and store performance data from a simulation

*/

/// \ingroup flow-monitor

/**

/// \brief An object that monitors and reports back packet flows observed during a simulation

 * \ingroup flow-monitor

///

 * \brief An object that monitors and reports back packet flows observed during a simulation

/// The FlowMonitor class is responsible forcoordinating efforts

/// regarding probes, and collects end-to-end flowstatistics.

 * The FlowMonitor class is responsible for coordinating efforts

 * regarding probes, and collects end-to-end flow statistics.

*/

class FlowMonitor : public Object

class FlowMonitor : public Object

public:

public:

Lines 81-86	Link Here

    /// as defined in IETF \RFC{3393}.

    /// as defined in IETF \RFC{3393}.

    Time     jitterSum; // jitterCount == rxPackets - 1

    Time     jitterSum; // jitterCount == rxPackets - 1

    /// Contains the last measured delay of a packet

    /// It is stored to measure the packet's Jitter

    Time     lastDelay;

    Time     lastDelay;

    /// Total number of transmitted bytes for the flow

    /// Total number of transmitted bytes for the flow

Lines 127-146	Link Here

127

    /// This attribute also tracks the number of lost bytes.  See also

134

    /// This attribute also tracks the number of lost bytes.  See also

128

    /// comment in attribute packetsDropped.

135

    /// comment in attribute packetsDropped.

129

    std::vector<uint64_t> bytesDropped; // bytesDropped[reasonCode] => number of dropped bytes

136

    std::vector<uint64_t> bytesDropped; // bytesDropped[reasonCode] => number of dropped bytes

130

    Histogram flowInterruptionsHistogram; // histogram of durations of flow interruptions

137

    Histogram flowInterruptionsHistogram; //!< histogram of durations of flow interruptions

131

};

138

};

132

139

133

  // --- basic methods ---

140

  // --- basic methods ---

141

/**

142

   * \brief Get the type ID.

143

   * \return the object TypeId

144

*/

134

  static TypeId GetTypeId ();

145

  static TypeId GetTypeId ();

135

  TypeId GetInstanceTypeId () const;

146

  TypeId GetInstanceTypeId () const;

136

  FlowMonitor ();

147

  FlowMonitor ();

137

148

138

  /// Set the FlowClassifier to be used by the flow monitor.

149

  /// Set the FlowClassifier to be used by the flow monitor.

150

  /// \param classifier the FlowClassifier

139

  void SetFlowClassifier (Ptr<FlowClassifier> classifier);

151

  void SetFlowClassifier (Ptr<FlowClassifier> classifier);

140

152

141

  /// Set the time, counting from the current time, from which to start monitoring flows

153

  /// Set the time, counting from the current time, from which to start monitoring flows.

154

  /// \param time delta time to start

142

  void Start (const Time &time);

155

  void Start (const Time &time);

143

  /// Set the time, counting from the current time, from which to stop monitoring flows

156

  /// Set the time, counting from the current time, from which to stop monitoring flows.

157

  /// \param time delta time to stop

144

  void Stop (const Time &time);

158

  void Stop (const Time &time);

145

  /// Begin monitoring flows *right now*

159

  /// Begin monitoring flows *right now*

146

  void StartRightNow ();

160

  void StartRightNow ();

Lines 151-171	Link Here

151

  /// Register a new FlowProbe that will begin monitoring and report

165

  /// Register a new FlowProbe that will begin monitoring and report

152

  /// events to this monitor.  This method is normally only used by

166

  /// events to this monitor.  This method is normally only used by

153

  /// FlowProbe implementations.

167

  /// FlowProbe implementations.

168

  /// \param probe the probe to add

154

  void AddProbe (Ptr<FlowProbe> probe);

169

  void AddProbe (Ptr<FlowProbe> probe);

155

170

156

  /// FlowProbe implementations are supposed to call this method to

171

  /// FlowProbe implementations are supposed to call this method to

157

  /// report that a new packet was transmitted (but keep in mind the

172

  /// report that a new packet was transmitted (but keep in mind the

158

  /// distinction between a new packet entering the system and a

173

  /// distinction between a new packet entering the system and a

159

  /// packet that is already known and is only being forwarded).

174

  /// packet that is already known and is only being forwarded).

175

  /// \param probe the reporting probe

176

  /// \param flowId flow identification

177

  /// \param packetId Packet ID

178

  /// \param packetSize packet size

160

  void ReportFirstTx (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);

179

  void ReportFirstTx (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);

161

  /// FlowProbe implementations are supposed to call this method to

180

  /// FlowProbe implementations are supposed to call this method to

162

  /// report that a known packet is being forwarded.

181

  /// report that a known packet is being forwarded.

182

  /// \param probe the reporting probe

183

  /// \param flowId flow identification

184

  /// \param packetId Packet ID

185

  /// \param packetSize packet size

163

  void ReportForwarding (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);

186

  void ReportForwarding (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);

164

  /// FlowProbe implementations are supposed to call this method to

187

  /// FlowProbe implementations are supposed to call this method to

165

  /// report that a known packet is being received.

188

  /// report that a known packet is being received.

189

  /// \param probe the reporting probe

190

  /// \param flowId flow identification

191

  /// \param packetId Packet ID

192

  /// \param packetSize packet size

166

  void ReportLastRx (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);

193

  void ReportLastRx (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId, uint32_t packetSize);

167

  /// FlowProbe implementations are supposed to call this method to

194

  /// FlowProbe implementations are supposed to call this method to

168

  /// report that a known packet is being dropped due to some reason.

195

  /// report that a known packet is being dropped due to some reason.

196

  /// \param probe the reporting probe

197

  /// \param flowId flow identification

198

  /// \param packetId Packet ID

199

  /// \param packetSize packet size

200

  /// \param reasonCode drop reason code

169

  void ReportDrop (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId,

201

  void ReportDrop (Ptr<FlowProbe> probe, FlowId flowId, FlowPacketId packetId,

170

                   uint32_t packetSize, uint32_t reasonCode);

202

                   uint32_t packetSize, uint32_t reasonCode);

171

203

Lines 175-180	Link Here

175

  /// Check right now for packets that appear to be lost, considering

207

  /// Check right now for packets that appear to be lost, considering

176

  /// packets as lost if not seen in the network for a time larger

208

  /// packets as lost if not seen in the network for a time larger

177

  /// than maxDelay

209

  /// than maxDelay

210

  /// \param maxDelay the max delay for a packet

178

  void CheckForLostPackets (Time maxDelay);

211

  void CheckForLostPackets (Time maxDelay);

179

212

180

  // --- methods to get the results ---

213

  // --- methods to get the results ---

Lines 182-190	Link Here

182

  /// FlowMonitor has not stopped monitoring yet, you should call

215

  /// FlowMonitor has not stopped monitoring yet, you should call

183

  /// CheckForLostPackets() to make sure all possibly lost packets are

216

  /// CheckForLostPackets() to make sure all possibly lost packets are

184

  /// accounted for.

217

  /// accounted for.

218

  /// \returns the flows statistics

185

  std::map<FlowId, FlowStats> GetFlowStats () const;

219

  std::map<FlowId, FlowStats> GetFlowStats () const;

186

220

187

  /// Get a list of all FlowProbe's associated with this FlowMonitor

221

  /// Get a list of all FlowProbe's associated with this FlowMonitor

222

  /// \returns a list of all the probes

188

  std::vector< Ptr<FlowProbe> > GetAllProbes () const;

223

  std::vector< Ptr<FlowProbe> > GetAllProbes () const;

189

224

190

  /// Serializes the results to an std::ostream in XML format

225

  /// Serializes the results to an std::ostream in XML format

Lines 213-247	Link Here

213

248

214

private:

249

private:

215

250

251

  /// Structure to represent a single tracked packet data

216

  struct TrackedPacket

252

  struct TrackedPacket

217

253

218

    Time firstSeenTime; // absolute time when the packet was first seen by a probe

254

    Time firstSeenTime; //!< absolute time when the packet was first seen by a probe

219

    Time lastSeenTime; // absolute time when the packet was last seen by a probe

255

    Time lastSeenTime; //!< absolute time when the packet was last seen by a probe

220

    uint32_t timesForwarded; // number of times the packet was reportedly forwarded

256

    uint32_t timesForwarded; //!< number of times the packet was reportedly forwarded

221

};

257

};

222

258

223

  // FlowId --> FlowStats

259

  /// FlowId --> FlowStats

224

  std::map<FlowId, FlowStats> m_flowStats;

260

  std::map<FlowId, FlowStats> m_flowStats;

225

261

226

  // (FlowId,PacketId) --> TrackedPacket

262

  /// (FlowId,PacketId) --> TrackedPacket

227

  typedef std::map< std::pair<FlowId, FlowPacketId>, TrackedPacket> TrackedPacketMap;

263

  typedef std::map< std::pair<FlowId, FlowPacketId>, TrackedPacket> TrackedPacketMap;

228

  TrackedPacketMap m_trackedPackets;

264

  TrackedPacketMap m_trackedPackets; //!< Tracked packets

229

  Time m_maxPerHopDelay;

265

  Time m_maxPerHopDelay; //!< Minimum per-hop delay

230

  std::vector< Ptr<FlowProbe> > m_flowProbes;

266

  std::vector< Ptr<FlowProbe> > m_flowProbes; //!< all the FlowProbes

231

267

232

  // note: this is needed only for serialization

268

  // note: this is needed only for serialization

233

  Ptr<FlowClassifier> m_classifier;

269

  Ptr<FlowClassifier> m_classifier; //!< the FlowClassifier

234

270

235

  EventId m_startEvent;

271

  EventId m_startEvent;     //!< Start event

236

  EventId m_stopEvent;

272

  EventId m_stopEvent;      //!< Stop event

237

  bool m_enabled;

273

  bool m_enabled;           //!< FlowMon is enabled

238

  double m_delayBinWidth;

274

  double m_delayBinWidth;   //!< Delay bin width (for histograms)

239

  double m_jitterBinWidth;

275

  double m_jitterBinWidth;  //!< Jitter bin width (for histograms)

240

  double m_packetSizeBinWidth;

276

  double m_packetSizeBinWidth;  //!< packet size bin width (for histograms)

241

  double m_flowInterruptionsBinWidth;

277

  double m_flowInterruptionsBinWidth; //!< Flow interruptions bin width (for histograms)

242

  Time m_flowInterruptionsMinTime;

278

  Time m_flowInterruptionsMinTime; //!< Flow interruptions minimum time

243

279

280

  /// Get the stats for a given flow

281

  /// \param flowId the Flow identification

282

  /// \returns the stats of the flow

244

  FlowStats& GetStatsForFlow (FlowId flowId);

283

  FlowStats& GetStatsForFlow (FlowId flowId);

284

285

  /// Periodic function to check for lost packets and prune statistics

245

  void PeriodicCheckForLostPackets ();

286

  void PeriodicCheckForLostPackets ();

246

};

287

};

247

288




class FlowProbe : public Object
{
private:
  /// Defined and not implemented to avoid misuse
  FlowProbe (FlowProbe const &);
  /// Defined and not implemented to avoid misuse
  /// \returns
  FlowProbe& operator= (FlowProbe const &);

protected:
  /// Constructor
  /// \param flowMonitor the FlowMonitor this probe is associated with
  FlowProbe (Ptr<FlowMonitor> flowMonitor);
  virtual void DoDispose (void);

public:
  virtual ~FlowProbe ();

  /// Structure to hold the statistics of a flow
  struct FlowStats
  {
    FlowStats () : delayFromFirstProbeSum (Seconds (0)), bytes (0), packets (0) {}

    uint32_t packets;
  };

  /// Container to map FlowId -> FlowStats
  typedef std::map<FlowId, FlowStats> Stats;

  /// Add a packet data to the flow stats
  /// \param flowId the flow Identifier
  /// \param packetSize the packet size
  /// \param delayFromFirstProbe packet delay
  void AddPacketStats (FlowId flowId, uint32_t packetSize, Time delayFromFirstProbe);
  /// Add a packet drop data to the flow stats
  /// \param flowId the flow Identifier
  /// \param packetSize the packet size
  /// \param reasonCode reason code for the drop
  void AddPacketDropStats (FlowId flowId, uint32_t packetSize, uint32_t reasonCode);

  /// Get the partial flow statistics stored in this probe.  With this
  /// information you can, for example, find out what is the delay
  /// from the first probe to this one.
  /// \returns the partial flow statistics
  Stats GetStats () const;

  /// Serializes the results to an std::ostream in XML format
  /// \param os the output stream
  /// \param indent number of spaces to use as base indentation level
  /// \param index FlowProbe index
  void SerializeToXmlStream (std::ostream &os, int indent, uint32_t index) const;

protected:
  Ptr<FlowMonitor> m_flowMonitor; //!< the FlowMonitor instance
  Stats m_stats; //!< The flow stats

};






namespace ns3 {

/**
 * \brief Class used to store data and make an histogram of the data frequency.
 *
 * Data are grouped in "bins", i.e., intervals. Each value is assigned to the
 * bin according to the following formula: floor(value/binWidth).
 * Hence, bin \a i groups the data from [i*binWidth, (i+1)binWidth).
 *
 * This class only handles \a positive bins, i.e., it does \a not handles negative data.
 *
 * \todo Add support for negative data.
 *
 * \todo Add method(s) to estimate \f$N\f$, \f$\mu\f$, and \f$s^2\f$ from the histogram,
 * see http://www.dspguide.com/ch2/4.htm
 *
 */
class Histogram
{
public:

  // --- basic methods ---
  /**
   * \brief Constructor
   * \param binWidth width of the histogram "bin".
   */
  Histogram (double binWidth);
  Histogram ();

  // Methods for Getting the Histogram Results
  /**
   * \brief Returns the number of bins in the histogram.
   * \return the number of bins in the histogram
   */
  uint32_t GetNBins () const;
  /**
   * \brief Returns the bin start, i.e., index*binWidth
   * \param index the bin index
   * \return the bin start
   */
  double GetBinStart (uint32_t index);
  /**
   * \brief Returns the bin end, i.e., (index+1)*binWidth
   * \param index the bin index
   * \return the bin start
   */
  double GetBinEnd (uint32_t index);
  /**
   * \brief Returns the bin width.
   *
   * Note that all the bins have the same width.
   *
   * \param index the bin index
   * \return the bin width
   */
  double GetBinWidth (uint32_t index) const;
  /**
   * \brief Set the bin width.
   *
   * Note that you can change the bin width only if the histogram is empty.
   *
   * \param binWidth the bin width
   */
  void SetDefaultBinWidth (double binWidth);
  /**
   * \brief Get the number of data added to the bin.
   * \param index the bin index
   * \return the number of data added to the bin
   */
  uint32_t GetBinCount (uint32_t index);

  // Method for adding values
  /**
   * \brief Add a value to the histogram
   * \param value the value to add
   */
  void AddValue (double value);

  /**
   * \brief Serializes the results to an std::ostream in XML format.
   * \param os the output stream
   * \param indent number of spaces to use as base indentation level
   * \param elementName name of the element to serialize.
   */
  void SerializeToXmlStream (std::ostream &os, int indent, std::string elementName) const;

  /// \todo add method(s) to estimate N, µ, and s² from the histogram,
  /// see http://www.dspguide.com/ch2/4.htm

private:
  std::vector<uint32_t> m_histogram; //!< Histogram data
  double m_binWidth; //!< Bin width
};



(-)a/src/flow-monitor/model/ipv4-flow-classifier.cc (-2 / +2 lines)

Lines 27-34	Link Here

namespace ns3 {

namespace ns3 {

/* see http://www.iana.org/assignments/protocol-numbers */

/* see http://www.iana.org/assignments/protocol-numbers */

const uint8_t TCP_PROT_NUMBER = 6;

const uint8_t TCP_PROT_NUMBER = 6;  //!< TCP Protocol number

const uint8_t UDP_PROT_NUMBER = 17;

const uint8_t UDP_PROT_NUMBER = 17; //!< UDP Protocol number




{
public:

  /// Structure to classify a packet
  struct FiveTuple
  {
    Ipv4Address sourceAddress;      //!< Source address
    Ipv4Address destinationAddress; //!< Destination address
    uint8_t protocol;               //!< Protocol
    uint16_t sourcePort;            //!< Source port
    uint16_t destinationPort;       //!< Destination port
  };

  Ipv4FlowClassifier ();

  /// \brief try to classify the packet into flow-id and packet-id
  /// \return true if the packet was classified, false if not (i.e. it
  /// does not appear to be part of a flow).
  /// \param ipHeader packet's IP header
  /// \param ipPayload packet's IP payload
  /// \param out_flowId packet's FlowId
  /// \param out_packetId packet's identifier
  bool Classify (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload,
                 uint32_t *out_flowId, uint32_t *out_packetId);

  /// Searches for the FiveTuple corresponding to the given flowId
  /// \param flowId the FlowId to search for
  /// \returns the FiveTuple corresponding to flowId
  FiveTuple FindFlow (FlowId flowId) const;

  virtual void SerializeToXmlStream (std::ostream &os, int indent) const;

private:

  /// Map to Flows Identifiers to FlowIds
  std::map<FiveTuple, FlowId> m_flowMap;

};

/**
 * \brief Less than operator.
 *
 * \param t1 the first operand
 * \param t2 the first operand
 * \returns true if the operands are equal
 */
bool operator < (const Ipv4FlowClassifier::FiveTuple &t1, const Ipv4FlowClassifier::FiveTuple &t2);

/**
 * \brief Equal to operator.
 *
 * \param t1 the first operand
 * \param t2 the first operand
 * \returns true if the operands are equal
 */
bool operator == (const Ipv4FlowClassifier::FiveTuple &t1, const Ipv4FlowClassifier::FiveTuple &t2);



(-)a/src/flow-monitor/model/ipv4-flow-probe.cc (-3 / +46 lines)

Lines 37-45	Link Here

// Ipv4FlowProbeTag class implementation //

// Ipv4FlowProbeTag class implementation //

//////////////////////////////////////

//////////////////////////////////////

/**

 * \ingroup flow-monitor

 * \brief Tag used to allow a fast identification of the packet

 * This tag is added by FlowMonitor when a packet is seen for

 * the first time, and it is then used to classify the packet in

 * the following hops.

*/

class Ipv4FlowProbeTag : public Tag

class Ipv4FlowProbeTag : public Tag

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual uint32_t GetSerializedSize (void) const;

Lines 47-63	Link Here

  virtual void Deserialize (TagBuffer buf);

  virtual void Deserialize (TagBuffer buf);

  virtual void Print (std::ostream &os) const;

  virtual void Print (std::ostream &os) const;

  Ipv4FlowProbeTag ();

  Ipv4FlowProbeTag ();

/**

   * \brief Consructor

   * \param flowId the flow identifier

   * \param packetId the packet identifier

   * \param packetSize the packet size

*/

  Ipv4FlowProbeTag (uint32_t flowId, uint32_t packetId, uint32_t packetSize);

  Ipv4FlowProbeTag (uint32_t flowId, uint32_t packetId, uint32_t packetSize);

/**

   * \brief Set the flow identifier

   * \param flowId the flow identifier

*/

  void SetFlowId (uint32_t flowId);

  void SetFlowId (uint32_t flowId);

/**

   * \brief Set the packet identifier

   * \param packetId the packet identifier

*/

  void SetPacketId (uint32_t packetId);

  void SetPacketId (uint32_t packetId);

/**

   * \brief Set the packet size

   * \param packetSize the packet size

*/

  void SetPacketSize (uint32_t packetSize);

  void SetPacketSize (uint32_t packetSize);

/**

   * \brief Set the flow identifier

   * \returns the flow identifier

*/

  uint32_t GetFlowId (void) const;

  uint32_t GetFlowId (void) const;

/**

   * \brief Set the packet identifier

   * \returns the packet identifier

*/

  uint32_t GetPacketId (void) const;

  uint32_t GetPacketId (void) const;

/**

   * \brief Get the packet size

   * \returns the packet size

*/

  uint32_t GetPacketSize (void) const;

  uint32_t GetPacketSize (void) const;

private:

100

private:

  uint32_t m_flowId;

101

  uint32_t m_flowId;      //!< flow identifier

  uint32_t m_packetId;

102

  uint32_t m_packetId;    //!< packet identifier

  uint32_t m_packetSize;

103

  uint32_t m_packetSize;  //!< packet size

104

};

105

};

106

(-)a/src/flow-monitor/model/ipv4-flow-probe.h (-4 / +28 lines)

Lines 30-35	Link Here

class FlowMonitor;

class FlowMonitor;

class Node;

class Node;

/// \ingroup flow-monitor

/// \brief Class that monitors flows at the IPv4 layer of a Node

/// \brief Class that monitors flows at the IPv4 layer of a Node

///

///

/// For each node in the simulation, one instance of the class

/// For each node in the simulation, one instance of the class

Lines 40-45	Link Here

public:

public:

  /// \brief Constructor

  /// \param monitor the FlowMonitor this probe is associated with

  /// \param classifier the Ipv4FlowClassifier this probe is associated with

  /// \param node the Node this probe is associated with

  Ipv4FlowProbe (Ptr<FlowMonitor> monitor, Ptr<Ipv4FlowClassifier> classifier, Ptr<Node> node);

  Ipv4FlowProbe (Ptr<FlowMonitor> monitor, Ptr<Ipv4FlowClassifier> classifier, Ptr<Node> node);

  virtual ~Ipv4FlowProbe ();

  virtual ~Ipv4FlowProbe ();

Lines 65-87	Link Here

    DROP_ROUTE_ERROR,   /**< Route error */

    DROP_ROUTE_ERROR,   /**< Route error */

    DROP_FRAGMENT_TIMEOUT, /**< Fragment timeout exceeded */

    DROP_FRAGMENT_TIMEOUT, /**< Fragment timeout exceeded */

    DROP_INVALID_REASON,

    DROP_INVALID_REASON, /**< Fallback reason (no known reason) */

};

};

protected:

protected:

    virtual void DoDispose (void);

  virtual void DoDispose (void);

private:

private:

  /// Log a packet being sent

  /// \param ipHeader IP header

  /// \param ipPayload IP payload

  /// \param interface outgoing interface

  void SendOutgoingLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);

  void SendOutgoingLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);

  /// Log a packet being forwarded

  /// \param ipHeader IP header

  /// \param ipPayload IP payload

  /// \param interface incoming interface

  void ForwardLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);

  void ForwardLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);

  /// Log a packet being received by the destination

  /// \param ipHeader IP header

  /// \param ipPayload IP payload

  /// \param interface incoming interface

  void ForwardUpLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);

  void ForwardUpLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);

  /// Log a packet being dropped

  /// \param ipHeader IP header

  /// \param ipPayload IP payload

  /// \param reason drop reason

100

  /// \param ipv4 pointer to the IP object dropping the packet

101

  /// \param ifIndex interface index

  void DropLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload,

102

  void DropLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload,

                   Ipv4L3Protocol::DropReason reason, Ptr<Ipv4> ipv4, uint32_t ifIndex);

103

                   Ipv4L3Protocol::DropReason reason, Ptr<Ipv4> ipv4, uint32_t ifIndex);

104

  /// Log a packet being dropped by a queue

105

  /// \param ipPayload IP payload

  void QueueDropLogger (Ptr<const Packet> ipPayload);

106

  void QueueDropLogger (Ptr<const Packet> ipPayload);

107

  Ptr<Ipv4FlowClassifier> m_classifier;

108

  Ptr<Ipv4FlowClassifier> m_classifier; //!< the Ipv4FlowClassifier this probe is associated with

};

109

};

110

111

Return to bug 938