Attachment #1890 for bug #938

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




 * PcapUserHelperForDevice and AsciiTraceUserHelperForDevice are
 * "mixins".
 */
class PointToPointHelper : public PcapHelperForDevice,
	                   public AsciiTraceHelperForDevice
{
public:
  /**


  /**
   * \param c a set of nodes
   * \return a NetDeviceContainer for nodes
   *
   * This method creates a ns3::PointToPointChannel with the
   * attributes configured by PointToPointHelper::SetChannelAttribute,

  /**
   * \param a first node
   * \param b second node
   * \return a NetDeviceContainer for nodes
   *
   * Saves you from having to construct a temporary NodeContainer. 
   * Also, if MPI is enabled, for distributed simulations, 

  /**
   * \param a first node
   * \param bName name of second node
   * \return a NetDeviceContainer for nodes
   *
   * Saves you from having to construct a temporary NodeContainer.
   */

  /**
   * \param aName Name of first node
   * \param b second node
   * \return a NetDeviceContainer for nodes
   *
   * Saves you from having to construct a temporary NodeContainer.
   */

  /**
   * \param aNode Name of first node
   * \param bNode Name of second node
   * \return a NetDeviceContainer for nodes
   *
   * Saves you from having to construct a temporary NodeContainer.
   */

    Ptr<NetDevice> nd,
    bool explicitFilename);

  ObjectFactory m_queueFactory;         //!< Queue Factory
  ObjectFactory m_channelFactory;       //!< Channel Factory
  ObjectFactory m_remoteChannelFactory; //!< Remote Channel Factory
  ObjectFactory m_deviceFactory;        //!< Device Factory
};

} // namespace ns3

(-)i/src/point-to-point/model/point-to-point-channel.h (-23 / +43 lines)

Lines 43-59 class Packet;	Link Here

 * There are two "wires" in the channel.  The first device connected gets the

 * There are two "wires" in the channel.  The first device connected gets the

 * [0] wire to transmit on.  The second device gets the [1] wire.  There is a

 * [0] wire to transmit on.  The second device gets the [1] wire.  There is a

 * state (IDLE, TRANSMITTING) associated with each wire.

 * state (IDLE, TRANSMITTING) associated with each wire.

 * \see Attach

 * \see TransmitStart

*/

*/

class PointToPointChannel : public Channel

class PointToPointChannel : public Channel

public:

public:

/**

   * \brief Get the TypeId

   * \return The TypeId for this class

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

   * \brief Create a PointToPointChannel

   * \brief Create a PointToPointChannel

   * By default, you get a channel that

   * By default, you get a channel that has an "infitely" fast

   * has zero transmission delay.

   * transmission speed and zero delay.

*/

*/

  PointToPointChannel ();

  PointToPointChannel ();

Lines 78-91 public:	Link Here

*/

*/

  virtual uint32_t GetNDevices (void) const;

  virtual uint32_t GetNDevices (void) const;

/*

/**

   * \brief Get PointToPointNetDevice corresponding to index i on this channel

   * \brief Get PointToPointNetDevice corresponding to index i on this channel

   * \param i Index number of the device requested

   * \param i Index number of the device requested

   * \returns Ptr to PointToPointNetDevice requested

   * \returns Ptr to PointToPointNetDevice requested

*/

*/

  Ptr<PointToPointNetDevice> GetPointToPointDevice (uint32_t i) const;

  Ptr<PointToPointNetDevice> GetPointToPointDevice (uint32_t i) const;

/*

/**

   * \brief Get NetDevice corresponding to index i on this channel

   * \brief Get NetDevice corresponding to index i on this channel

   * \param i Index number of the device requested

   * \param i Index number of the device requested

   * \returns Ptr to NetDevice requested

   * \returns Ptr to NetDevice requested

Lines 93-111 public:	Link Here

  virtual Ptr<NetDevice> GetDevice (uint32_t i) const;

101

  virtual Ptr<NetDevice> GetDevice (uint32_t i) const;

102

protected:

103

protected:

/*

104

/**

   * \brief Get the delay associated with this channel

105

   * \brief Get the delay associated with this channel

   * \returns Time delay

106

   * \returns Time delay

*/

107

*/

100

  Time GetDelay (void) const;

108

  Time GetDelay (void) const;

101

109

102

/*

110

/**

103

   * \brief Check to make sure the link is initialized

111

   * \brief Check to make sure the link is initialized

104

   * \returns true if initialized, asserts otherwise

112

   * \returns true if initialized, asserts otherwise

105

*/

113

*/

106

  bool IsInitialized (void) const;

114

  bool IsInitialized (void) const;

107

115

108

/*

116

/**

109

   * \brief Get the net-device source

117

   * \brief Get the net-device source

110

   * \param i the link requested

118

   * \param i the link requested

111

   * \returns Ptr to PointToPointNetDevice source for the

119

   * \returns Ptr to PointToPointNetDevice source for the

Lines 113-119 protected:	Link Here

113

*/

121

*/

114

  Ptr<PointToPointNetDevice> GetSource (uint32_t i) const;

122

  Ptr<PointToPointNetDevice> GetSource (uint32_t i) const;

115

123

116

/*

124

/**

117

   * \brief Get the net-device destination

125

   * \brief Get the net-device destination

118

   * \param i the link requested

126

   * \param i the link requested

119

   * \returns Ptr to PointToPointNetDevice destination for

127

   * \returns Ptr to PointToPointNetDevice destination for

Lines 122-132 protected:	Link Here

122

  Ptr<PointToPointNetDevice> GetDestination (uint32_t i) const;

130

  Ptr<PointToPointNetDevice> GetDestination (uint32_t i) const;

123

131

124

private:

132

private:

125

  // Each point to point link has exactly two net devices

133

  static const int N_DEVICES = 2; //!< Each point to point link has

126

  static const int N_DEVICES = 2;

134

                                  //   exactly two net devices

127

135

128

  Time          m_delay;

136

  Time          m_delay;    //!< Propagation delay

129

  int32_t       m_nDevices;

137

  int32_t       m_nDevices; //!< Devices of this channel

130

138

131

/**

139

/**

132

   * The trace source for the packet transmission animation events that the

140

   * The trace source for the packet transmission animation events that the

Lines 135-141 private:	Link Here

135

   * net device, receiving net device, transmission time and

143

   * net device, receiving net device, transmission time and

136

   * packet receipt time.

144

   * packet receipt time.

137

145

138

   * @see class CallBackTraceSource

146

   * \see class CallBackTraceSource

139

*/

147

*/

140

  TracedCallback<Ptr<const Packet>, // Packet being transmitted

148

  TracedCallback<Ptr<const Packet>, // Packet being transmitted

141

                 Ptr<NetDevice>,    // Transmitting NetDevice

149

                 Ptr<NetDevice>,    // Transmitting NetDevice

Lines 144-167 private:	Link Here

144

                 Time               // Last bit receive time (relative to now)

152

                 Time               // Last bit receive time (relative to now)

145

                 > m_txrxPointToPoint;

153

                 > m_txrxPointToPoint;

146

154

155

  /** \brief Wire states

156

157

*/

147

  enum WireState

158

  enum WireState

148

159

149

    INITIALIZING,

160

    INITIALIZING, //!< Initializing state

150

    IDLE,

161

    IDLE,         //!< Idle state (no transmission from NetDevice)

151

    TRANSMITTING,

162

    TRANSMITTING, //!< Transmitting state (data being transmitted from

152

    PROPAGATING

163

                  //   NetDevice

164

    PROPAGATING   //!< Propagating state (data is being propagated in the

165

                  //   channel

153

};

166

};

154

167

168

/**

169

   * \brief Wire model for the PointToPointChannel

170

*/

155

  class Link

171

  class Link

156

172

157

public:

173

    public:

174

    /** \brief Create the link, it will be in INITIALIZING state

175

176

*/

158

    Link() : m_state (INITIALIZING), m_src (0), m_dst (0) {}

177

    Link() : m_state (INITIALIZING), m_src (0), m_dst (0) {}

159

    WireState                  m_state;

178

160

    Ptr<PointToPointNetDevice> m_src;

179

    WireState                  m_state; //!< State of the link

161

    Ptr<PointToPointNetDevice> m_dst;

180

    Ptr<PointToPointNetDevice> m_src;   //!< First NetDevice

181

    Ptr<PointToPointNetDevice> m_dst;   //!< Second NetDevice

162

};

182

};

163

183

164

  Link    m_link[N_DEVICES];

184

  Link    m_link[N_DEVICES]; //!< Link model

165

};

185

};

166

186

167

} // namespace ns3

187

} // namespace ns3

(-)i/src/point-to-point/model/point-to-point-net-device.h (-35 / +82 lines)

Lines 39-45 class ErrorModel;	Link Here

/**

/**

 * \defgroup point-to-point Point-To-Point Network Device

 * \defgroup point-to-point Point-To-Point Network Device

 * This section documents the API of the ns-3 point-to-point module. For a generic functional description, please refer to the ns-3 manual.

 * This section documents the API of the ns-3 point-to-point module. For a

 * functional description, please refer to the ns-3 manual here:

 * http://www.nsnam.org/docs/models/html/point-to-point.html

 * Be sure to read the manual BEFORE going down to the API.

*/

*/

/**

/**

Lines 54-63 class ErrorModel;	Link Here

 * Key parameters or objects that can be specified for this device

 * Key parameters or objects that can be specified for this device

 * include a queue, data rate, and interframe transmission gap (the

 * include a queue, data rate, and interframe transmission gap (the

 * propagation delay is set in the PointToPointChannel).

 * propagation delay is set in the PointToPointChannel).

 * \see SetDataRate

 * \see SetInterframeGap

 * \see SetReceiveErrorModel

*/

*/

class PointToPointNetDevice : public NetDevice

class PointToPointNetDevice : public NetDevice

public:

public:

/**

   * \brief Get the TypeId

   * \return The TypeId for this class

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

Lines 81-88 public:	Link Here

   * set in the Attach () method from the corresponding field in the channel

   * set in the Attach () method from the corresponding field in the channel

   * to which the device is attached.  It can be overridden using this method.

   * to which the device is attached.  It can be overridden using this method.

   * @see Attach ()

   * \see Attach ()

   * @param bps the data rate at which this object operates

   * \param bps the data rate at which this object operates

*/

100

*/

  void SetDataRate (DataRate bps);

101

  void SetDataRate (DataRate bps);

102

Lines 90-103 public:	Link Here

   * Set the interframe gap used to separate packets.  The interframe gap

104

   * Set the interframe gap used to separate packets.  The interframe gap

   * defines the minimum space required between packets sent by this device.

105

   * defines the minimum space required between packets sent by this device.

106

   * @param t the interframe gap time

107

   * \param t the interframe gap time

*/

108

*/

  void SetInterframeGap (Time t);

109

  void SetInterframeGap (Time t);

110

/**

111

/**

   * Attach the device to a channel.

112

   * Attach the device to a channel.

113

100

   * @param ch Ptr to the channel to which this object is being attached.

114

   * \param ch Ptr to the channel to which this object is being attached.

115

   * \return true if the operation was successfull (always true actually)

101

*/

116

*/

102

  bool Attach (Ptr<PointToPointChannel> ch);

117

  bool Attach (Ptr<PointToPointChannel> ch);

103

118

Lines 107-122 public:	Link Here

107

   * The PointToPointNetDevice "owns" a queue that implements a queueing

122

   * The PointToPointNetDevice "owns" a queue that implements a queueing

108

   * method such as DropTail or RED.

123

   * method such as DropTail or RED.

109

124

110

   * @see Queue

125

   * \see Queue

111

   * @see DropTailQueue

126

   * \see DropTailQueue

112

   * @param queue Ptr to the new queue.

127

   * \param queue Ptr to the new queue.

113

*/

128

*/

114

  void SetQueue (Ptr<Queue> queue);

129

  void SetQueue (Ptr<Queue> queue);

115

130

116

/**

131

/**

117

   * Get a copy of the attached Queue.

132

   * Get a copy of the attached Queue.

118

133

119

   * @returns Ptr to the queue.

134

   * \returns Ptr to the queue.

120

*/

135

*/

121

  Ptr<Queue> GetQueue (void) const;

136

  Ptr<Queue> GetQueue (void) const;

122

137

Lines 126-133 public:	Link Here

126

   * The PointToPointNetDevice may optionally include an ErrorModel in

141

   * The PointToPointNetDevice may optionally include an ErrorModel in

127

   * the packet receive chain.

142

   * the packet receive chain.

128

143

129

   * @see ErrorModel

144

   * \see ErrorModel

130

   * @param em Ptr to the ErrorModel.

145

   * \param em Ptr to the ErrorModel.

131

*/

146

*/

132

  void SetReceiveErrorModel (Ptr<ErrorModel> em);

147

  void SetReceiveErrorModel (Ptr<ErrorModel> em);

133

148

Lines 139-146 public:	Link Here

139

   * used by the channel to indicate that the last bit of a packet has

154

   * used by the channel to indicate that the last bit of a packet has

140

   * arrived at the device.

155

   * arrived at the device.

141

156

142

   * @see PointToPointChannel

157

   * \see PointToPointChannel

143

   * @param p Ptr to the received packet.

158

   * \param p Ptr to the received packet.

144

*/

159

*/

145

  void Receive (Ptr<Packet> p);

160

  void Receive (Ptr<Packet> p);

146

161

Lines 186-198 public:	Link Here

186

  virtual bool SupportsSendFrom (void) const;

201

  virtual bool SupportsSendFrom (void) const;

187

202

188

protected:

203

protected:

204

/**

205

   * \brief Handler for MPI receive event

206

207

   * \param p Packet received

208

*/

189

  void DoMpiReceive (Ptr<Packet> p);

209

  void DoMpiReceive (Ptr<Packet> p);

190

210

191

private:

211

private:

192

212

193

  PointToPointNetDevice& operator = (const PointToPointNetDevice &);

213

/**

194

  PointToPointNetDevice (const PointToPointNetDevice &);

214

   * \brief Assign operator

215

216

   * The method is private, so it is DISABLED.

217

218

   * \param o Other NetDevice

219

   * \return New instance of the NetDevice

220

*/

221

  PointToPointNetDevice& operator = (const PointToPointNetDevice &o);

195

222

223

/**

224

   * \brief Copy constructor

225

226

   * The method is private, so it is DISABLED.

227

228

   * \param o Other NetDevice

229

*/

230

  PointToPointNetDevice (const PointToPointNetDevice &o);

231

232

/**

233

   * \brief Dispose of the object

234

*/

196

  virtual void DoDispose (void);

235

  virtual void DoDispose (void);

197

236

198

private:

237

private:

Lines 231-240 private:	Link Here

231

   * started sending signals.  An event is scheduled for the time at which

270

   * started sending signals.  An event is scheduled for the time at which

232

   * the bits have been completely transmitted.

271

   * the bits have been completely transmitted.

233

272

234

   * @see PointToPointChannel::TransmitStart ()

273

   * \see PointToPointChannel::TransmitStart ()

235

   * @see TransmitCompleteEvent ()

274

   * \see TransmitCompleteEvent ()

236

   * @param p a reference to the packet to send

275

   * \param p a reference to the packet to send

237

   * @returns true if success, false on failure

276

   * \returns true if success, false on failure

238

*/

277

*/

239

  bool TransmitStart (Ptr<Packet> p);

278

  bool TransmitStart (Ptr<Packet> p);

240

279

Lines 246-251 private:	Link Here

246

*/

285

*/

247

  void TransmitComplete (void);

286

  void TransmitComplete (void);

248

287

288

/**

289

   * \brief Make the link up and running

290

291

   * It calls also the linkChange callback.

292

*/

249

  void NotifyLinkUp (void);

293

  void NotifyLinkUp (void);

250

294

251

/**

295

/**

Lines 258-285 private:	Link Here

258

};

302

};

259

/**

303

/**

260

   * The state of the Net Device transmit state machine.

304

   * The state of the Net Device transmit state machine.

261

   * @see TxMachineState

305

   * \see TxMachineState

262

*/

306

*/

263

  TxMachineState m_txMachineState;

307

  TxMachineState m_txMachineState;

264

308

265

/**

309

/**

266

   * The data rate that the Net Device uses to simulate packet transmission

310

   * The data rate that the Net Device uses to simulate packet transmission

267

   * timing.

311

   * timing.

268

   * @see class DataRate

312

   * \see class DataRate

269

*/

313

*/

270

  DataRate       m_bps;

314

  DataRate       m_bps;

271

315

272

/**

316

/**

273

   * The interframe gap that the Net Device uses to throttle packet

317

   * The interframe gap that the Net Device uses to throttle packet

274

   * transmission

318

   * transmission

275

   * @see class Time

319

   * \see class Time

276

*/

320

*/

277

  Time           m_tInterframeGap;

321

  Time           m_tInterframeGap;

278

322

279

/**

323

/**

280

   * The PointToPointChannel to which this PointToPointNetDevice has been

324

   * The PointToPointChannel to which this PointToPointNetDevice has been

281

   * attached.

325

   * attached.

282

   * @see class PointToPointChannel

326

   * \see class PointToPointChannel

283

*/

327

*/

284

  Ptr<PointToPointChannel> m_channel;

328

  Ptr<PointToPointChannel> m_channel;

285

329

Lines 287-294 private:	Link Here

287

   * The Queue which this PointToPointNetDevice uses as a packet source.

331

   * The Queue which this PointToPointNetDevice uses as a packet source.

288

   * Management of this Queue has been delegated to the PointToPointNetDevice

332

   * Management of this Queue has been delegated to the PointToPointNetDevice

289

   * and it has the responsibility for deletion.

333

   * and it has the responsibility for deletion.

290

   * @see class Queue

334

   * \see class Queue

291

   * @see class DropTailQueue

335

   * \see class DropTailQueue

292

*/

336

*/

293

  Ptr<Queue> m_queue;

337

  Ptr<Queue> m_queue;

294

338

Lines 431-455 private:	Link Here

431

*/

475

*/

432

  TracedCallback<Ptr<const Packet> > m_promiscSnifferTrace;

476

  TracedCallback<Ptr<const Packet> > m_promiscSnifferTrace;

433

477

434

  Ptr<Node> m_node;

478

  Ptr<Node> m_node;         //!< Node owning this NetDevice

435

  Mac48Address m_address;

479

  Mac48Address m_address;   //!< Address of this NetDevice

436

  NetDevice::ReceiveCallback m_rxCallback;

480

  NetDevice::ReceiveCallback m_rxCallback;   //!< Receive callback

437

  NetDevice::PromiscReceiveCallback m_promiscCallback;

481

  NetDevice::PromiscReceiveCallback m_promiscCallback;  //!< Receive callback

438

  uint32_t m_ifIndex;

482

                                                        //   (promisc data)

439

  bool m_linkUp;

483

  uint32_t m_ifIndex; //!< Index of the interface

440

  TracedCallback<> m_linkChangeCallbacks;

484

  bool m_linkUp;      //!< Identify if the link is up or not

485

  TracedCallback<> m_linkChangeCallbacks;  //!< Callback for the link change event

441

486

442

  static const uint16_t DEFAULT_MTU = 1500;

487

  static const uint16_t DEFAULT_MTU = 1500; //!< Default MTU

443

488

444

/**

489

/**

445

   * The Maximum Transmission Unit.  This corresponds to the maximum

490

   * \brief The Maximum Transmission Unit

491

492

   * This corresponds to the maximum

446

   * number of bytes that can be transmitted as seen from higher layers.

493

   * number of bytes that can be transmitted as seen from higher layers.

447

   * This corresponds to the 1500 byte MTU size often seen on IP over

494

   * This corresponds to the 1500 byte MTU size often seen on IP over

448

   * Ethernet.

495

   * Ethernet.

449

*/

496

*/

450

  uint32_t m_mtu;

497

  uint32_t m_mtu;

451

498

452

  Ptr<Packet> m_currentPkt;

499

  Ptr<Packet> m_currentPkt; //!< Current packet processed

453

500

454

/**

501

/**

455

   * \brief PPP to Ethernet protocol number mapping

502

   * \brief PPP to Ethernet protocol number mapping

(-)i/src/point-to-point/model/point-to-point-remote-channel.h (-2 / +32 lines)

Lines 31-46 namespace ns3 {	Link Here

/**

/**

 * \ingroup point-to-point

 * \ingroup point-to-point

 * \brief A Remote Point-To-Point Channel

 * This object connects two point-to-point net devices where at least one

 * is not local to this simulator object. It simply override the transmit

 * method and uses an MPI Send operation instead.

*/

*/

class PointToPointRemoteChannel : public PointToPointChannel

class PointToPointRemoteChannel : public PointToPointChannel

public:

public:

/**

   * \brief Get the TypeId

   * \return The TypeId for this class

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

   * \brief Constructor

*/

  PointToPointRemoteChannel ();

  PointToPointRemoteChannel ();

/**

   * \brief Deconstructor

*/

  ~PointToPointRemoteChannel ();

  ~PointToPointRemoteChannel ();

  virtual bool TransmitStart (Ptr<Packet> p, Ptr<PointToPointNetDevice> src, Time txTime);

/**

   * \brief Transmit the packet

   * \param p Packet to transmit

   * \param src Source PointToPointNetDevice

   * \param txTime Transmit time to apply

   * \returns true if successful (currently always true)

*/

  virtual bool TransmitStart (Ptr<Packet> p, Ptr<PointToPointNetDevice> src,

                              Time txTime);

};

};

} // namespace ns3

#endif

#endif

(-)i/src/point-to-point/model/ppp-header.h (-1 / +14 lines)

Lines 45-51 namespace ns3 {	Link Here

 * to the packet.  The ns-3 way to do this is via a class that inherits from

 * to the packet.  The ns-3 way to do this is via a class that inherits from

 * class Header.

 * class Header.

*/

*/

class PppHeader : public Header

class PppHeader : public Header

public:

public:

Lines 59-66 public:	Link Here

*/

*/

  virtual ~PppHeader ();

  virtual ~PppHeader ();

/**

   * \brief Get the TypeId

   * \return The TypeId for this class

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

   * \brief Get the TypeId of the instance

   * \return The TypeId for this instance

*/

  virtual TypeId GetInstanceTypeId (void) const;

  virtual TypeId GetInstanceTypeId (void) const;

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

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

  virtual void Serialize (Buffer::Iterator start) const;

  virtual void Serialize (Buffer::Iterator start) const;

  virtual uint32_t Deserialize (Buffer::Iterator start);

  virtual uint32_t Deserialize (Buffer::Iterator start);

(-)i/src/point-to-point/test/point-to-point-test.cc (-2 / +25 lines)

Lines 6-19	Link Here

using namespace ns3;

using namespace ns3;

/**

 * \brief Test class for PointToPoint model

 * It tries to send one packet from one NetDevice to another, over a

 * PointToPointChannel.

*/

class PointToPointTest : public TestCase

class PointToPointTest : public TestCase

public:

public:

/**

   * \brief Create the test

*/

  PointToPointTest ();

  PointToPointTest ();

/**

   * \brief Run the test

*/

  virtual void DoRun (void);

  virtual void DoRun (void);

private:

private:

/**

   * \brief Send one packet to the device specified

   * \param device NetDevice to send to

*/

  void SendOnePacket (Ptr<PointToPointNetDevice> device);

  void SendOnePacket (Ptr<PointToPointNetDevice> device);

};

};

Lines 55-64 PointToPointTest::DoRun (void)	Link Here

  Simulator::Destroy ();

  Simulator::Destroy ();

//-----------------------------------------------------------------------------

/**

 * \brief TestSuite for PointToPoint module

*/

class PointToPointTestSuite : public TestSuite

class PointToPointTestSuite : public TestSuite

public:

public:

/**

   * \brief Constructor

*/

  PointToPointTestSuite ();

  PointToPointTestSuite ();

};

};

Lines 68-71 PointToPointTestSuite::PointToPointTestSuite ()	Link Here

  AddTestCase (new PointToPointTest, TestCase::QUICK);

  AddTestCase (new PointToPointTest, TestCase::QUICK);

static PointToPointTestSuite g_pointToPointTestSuite;

static PointToPointTestSuite g_pointToPointTestSuite; //!< The testsuite

Return to bug 938