Attachment #2284 for bug #2302

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




                                TypeId congestionControl,
                                uint32_t mtu)
  : TestCase (desc),
    m_congControlTypeId (congestionControl),
    m_propagationDelay (propagationDelay),
    m_startTime (startTime),
    m_mtu (mtu),
    m_pktSize (pktSize),
    m_pktCount (pktCount),
    m_interPacketInterval (pktInterval),
    m_initialSlowStartThresh (initialSlowStartThresh),
    m_initialCwnd (initialCwnd),
    m_segmentSize (segmentSize),
    m_remoteAddr (Ipv4Address::GetAny (), 4477)
{
  NS_LOG_FUNCTION (this << desc);
}

  m_receiverSocket->SetProcessedAckCb (MakeCallback (&TcpGeneralTest::ProcessedAckCb, this));
  m_receiverSocket->SetRetransmitCb (MakeCallback (&TcpGeneralTest::RtoExpiredCb, this));
  m_receiverSocket->SetForkCb (MakeCallback (&TcpGeneralTest::ForkCb, this));
  m_receiverSocket->SetUpdateRttHistoryCb (MakeCallback (&TcpGeneralTest::UpdateRttHistoryCb, this));
  m_receiverSocket->TraceConnectWithoutContext ("Tx",
                                                MakeCallback (&TcpGeneralTest::TxPacketCb, this));
  m_receiverSocket->TraceConnectWithoutContext ("Rx",

  m_senderSocket->SetRcvAckCb (MakeCallback (&TcpGeneralTest::RcvAckCb, this));
  m_senderSocket->SetProcessedAckCb (MakeCallback (&TcpGeneralTest::ProcessedAckCb, this));
  m_senderSocket->SetRetransmitCb (MakeCallback (&TcpGeneralTest::RtoExpiredCb, this));
  m_senderSocket->SetUpdateRttHistoryCb (MakeCallback (&TcpGeneralTest::UpdateRttHistoryCb, this));
  m_senderSocket->SetDataSentCallback (MakeCallback (&TcpGeneralTest::DataSentCb, this));
  m_senderSocket->TraceConnectWithoutContext ("CongestionWindow",
                                              MakeCallback (&TcpGeneralTest::CWndTrace, this));
  m_senderSocket->TraceConnectWithoutContext ("CongState",

}

void
TcpGeneralTest::UpdateRttHistoryCb (Ptr<const TcpSocketBase> tcp,
                                    const SequenceNumber32 & seq, uint32_t sz,
                                    bool isRetransmission)
{
  if (tcp->GetNode () == m_receiverSocket->GetNode ())
    {
      UpdatedRttHistory (seq, sz, isRetransmission, RECEIVER);
    }
  else if (tcp->GetNode () == m_senderSocket->GetNode ())
    {
      UpdatedRttHistory (seq, sz, isRetransmission, SENDER);
    }
  else
    {
      NS_FATAL_ERROR ("Closed socket, but not recognized");
    }
}

void
TcpGeneralTest::RtoExpiredCb (const Ptr<const TcpSocketState> tcb,
                              const Ptr<const TcpSocketBase> tcp)
{

}

Time
TcpGeneralTest::GetDelAckTimeout (SocketWho who)
{
  if (who == SENDER)
    {

}

void
TcpSocketMsgBase::SetRcvAckCb (AckManagementCb cb)
{
  NS_ASSERT (!cb.IsNull ());
  m_rcvAckCb = cb;
}

void
TcpSocketMsgBase::SetProcessedAckCb (AckManagementCb cb)
{
  NS_ASSERT (!cb.IsNull ());
  m_processedAckCb = cb;
}

void
TcpSocketMsgBase::SetRetransmitCb (RetrCb cb)
{
  NS_ASSERT (!cb.IsNull ());
  m_retrCallback = cb;

}

void
TcpSocketMsgBase::SetUpdateRttHistoryCb (UpdateRttCallback cb)
{
  NS_ASSERT (!cb.IsNull ());
  m_updateRttCb = cb;
}

void
TcpSocketMsgBase::UpdateRttHistory (const SequenceNumber32 &seq, uint32_t sz,
                                    bool isRetransmission)
{
  TcpSocketBase::UpdateRttHistory (seq, sz, isRetransmission);
  if (!m_updateRttCb.IsNull ())
    {
      m_updateRttCb (this, seq, sz, isRetransmission);
    }
}

void
TcpSocketMsgBase::CompleteFork (Ptr<Packet> p, const TcpHeader &tcpHeader,
                                const Address &fromAddress, const Address &toAddress)
{

(-)a/src/internet/test/tcp-general-test.h (-15 / +41 lines)

Lines 60-68 public:	Link Here

  typedef Callback<void, Ptr<const Packet>, const TcpHeader&,

  typedef Callback<void, Ptr<const Packet>, const TcpHeader&,

                   Ptr<const TcpSocketBase> > AckManagementCallback;

                   Ptr<const TcpSocketBase> > AckManagementCb;

  typedef Callback<void, Ptr<const TcpSocketState>,

  typedef Callback<void, Ptr<const TcpSocketState>,

                   Ptr<const TcpSocketBase> > RetrCallback;

                   Ptr<const TcpSocketBase> > RetrCb;

  typedef Callback<void, Ptr<const TcpSocketBase>, const SequenceNumber32&,

                   uint32_t, bool> UpdateRttCallback;

/**

/**

   * \brief Set the callback invoked when an ACK is received (at the beginning

   * \brief Set the callback invoked when an ACK is received (at the beginning

Lines 70-76 public:	Link Here

   * \param cb callback

   * \param cb callback

*/

*/

  void SetRcvAckCb (AckManagementCallback cb);

  void SetRcvAckCb (AckManagementCb cb);

/**

/**

   * \brief Set the callback invoked when an ACK is received and processed

   * \brief Set the callback invoked when an ACK is received and processed

Lines 78-91 public:	Link Here

   * \param cb callback

   * \param cb callback

*/

*/

  void SetProcessedAckCb (AckManagementCallback cb);

  void SetProcessedAckCb (AckManagementCb cb);

/**

/**

   * \brief Set the callback invoked after the processing of a retransmit timeout

   * \brief Set the callback invoked after the processing of a retransmit timeout

   * \param cb callback

   * \param cb callback

*/

*/

  void SetRetransmitCb (RetrCallback cb);

  void SetRetransmitCb (RetrCb cb);

/**

/**

   * \brief Set the callback invoked after the forking

   * \brief Set the callback invoked after the forking

Lines 93-110 public:	Link Here

*/

*/

  void SetForkCb (Callback<void, Ptr<TcpSocketMsgBase> > cb);

  void SetForkCb (Callback<void, Ptr<TcpSocketMsgBase> > cb);

/**

   * \brief Set the callback invoked when we update rtt history

100

101

   * \param cb callback

102

*/

103

  void SetUpdateRttHistoryCb (UpdateRttCallback cb);

104

protected:

105

protected:

  virtual void ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader);

106

  virtual void ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader);

  virtual void Retransmit (void);

107

  virtual void Retransmit (void);

  virtual Ptr<TcpSocketBase> Fork (void);

108

  virtual Ptr<TcpSocketBase> Fork (void);

100

  virtual void CompleteFork (Ptr<Packet> p, const TcpHeader& tcpHeader,

109

  virtual void CompleteFork (Ptr<Packet> p, const TcpHeader& tcpHeader,

101

                             const Address& fromAddress, const Address& toAddress);

110

                             const Address& fromAddress, const Address& toAddress);

111

  virtual void UpdateRttHistory (const SequenceNumber32 &seq, uint32_t sz,

112

                                 bool isRetransmission);

102

113

103

private:

114

private:

104

  AckManagementCallback m_rcvAckCb;

115

  AckManagementCb m_rcvAckCb;

105

  AckManagementCallback m_processedAckCb;

116

  AckManagementCb m_processedAckCb;

106

  RetrCallback m_retrCallback;

117

  RetrCb m_retrCallback;

107

  Callback<void, Ptr<TcpSocketMsgBase> > m_forkCb;

118

  Callback<void, Ptr<TcpSocketMsgBase> > m_forkCb;

119

  UpdateRttCallback m_updateRttCb;

108

};

120

};

109

121

110

122

Lines 129-144 public:	Link Here

129

141

130

  TcpSocketSmallAcks ()

142

  TcpSocketSmallAcks ()

131

    : TcpSocketMsgBase (),

143

    : TcpSocketMsgBase (),

132

    m_bytesToAck (125),

144

      m_bytesToAck (125),

133

    m_bytesLeftToBeAcked (0),

145

      m_bytesLeftToBeAcked (0),

134

    m_lastAckedSeq (1)

146

      m_lastAckedSeq (1)

135

147

136

148

137

149

138

  TcpSocketSmallAcks (const TcpSocketSmallAcks &other) : TcpSocketMsgBase (other),

150

  TcpSocketSmallAcks (const TcpSocketSmallAcks &other) : TcpSocketMsgBase (other),

139

    m_bytesToAck (other.m_bytesToAck),

151

                                                         m_bytesToAck (other.m_bytesToAck),

140

    m_bytesLeftToBeAcked (other.m_bytesLeftToBeAcked),

152

                                                         m_bytesLeftToBeAcked (other.m_bytesLeftToBeAcked),

141

    m_lastAckedSeq (other.m_lastAckedSeq)

153

                                                         m_lastAckedSeq (other.m_lastAckedSeq)

142

154

143

155

144

156

Lines 464-470 protected:	Link Here

464

   * \param newValue new value

476

   * \param newValue new value

465

*/

477

*/

466

  virtual void CongStateTrace (const TcpSocketState::TcpCongState_t oldValue,

478

  virtual void CongStateTrace (const TcpSocketState::TcpCongState_t oldValue,

467

                              const TcpSocketState::TcpCongState_t newValue)

479

                               const TcpSocketState::TcpCongState_t newValue)

468

480

469

481

470

482

Lines 593-598 protected:	Link Here

593

605

594

606

595

/**

607

/**

608

   * \brief Updated the Rtt history

609

   * \param seq Sequence inserted

610

   * \param sz size

611

   * \param isRetransmission self-explanatory

612

   * \param who where the rtt history was updated

613

*/

614

  virtual void UpdatedRttHistory (const SequenceNumber32 & seq, uint32_t sz,

615

                                  bool isRetransmission, SocketWho who)

616

617

618

619

/**

596

   * \brief Notifying application for sent data

620

   * \brief Notifying application for sent data

597

621

598

   * \param size the amount of bytes transmitted

622

   * \param size the amount of bytes transmitted

Lines 721-726 private:	Link Here

721

                       const Ptr<const TcpSocketBase> tcp);

745

                       const Ptr<const TcpSocketBase> tcp);

722

  void RtoExpiredCb   (const Ptr<const TcpSocketState> tcb,

746

  void RtoExpiredCb   (const Ptr<const TcpSocketState> tcb,

723

                       const Ptr<const TcpSocketBase> tcp);

747

                       const Ptr<const TcpSocketBase> tcp);

748

  void UpdateRttHistoryCb (Ptr<const TcpSocketBase> tcp, const SequenceNumber32&seq,

749

                           uint32_t sz, bool isRetransmission);

724

  void DataSentCb     (Ptr<Socket> socket, uint32_t size);

750

  void DataSentCb     (Ptr<Socket> socket, uint32_t size);

725

  void ForkCb         (Ptr<TcpSocketMsgBase> tcp);

751

  void ForkCb         (Ptr<TcpSocketMsgBase> tcp);

726

  void HandleAccept (Ptr<Socket> socket, const Address& from);

752

  void HandleAccept (Ptr<Socket> socket, const Address& from);




/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2016 Natale Patriciello <natale.patriciello@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "tcp-general-test.h"
#include "ns3/node.h"
#include "ns3/log.h"
#include "tcp-error-model.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("TcpRttEstimationTestSuite");

/**
 * \brief Check Rtt calculations
 *
 * First check is that, for each ACK, we have a valid estimation of the RTT.
 * The second check is that, when updating RTT history, we should consider
 * retransmission only segments which sequence number is lower than the highest
 * already transmitted.
 */
class TcpRttEstimationTest : public TcpGeneralTest
{
public:
  TcpRttEstimationTest (const std::string &desc, bool enableTs, uint32_t dataPkt);

protected:
  virtual Ptr<TcpSocketMsgBase> CreateReceiverSocket (Ptr<Node> node);
  virtual Ptr<TcpSocketMsgBase> CreateSenderSocket (Ptr<Node> node);

  virtual void Rx (const Ptr<const Packet> p, const TcpHeader&h, SocketWho who);
  virtual void Tx (const Ptr<const Packet> p, const TcpHeader&h, SocketWho who);
  virtual void UpdatedRttHistory (const SequenceNumber32 & seq, uint32_t sz,
                                  bool isRetransmission, SocketWho who);
  virtual void RttTrace (Time oldTime, Time newTime);
  void FinalChecks ();

private:
  bool m_enableTs;
  bool m_rttChanged;
  SequenceNumber32 m_highestTxSeq;
};

TcpRttEstimationTest::TcpRttEstimationTest (const std::string &desc, bool enableTs, uint32_t dataPkt)
  : TcpGeneralTest (desc, 500, dataPkt, Seconds (0.01), Seconds (0.05), Seconds (2.0),
                    0xffffffff,1, 500),
    m_enableTs (enableTs),
    m_rttChanged (false),
    m_highestTxSeq (0)
{
}

Ptr<TcpSocketMsgBase>
TcpRttEstimationTest::CreateReceiverSocket (Ptr<Node> node)
{
  Ptr<TcpSocketMsgBase> s = TcpGeneralTest::CreateReceiverSocket (node);
  if (!m_enableTs)
    {
      s->SetAttribute ("Timestamp", BooleanValue (false));
    }

  return s;
}

Ptr<TcpSocketMsgBase>
TcpRttEstimationTest::CreateSenderSocket (Ptr<Node> node)
{
  Ptr<TcpSocketMsgBase> s = TcpGeneralTest::CreateSenderSocket (node);
  if (!m_enableTs)
    {
      s->SetAttribute ("Timestamp", BooleanValue (false));
    }

  return s;
}

void
TcpRttEstimationTest::Tx (const Ptr<const Packet> p, const TcpHeader &h, SocketWho who)
{
  if (who == SENDER && h.GetFlags () != TcpHeader::SYN)
    {
      if (m_highestTxSeq < h.GetSequenceNumber ())
        {
          m_highestTxSeq = h.GetSequenceNumber ();
        }

      Ptr<RttEstimator> rttEstimator = GetRttEstimator (SENDER);
      NS_ASSERT (rttEstimator != 0);
      NS_LOG_DEBUG ("S Rx: seq=" << h.GetSequenceNumber () << " ack=" << h.GetAckNumber ());
      NS_TEST_ASSERT_MSG_NE (rttEstimator->GetEstimate (), Seconds (1),
                             "Default Estimate for the RTT");
    }
}

void
TcpRttEstimationTest::Rx (const Ptr<const Packet> p, const TcpHeader &h, SocketWho who)
{
  if (who == RECEIVER)
    {
      NS_LOG_DEBUG ("R Rx: seq=" << h.GetSequenceNumber () << " ack=" << h.GetAckNumber ());
    }
}

void
TcpRttEstimationTest::UpdatedRttHistory (const SequenceNumber32 & seq, uint32_t sz,
                                         bool isRetransmission, SocketWho who)
{
  if (seq < m_highestTxSeq)
    {
      NS_TEST_ASSERT_MSG_EQ (isRetransmission, true,
                             "A retransmission is not flagged as such");
    }
  else
    {
      NS_TEST_ASSERT_MSG_EQ (isRetransmission, false,
                             "Incorrectly flagging seq as retransmission");
    }

}

void
TcpRttEstimationTest::RttTrace (Time oldTime, Time newTime)
{
  NS_LOG_DEBUG ("Rtt changed to " << newTime);
  m_rttChanged = true;
}

void
TcpRttEstimationTest::FinalChecks ()
{
  NS_TEST_ASSERT_MSG_EQ (m_rttChanged, true, "Rtt was not updated");
}

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

static class TcpRttEstimationTestSuite : public TestSuite
{
public:
  TcpRttEstimationTestSuite () : TestSuite ("tcp-rtt-estimation-test", UNIT)
  {
    AddTestCase (new TcpRttEstimationTest ("RTT estimation, ts, no data", true, 0),
                 TestCase::QUICK);
    AddTestCase (new TcpRttEstimationTest ("RTT estimation, no ts, no data", false, 0),
                 TestCase::QUICK);
    AddTestCase (new TcpRttEstimationTest ("RTT estimation, ts, some data", true, 10),
                 TestCase::QUICK);
    AddTestCase (new TcpRttEstimationTest ("RTT estimation, no ts, some data", false, 10),
                 TestCase::QUICK);
  }
} g_tcpRttEstimationTestSuite;

} // namespace ns3

(-)a/src/internet/wscript (+1 lines)

Lines 244-249 def build(bld):	Link Here

244

        'test/tcp-zero-window-test.cc',

244

        'test/tcp-zero-window-test.cc',

245

        'test/tcp-pkts-acked-test.cc',

245

        'test/tcp-pkts-acked-test.cc',

246

        'test/tcp-bytes-in-flight-test.cc',

246

        'test/tcp-bytes-in-flight-test.cc',

247

        'test/tcp-rtt-estimation.cc',

247

        'test/udp-test.cc',

248

        'test/udp-test.cc',

248

        'test/ipv6-address-generator-test-suite.cc',

249

        'test/ipv6-address-generator-test-suite.cc',

249

        'test/ipv6-dual-stack-test-suite.cc',

250

        'test/ipv6-dual-stack-test-suite.cc',

Return to bug 2302