Attachment #805 for bug #854

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

(-)a/src/contrib/flow-monitor/ipv4-flow-probe.cc (-5 / +153 lines)

Lines 25-40	Link Here

#include "ns3/flow-monitor.h"

#include "ns3/flow-monitor.h"

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/pointer.h"

#include "ns3/pointer.h"

#include "ns3/config.h"

#include "ns3/flow-id-tag.h"

#include <sstream>

namespace ns3 {

namespace ns3 {

using namespace std;

NS_LOG_COMPONENT_DEFINE ("Ipv4FlowProbe");

NS_LOG_COMPONENT_DEFINE ("Ipv4FlowProbe");

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

            // FlowProbeTag class implementation //

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

class FlowProbeTag : public Tag

public:

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (TagBuffer buf) const;

  virtual void Deserialize (TagBuffer buf);

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

  FlowProbeTag ();

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

  void SetFlowId (uint32_t flowId);

  void SetPacketId (uint32_t packetId);

  void SetPacketSize (uint32_t packetSize);

  uint32_t GetFlowId (void) const;

  uint32_t GetPacketId (void) const;

  uint32_t GetPacketSize (void) const;

private:

  uint32_t m_flowId;

  uint32_t m_packetId;

  uint32_t m_packetSize;

};

Ipv4FlowProbe::~Ipv4FlowProbe ()

TypeId

FlowProbeTag::GetTypeId (void)

  static TypeId tid = TypeId ("ns3::FlowProbeTag")

    .SetParent<Tag> ()

    .AddConstructor<FlowProbeTag> ()

  return tid;

TypeId

FlowProbeTag::GetInstanceTypeId (void) const

  return GetTypeId ();

uint32_t

FlowProbeTag::GetSerializedSize (void) const

  return 4 + 4 + 4;

void

FlowProbeTag::Serialize (TagBuffer buf) const

  buf.WriteU32 (m_flowId);

  buf.WriteU32 (m_packetId);

  buf.WriteU32 (m_packetSize);

void

FlowProbeTag::Deserialize (TagBuffer buf)

  m_flowId = buf.ReadU32 ();

  m_packetId = buf.ReadU32 ();

  m_packetSize = buf.ReadU32 ();

void

100

FlowProbeTag::Print (std::ostream &os) const

101

102

  os << "FlowId=" << m_flowId;

103

  os << "PacketId=" << m_packetId;

104

  os << "PacketSize=" << m_packetSize;

105

106

FlowProbeTag::FlowProbeTag ()

107

  : Tag ()

108

{}

109

110

FlowProbeTag::FlowProbeTag (uint32_t flowId, uint32_t packetId, uint32_t packetSize)

111

  : Tag (), m_flowId (flowId), m_packetId (packetId), m_packetSize (packetSize)

112

{}

113

114

void

115

FlowProbeTag::SetFlowId (uint32_t id)

116

117

  m_flowId = id;

118

119

void

120

FlowProbeTag::SetPacketId (uint32_t id)

121

122

  m_packetId = id;

123

124

void

125

FlowProbeTag::SetPacketSize (uint32_t size)

126

127

  m_packetSize = size;

128

129

uint32_t

130

FlowProbeTag::GetFlowId (void) const

131

132

  return m_flowId;

133

134

uint32_t

135

FlowProbeTag::GetPacketId (void) const

136

137

  return m_packetId;

138

139

uint32_t

140

FlowProbeTag::GetPacketSize (void) const

141

142

  return m_packetSize;

143

144

145

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

146

            // Ipv4FlowProbe class implementation //

147

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

148

Ipv4FlowProbe::Ipv4FlowProbe (Ptr<FlowMonitor> monitor,

149

Ipv4FlowProbe::Ipv4FlowProbe (Ptr<FlowMonitor> monitor,

                              Ptr<Ipv4FlowClassifier> classifier,

150

                              Ptr<Ipv4FlowClassifier> classifier,

Lines 67-72	Link Here

177

      NS_FATAL_ERROR ("trace fail");

178

      NS_FATAL_ERROR ("trace fail");

179

180

181

  // code copied from point-to-point-helper.cc

182

  std::ostringstream oss;

183

  oss << "/NodeList/" << node->GetId () << "/DeviceList/*/TxQueue/Drop";

184

  Config::ConnectWithoutContext (oss.str (), MakeCallback (&Ipv4FlowProbe::QueueDropLogger, Ptr<Ipv4FlowProbe> (this)));

185

186

void

187

void

Lines 76-86	Link Here

  FlowPacketId packetId;

191

  FlowPacketId packetId;

192

  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))

193

  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))

194

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());

195

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());

      NS_LOG_DEBUG ("ReportFirstTx ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<"); "

196

      NS_LOG_DEBUG ("ReportFirstTx ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<"); "

                    << ipHeader << *ipPayload);

197

                    << ipHeader << *ipPayload);

      m_flowMonitor->ReportFirstTx (this, flowId, packetId, size);

198

      m_flowMonitor->ReportFirstTx (this, flowId, packetId, size);

199

200

      // tag the packet with the flow id and packet id, so that the packet can be identified even

201

      // when Ipv4Header is not accessible at some non-IPv4 protocol layer

202

      FlowProbeTag fTag (flowId, packetId, size);

203

      ipPayload->AddPacketTag (fTag);

204

205

206

Lines 107-112	Link Here

107

227

108

  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))

228

  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))

109

229

230

      // remove the tags that are added by Ipv4FlowProbe::SendOutgoingLogger ()

231

      FlowProbeTag fTag;

232

      bool tagFound = ConstCast<Packet> (ipPayload)->RemovePacketTag (fTag);

233

      NS_ASSERT_MSG (tagFound, "FlowProbeTag is missing");

234

110

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());

235

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());

111

      NS_LOG_DEBUG ("ReportLastRx ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<");");

236

      NS_LOG_DEBUG ("ReportLastRx ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<");");

112

      m_flowMonitor->ReportLastRx (this, flowId, packetId, size);

237

      m_flowMonitor->ReportLastRx (this, flowId, packetId, size);

Lines 140-148	Link Here

140

265

141

  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))

266

  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))

142

267

268

      // remove the tags that are added by Ipv4FlowProbe::SendOutgoingLogger ()

269

      FlowProbeTag fTag;

270

      bool tagFound = ConstCast<Packet> (ipPayload)->RemovePacketTag (fTag);

271

      NS_ASSERT_MSG (tagFound, "FlowProbeTag is missing");

272

143

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());

273

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());

144

      NS_LOG_DEBUG ("Drop ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<", " << reason

274

      NS_LOG_DEBUG ("Drop ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<", " << reason

145

                    << ", destIp=" << ipHeader.GetDestination () << "); "

275

                    << ", destIp=" << ipHeader.GetDestination () << "); "

146

                    << "HDR: " << ipHeader << " PKT: " << *ipPayload);

276

                    << "HDR: " << ipHeader << " PKT: " << *ipPayload);

147

277

148

      DropReason myReason;

278

      DropReason myReason;

Lines 171-177	Link Here

171

301

172

302

173

303

304

void

305

Ipv4FlowProbe::QueueDropLogger (Ptr<const Packet> ipPayload)

306

307

  // remove the tags that are added by Ipv4FlowProbe::SendOutgoingLogger ()

308

  FlowProbeTag fTag;

309

  bool tagFound = ConstCast<Packet> (ipPayload)->RemovePacketTag (fTag);

310

311

  if (tagFound)

312

313

    FlowId flowId = fTag.GetFlowId ();

314

    FlowPacketId packetId = fTag.GetPacketId ();

315

    uint32_t size = fTag.GetPacketSize ();

174

316

317

    NS_LOG_DEBUG ("Drop ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<", " << DROP_QUEUE

318

                  << "); ");

319

320

    m_flowMonitor->ReportDrop (this, flowId, packetId, size, DROP_QUEUE);

321

322

175

323

176

} // namespace ns3

324

} // namespace ns3

177

325




  
public:
  Ipv4FlowProbe (Ptr<FlowMonitor> monitor, Ptr<Ipv4FlowClassifier> classifier, Ptr<Node> node);
  //virtual ~Ipv4FlowProbe ();

  /// \brief enumeration of possible reasons why a packet may be dropped
  enum DropReason 

      DROP_TTL_EXPIRE,      
      /// Packet dropped due to invalid checksum in the IPv4 header
      DROP_BAD_CHECKSUM,
      /// Packet dropped due to queue overflow
      DROP_QUEUE, // TODO: this is not easy to do
      DROP_INVALID_REASON,
    };


  void ForwardUpLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload, uint32_t interface);
  void DropLogger (const Ipv4Header &ipHeader, Ptr<const Packet> ipPayload,
                   Ipv4L3Protocol::DropReason reason, uint32_t ifIndex);
  void QueueDropLogger (Ptr<const Packet> ipPayload);

  Ptr<Ipv4FlowClassifier> m_classifier;
};

Return to bug 854