Attachment #1949 for bug #2041

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




    return

def register_Ns3Int64x64_t_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right'))

    cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right'))
    cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor]

                   'ns3::Ptr< ns3::RttEstimator >', 
                   [], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## rtt-estimator.h (module 'internet'): ns3::Time ns3::RttEstimator::EstimateRttFromSeq(ns3::SequenceNumber32 ackSeq) [member function]
    cls.add_method('EstimateRttFromSeq', 
                   'ns3::Time', 
                   [param('ns3::SequenceNumber32', 'ackSeq')], 
                   is_virtual=True)
    ## rtt-estimator.h (module 'internet'): ns3::Time ns3::RttEstimator::GetCurrentEstimate() const [member function]
    cls.add_method('GetCurrentEstimate', 
                   'ns3::Time', 

                   'ns3::Time', 
                   [], 
                   is_const=True)
    ## rtt-estimator.h (module 'internet'): ns3::Time ns3::RttEstimator::GetRttFor(ns3::TcpHeader const & tcpHeader) [member function]
    cls.add_method('GetRttFor', 
                   'ns3::Time', 
                   [param('ns3::TcpHeader const &', 'tcpHeader')], 
                   is_virtual=True)
    ## rtt-estimator.h (module 'internet'): static ns3::TypeId ns3::RttEstimator::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 

                   'ns3::Time', 
                   [], 
                   is_pure_virtual=True, is_virtual=True)
    ## rtt-estimator.h (module 'internet'): void ns3::RttEstimator::SentPkt(ns3::TcpHeader const & tcpHeader, uint32_t size) [member function]
    cls.add_method('SentPkt', 
                   'void', 
                   [param('ns3::TcpHeader const &', 'tcpHeader'), param('uint32_t', 'size')], 
                   is_virtual=True)
    ## rtt-estimator.h (module 'internet'): void ns3::RttEstimator::SetCurrentEstimate(ns3::Time estimate) [member function]
    cls.add_method('SetCurrentEstimate', 

    cls.add_method('SetMinRto', 
                   'void', 
                   [param('ns3::Time', 'minRto')])
    ## rtt-estimator.h (module 'internet'): void ns3::RttEstimator::SetTimestampEnabled(bool enabled) [member function]
    cls.add_method('SetTimestampEnabled', 
                   'void', 
                   [param('bool', 'enabled')])
    return

def register_Ns3RttMeanDeviation_methods(root_module, cls):

    return

def register_Ns3Time_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right'))

    cls.add_binary_comparison_operator('>')
    cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## nstime.h (module 'core'): ns3::Time::Time() [constructor]




    return

def register_Ns3Int64x64_t_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right'))

    cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right'))
    cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor]

                   'ns3::Ptr< ns3::RttEstimator >', 
                   [], 
                   is_pure_virtual=True, is_const=True, is_virtual=True)
    ## rtt-estimator.h (module 'internet'): ns3::Time ns3::RttEstimator::EstimateRttFromSeq(ns3::SequenceNumber32 ackSeq) [member function]
    cls.add_method('EstimateRttFromSeq', 
                   'ns3::Time', 
                   [param('ns3::SequenceNumber32', 'ackSeq')], 
                   is_virtual=True)
    ## rtt-estimator.h (module 'internet'): ns3::Time ns3::RttEstimator::GetCurrentEstimate() const [member function]
    cls.add_method('GetCurrentEstimate', 
                   'ns3::Time', 

                   'ns3::Time', 
                   [], 
                   is_const=True)
    ## rtt-estimator.h (module 'internet'): ns3::Time ns3::RttEstimator::GetRttFor(ns3::TcpHeader const & tcpHeader) [member function]
    cls.add_method('GetRttFor', 
                   'ns3::Time', 
                   [param('ns3::TcpHeader const &', 'tcpHeader')], 
                   is_virtual=True)
    ## rtt-estimator.h (module 'internet'): static ns3::TypeId ns3::RttEstimator::GetTypeId() [member function]
    cls.add_method('GetTypeId', 
                   'ns3::TypeId', 

                   'ns3::Time', 
                   [], 
                   is_pure_virtual=True, is_virtual=True)
    ## rtt-estimator.h (module 'internet'): void ns3::RttEstimator::SentPkt(ns3::TcpHeader const & tcpHeader, uint32_t size) [member function]
    cls.add_method('SentPkt', 
                   'void', 
                   [param('ns3::TcpHeader const &', 'tcpHeader'), param('uint32_t', 'size')], 
                   is_virtual=True)
    ## rtt-estimator.h (module 'internet'): void ns3::RttEstimator::SetCurrentEstimate(ns3::Time estimate) [member function]
    cls.add_method('SetCurrentEstimate', 

    cls.add_method('SetMinRto', 
                   'void', 
                   [param('ns3::Time', 'minRto')])
    ## rtt-estimator.h (module 'internet'): void ns3::RttEstimator::SetTimestampEnabled(bool enabled) [member function]
    cls.add_method('SetTimestampEnabled', 
                   'void', 
                   [param('bool', 'enabled')])
    return

def register_Ns3RttMeanDeviation_methods(root_module, cls):

    return

def register_Ns3Time_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right'))

    cls.add_binary_comparison_operator('>')
    cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## nstime.h (module 'core'): ns3::Time::Time() [constructor]

(-)a/src/internet/model/rtt-estimator.cc (-19 / +54 lines)

Lines 33-38	Link Here

#include "ns3/integer.h"

#include "ns3/integer.h"

#include "ns3/uinteger.h"

#include "ns3/uinteger.h"

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/packet.h"

#include "ns3/tcp-header.h"

#include "tcp-option-ts.h"

namespace ns3 {

namespace ns3 {

Lines 107-113	Link Here

107

RttEstimator::RttEstimator ()

110

RttEstimator::RttEstimator ()

108

  : m_next (1), m_history (),

111

  : m_next (1), m_history (),

109

    m_nSamples (0),

112

    m_nSamples (0),

110

    m_multiplier (1)

113

    m_multiplier (1),

114

    m_timestampEnabled (false)

111

115

112

  NS_LOG_FUNCTION (this);

116

  NS_LOG_FUNCTION (this);

113

  //note next=1 everywhere since first segment will have sequence 1

117

  //note next=1 everywhere since first segment will have sequence 1

Lines 124-130	Link Here

124

    m_maxMultiplier (c.m_maxMultiplier),

128

    m_maxMultiplier (c.m_maxMultiplier),

125

    m_initialEstimatedRtt (c.m_initialEstimatedRtt),

129

    m_initialEstimatedRtt (c.m_initialEstimatedRtt),

126

    m_currentEstimatedRtt (c.m_currentEstimatedRtt), m_minRto (c.m_minRto),

130

    m_currentEstimatedRtt (c.m_currentEstimatedRtt), m_minRto (c.m_minRto),

127

    m_nSamples (c.m_nSamples), m_multiplier (c.m_multiplier)

131

    m_nSamples (c.m_nSamples), m_multiplier (c.m_multiplier),

132

    m_timestampEnabled (c.m_timestampEnabled)

128

133

129

  NS_LOG_FUNCTION (this);

134

  NS_LOG_FUNCTION (this);

130

135

Lines 140-148	Link Here

140

  return GetTypeId ();

145

  return GetTypeId ();

141

146

142

147

143

void RttEstimator::SentSeq (SequenceNumber32 seq, uint32_t size)

148

void RttEstimator::SentPkt (const TcpHeader &tcpHeader, uint32_t size)

144

149

145

  NS_LOG_FUNCTION (this << seq << size);

150

  NS_LOG_FUNCTION (this << tcpHeader);

151

152

  SequenceNumber32 seq = tcpHeader.GetSequenceNumber();

153

146

  // Note that a particular sequence has been sent

154

  // Note that a particular sequence has been sent

147

  if (seq == m_next)

155

  if (seq == m_next)

148

    { // This is the next expected one, just log at end

156

    { // This is the next expected one, just log at end

Lines 168-188	Link Here

168

176

169

177

170

178

171

Time RttEstimator::EstimateRttFromSeq (SequenceNumber32 ackSeq)

179

Time

180

RttEstimator::GetRttFor (const TcpHeader &tcpHeader)

172

181

173

  NS_LOG_FUNCTION (this << ackSeq);

182

  NS_LOG_FUNCTION (this << tcpHeader);

174

  // An ack has been received, calculate rtt and log this measurement

183

175

  // Note we use a linear search (O(n)) for this since for the common

184

  SequenceNumber32 ackSeq = tcpHeader.GetAckNumber();

176

  // case the ack'ed packet will be at the head of the list

185

177

  Time m = Seconds (0.0);

186

  Time m = Time (0.0);

178

  if (m_history.size () == 0) return (m);    // No pending history, just exit

187

179

  RttHistory& h = m_history.front ();

188

  if (m_timestampEnabled && tcpHeader.HasOption (TcpOption::TS))

180

  if (!h.retx && ackSeq >= (h.seq + SequenceNumber32 (h.count)))

189

181

    { // Ok to use this sample

190

      Ptr<TcpOptionTS> ts;

182

      m = Simulator::Now () - h.time; // Elapsed time

191

      ts = DynamicCast<TcpOptionTS> (tcpHeader.GetOption (TcpOption::TS));

183

      Measurement (m);                // Log the measurement

192

      m = TcpOptionTS::ElapsedTimeFromTsValue (ts->GetEcho ());

184

      ResetMultiplier ();             // Reset multiplier on valid measurement

185

193

194

  else

195

196

      // An ack has been received, calculate rtt and log this measurement

197

      // Note we use a linear search (O(n)) for this since for the common

198

      // case the ack'ed packet will be at the head of the list

199

      if (m_history.size () == 0) return (m);    // No pending history, just exit

200

      RttHistory& h = m_history.front ();

201

      if (!h.retx && ackSeq >= (h.seq + SequenceNumber32 (h.count)))

202

        { // Ok to use this sample

203

          m = Simulator::Now () - h.time; // Elapsed time

204

205

206

186

  // Now delete all ack history with seq <= ack

207

  // Now delete all ack history with seq <= ack

187

  while(m_history.size () > 0)

208

  while(m_history.size () > 0)

188

209

Lines 190-196	Link Here

190

      if ((h.seq + SequenceNumber32 (h.count)) > ackSeq) break;               // Done removing

211

      if ((h.seq + SequenceNumber32 (h.count)) > ackSeq) break;               // Done removing

191

      m_history.pop_front (); // Remove

212

      m_history.pop_front (); // Remove

192

213

193

  return m;

214

215

  if (!m.IsZero ())

216

217

      Measurement (m);                // Log the measurement

218

      ResetMultiplier ();             // Reset multiplier on valid measurement

219

      return m;

220

221

  else

222

223

      return m_currentEstimatedRtt;

224

194

225

195

226

196

void RttEstimator::ClearSent ()

227

void RttEstimator::ClearSent ()

Lines 225-231	Link Here

225

  ResetMultiplier ();

256

  ResetMultiplier ();

226

257

227

258

228

259

void

260

RttEstimator::SetTimestampEnabled (bool enabled)

261

262

  m_timestampEnabled = enabled;

263

229

264

230

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

265

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

231

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

266

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

(-)a/src/internet/model/rtt-estimator.h (-8 / +22 lines)

Lines 61-66	Link Here

/// Container for RttHistory objects

/// Container for RttHistory objects

typedef std::deque<RttHistory> RttHistory_t;

typedef std::deque<RttHistory> RttHistory_t;

class Packet;

class TcpHeader;

/**

/**

 * \ingroup tcp

 * \ingroup tcp

Lines 86-103	Link Here

  virtual TypeId GetInstanceTypeId (void) const;

  virtual TypeId GetInstanceTypeId (void) const;

/**

/**

   * \brief Note that a particular sequence has been sent

   * \brief Note that a particular packet (its sequence number) has been sent.

   * \param seq the packet sequence number.

   * \param tcpHeader the packet TCP header.

   * \param size the packet size.

   * \param size the packet size.

*/

*/

  virtual void SentSeq (SequenceNumber32 seq, uint32_t size);

  virtual void SentPkt (const TcpHeader &tcpHeader, uint32_t size);

/**

/**

   * \brief Note that a particular ack sequence has been received

   * \brief Note that a particular packet has been received. Depending on

   * \param ackSeq the ack sequence number.

100

   * the TCP TimeStamp option presence, the ack number or the TimeStamp will be used to

   * \return The measured RTT for this ack.

101

   * calculate the estimate RTT.

102

   * \param tcpHeader the packet TCP header.

103

   * \return The estimated RTT.

*/

104

*/

100

  virtual Time EstimateRttFromSeq (SequenceNumber32 ackSeq);

105

  virtual Time GetRttFor (const TcpHeader &tcpHeader);

101

106

102

/**

107

/**

103

   * \brief Clear all history entries

108

   * \brief Clear all history entries

Lines 156-166	Link Here

156

  void SetCurrentEstimate (Time estimate);

161

  void SetCurrentEstimate (Time estimate);

157

162

158

/**

163

/**

159

   * \brief gets the current RTT estimate.

164

   * \brief Gets the current RTT estimate.

160

   * \return The current RTT estimate.

165

   * \return The current RTT estimate.

161

*/

166

*/

162

  Time GetCurrentEstimate (void) const;

167

  Time GetCurrentEstimate (void) const;

163

168

169

/**

170

   * \brief Enable (or disable) the use of TCP TimeStamp option

171

   * \param true: use TCP TimeStamp option

172

*/

173

  void SetTimestampEnabled (bool enabled);

174

164

private:

175

private:

165

  SequenceNumber32 m_next;    //!< Next expected sequence to be sent

176

  SequenceNumber32 m_next;    //!< Next expected sequence to be sent

166

  RttHistory_t m_history;     //!< List of sent packet

177

  RttHistory_t m_history;     //!< List of sent packet

Lines 172-177	Link Here

172

  Time         m_minRto;                  //!< minimum value of the timeout

183

  Time         m_minRto;                  //!< minimum value of the timeout

173

  uint32_t     m_nSamples;                //!< Number of samples

184

  uint32_t     m_nSamples;                //!< Number of samples

174

  uint16_t     m_multiplier;              //!< RTO Multiplier

185

  uint16_t     m_multiplier;              //!< RTO Multiplier

186

187

private:

188

  bool m_timestampEnabled;                //!< Use TCP TimeStamp option

175

};

189

};

176

190

177

/**

191

/**




    m_sndScaleFactor (0),
    m_rcvScaleFactor (0),
    m_timestampEnabled (true),
    m_timestampToEcho (0)
    m_lastEchoedTime (0)

{
  NS_LOG_FUNCTION (this);

    m_sndScaleFactor (sock.m_sndScaleFactor),
    m_rcvScaleFactor (sock.m_rcvScaleFactor),
    m_timestampEnabled (sock.m_timestampEnabled),
    m_timestampToEcho (sock.m_timestampToEcho)
    m_lastEchoedTime (sock.m_lastEchoedTime)

{
  NS_LOG_FUNCTION (this);

      m_tcp->SendPacket (p, header, m_endPoint6->GetLocalAddress (),
                         m_endPoint6->GetPeerAddress (), m_boundnetdevice);
    }
  m_rtt->SentPkt (header, sz);       // notify the RTT
  // Notify the application of the data being sent unless this is a retransmit
  if (seq == m_nextTxSequence)
    {

{
  Time nextRtt;

  // Use m_rtt for the estimation. Note, RTT of duplicated acknowledgement
  // (which should be ignored) is handled by m_rtt.
  nextRtt =  m_rtt->GetRttFor (tcpHeader);
    }
  else
    {
      // Use m_rtt for the estimation. Note, RTT of duplicated acknowledgement
      // (which should be ignored) is handled by m_rtt.
      nextRtt =  m_rtt->EstimateRttFromSeq (tcpHeader.GetAckNumber () );
    }

  //nextRtt will be zero for dup acks.  Don't want to update lastRtt in that case
  //but still needed to do list clearing that is done in EstimateRttFromSeq.

    }

  m_timestampEnabled = false;
  m_rtt->SetTimestampEnabled (false);

  if (header.HasOption (TcpOption::TS))
    {
      m_timestampEnabled = true;
      m_rtt->SetTimestampEnabled (true);
      ProcessOptionTimestamp (header.GetOption (TcpOption::TS));
    }
}


  Ptr<const TcpOptionTS> ts = DynamicCast<const TcpOptionTS> (option);
  m_timestampToEcho = ts->GetTimestamp ();
  m_lastEchoedTime = ts->GetEcho ();

  NS_LOG_INFO (m_node->GetId () << " Got timestamp=" <<
               m_timestampToEcho << " and Echo="     << ts->GetEcho ());
}

void

(-)a/src/internet/model/tcp-socket-base.h (-1 lines)

Lines 667-673	Link Here

667

668

  bool     m_timestampEnabled;    //!< Timestamp option enabled

668

  bool     m_timestampEnabled;    //!< Timestamp option enabled

669

  uint32_t m_timestampToEcho;     //!< Timestamp to echo

669

  uint32_t m_timestampToEcho;     //!< Timestamp to echo

670

  uint32_t m_lastEchoedTime;      //!< Last echoed timestamp

671

};

670

};

672

671

673

} // namespace ns3

672

} // namespace ns3

Return to bug 2041