diff --git a/src/internet/doc/tcp.rst b/src/internet/doc/tcp.rst index 7e2ec5c04..accff0a9e 100644 --- a/src/internet/doc/tcp.rst +++ b/src/internet/doc/tcp.rst @@ -237,11 +237,20 @@ However, other things should be checked in the test: * Persistent timer setup * Persistent timer teardown if rWnd increases -At first, we should define the general parameters for the TCP connection, which +To construct the test case, just derive from the TcpGeneralTest class: + +The code is the following: + +.. code-block:: c++ + + TcpZeroWindowTest::TcpZeroWindowTest (const std::string &desc) + : TcpGeneralTest (desc) + { + } + +Then, we should define the general parameters for the TCP connection, which will be one-sided (one node is acting as SENDER, while the other is acting as -RECEIVER). They are coded in the constructor of the test case, as subclass of -TcpGeneralTest (see the doxygen documentation to discover all methods you have -at your disposal): +RECEIVER): * Application packet size set to 500, and 20 packet in total (it means a stream of 10k bytes) @@ -252,22 +261,52 @@ at your disposal): We have also to define the link properties, because the above definition does not work for every combination of propagation delay and sender application behavior. -We can specify the following parameters through the same test constructor: * Link one-way propagation delay: 50 ms * Application packet generation interval: 10 ms * Application starting time: 20 s after the starting point -The code is the following: +To define the properties of the environment (e.g. properties which should be +set before the object creation, such as propagation delay) we implement the method +ConfigureEnvironment: .. code-block:: c++ - TcpZeroWindowTest::TcpZeroWindowTest (const std::string &desc) - : TcpGeneralTest (desc, 500, 20, Seconds (0.01), Seconds (0.05), Seconds (2.0), - 0xffffffff, 10, 500) + void + TcpZeroWindowTest::ConfigureEnvironment () { + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (20); + SetMTU (500); + SetTransmitStart (Seconds (2.0)); + SetPropagationDelay (MilliSeconds (50)); } +For other properties, set after the object creation, we can use ConfigureProperties. +The difference is that some values, for example initial congestion window +or initial slow start threshold, are applicable only to a single instance, not +to every instance we have. Usually, methods which requires an id and a value +are meant to be called inside ConfigureProperties. Please see the doxygen +documentation for an exhaustive list of the tunable properties. + +.. code-block:: c++ + + void + TcpZeroWindowTest::ConfigureProperties () + { + TcpGeneralTest::ConfigureProperties (); + SetInitialCwnd (SENDER, 10); + } + +To see the default value for the experiment, please see the implementation of +both methods inside TcpGeneralTest class. + +.. note:: + If some configuration parameters are missing, add a method called + "SetSomeValue" which takes as input the value only (if it is meant to be + called inside ConfigureEnvironment) or the socket and the value (if it is + meant to be called inside ConfigureProperties). + To define a zero-window situation, we choose (by design) to initiate the connection with a 0-byte rx buffer. This implies that the RECEIVER, in its first SYN-ACK, advertizes a zero window. To this aim, we implement the method diff --git a/src/internet/test/tcp-bytes-in-flight-test.cc b/src/internet/test/tcp-bytes-in-flight-test.cc index d46bfe632..8eb61c6ec 100644 --- a/src/internet/test/tcp-bytes-in-flight-test.cc +++ b/src/internet/test/tcp-bytes-in-flight-test.cc @@ -48,6 +48,7 @@ protected: virtual void BytesInFlightTrace (uint32_t oldValue, uint32_t newValue); void PktDropped (const Ipv4Header &ipH, const TcpHeader& tcpH, Ptr p); + void ConfigureEnvironment (); void FinalChecks (); @@ -60,9 +61,9 @@ private: std::vector m_toDrop; // List of SequenceNumber to drop }; -TcpBytesInFlightTest::TcpBytesInFlightTest (const std::string &desc, std::vector &toDrop) - : TcpGeneralTest (desc, 500, 30, Seconds (0.01), Seconds (0.05), Seconds (2.0), - 0xffffffff,1, 500), +TcpBytesInFlightTest::TcpBytesInFlightTest (const std::string &desc, + std::vector &toDrop) + : TcpGeneralTest (desc), m_realBytesInFlight (0), m_guessedBytesInFlight (0), m_dupAckRecv (0), @@ -72,6 +73,16 @@ TcpBytesInFlightTest::TcpBytesInFlightTest (const std::string &desc, std::vector { } +void +TcpBytesInFlightTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (30); + SetPropagationDelay (MilliSeconds (50)); + SetTransmitStart (Seconds (2.0)); + +} + Ptr TcpBytesInFlightTest::CreateReceiverErrorModel () { diff --git a/src/internet/test/tcp-cong-avoid-test.cc b/src/internet/test/tcp-cong-avoid-test.cc index c95917e73..4b6454a4e 100644 --- a/src/internet/test/tcp-cong-avoid-test.cc +++ b/src/internet/test/tcp-cong-avoid-test.cc @@ -31,11 +31,30 @@ TcpNewRenoCongAvoidNormalTest::TcpNewRenoCongAvoidNormalTest (uint32_t segmentSi uint32_t packets, TypeId &typeId, const std::string &desc) - : TcpGeneralTest (desc, packetSize, packets, Seconds (0.01), Seconds (0.5), - Seconds (10), 0, 1, segmentSize, typeId, 1500), + : TcpGeneralTest (desc), + m_segmentSize (segmentSize), + m_packetSize (packetSize), + m_packets (packets), m_increment (0), m_initial (true) { + m_congControlTypeId = typeId; +} + +void +TcpNewRenoCongAvoidNormalTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktSize (m_packetSize); + SetAppPktCount (m_packets); + SetMTU (1500); +} + +void TcpNewRenoCongAvoidNormalTest::ConfigureProperties () +{ + TcpGeneralTest::ConfigureProperties (); + SetSegmentSize (SENDER, m_segmentSize); + SetInitialSsThresh (SENDER, 0); } /** diff --git a/src/internet/test/tcp-cong-avoid-test.h b/src/internet/test/tcp-cong-avoid-test.h index 08929700a..b239fb08a 100644 --- a/src/internet/test/tcp-cong-avoid-test.h +++ b/src/internet/test/tcp-cong-avoid-test.h @@ -48,7 +48,7 @@ namespace ns3 { * it checks that the increment has not passed the 1 MSS limit. */ class - TcpNewRenoCongAvoidNormalTest : public TcpGeneralTest +TcpNewRenoCongAvoidNormalTest : public TcpGeneralTest { public: TcpNewRenoCongAvoidNormalTest (uint32_t segmentSize, uint32_t packetSize, @@ -61,6 +61,13 @@ protected: void NormalClose (SocketWho who); void Check (); + void ConfigureEnvironment (); + void ConfigureProperties (); + +private: + uint32_t m_segmentSize; + uint32_t m_packetSize; + uint32_t m_packets; uint32_t m_increment; EventId m_event; bool m_initial; diff --git a/src/internet/test/tcp-datasentcb-test.cc b/src/internet/test/tcp-datasentcb-test.cc index 382ef2985..20ee21763 100644 --- a/src/internet/test/tcp-datasentcb-test.cc +++ b/src/internet/test/tcp-datasentcb-test.cc @@ -66,7 +66,7 @@ TcpSocketHalfAck::Fork (void) } void -TcpSocketHalfAck::ReceivedData(Ptr packet, const TcpHeader &tcpHeader) +TcpSocketHalfAck::ReceivedData (Ptr packet, const TcpHeader &tcpHeader) { NS_LOG_FUNCTION (this << packet << tcpHeader); static uint32_t times = 1; @@ -74,7 +74,7 @@ TcpSocketHalfAck::ReceivedData(Ptr packet, const TcpHeader &tcpHeader) Ptr halved = packet->Copy (); if (times % 2 == 0) - halved->RemoveAtEnd (packet->GetSize() / 2); + halved->RemoveAtEnd (packet->GetSize () / 2); times++; @@ -95,7 +95,9 @@ class TcpDataSentCbTestCase : public TcpGeneralTest { public: TcpDataSentCbTestCase (const std::string &desc, uint32_t size, uint32_t packets) : - TcpGeneralTest (desc, size, packets), + TcpGeneralTest (desc), + m_pktSize (size), + m_pktCount (packets), m_notifiedData (0) { } @@ -103,13 +105,23 @@ protected: virtual Ptr CreateReceiverSocket (Ptr node); virtual void DataSent (uint32_t size, SocketWho who); - + virtual void ConfigureEnvironment (); virtual void FinalChecks (); private: + uint32_t m_pktSize; + uint32_t m_pktCount; uint32_t m_notifiedData; }; +void +TcpDataSentCbTestCase::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (m_pktCount); + SetAppPktSize (m_pktSize); +} + void TcpDataSentCbTestCase::DataSent (uint32_t size, SocketWho who) { @@ -119,9 +131,9 @@ TcpDataSentCbTestCase::DataSent (uint32_t size, SocketWho who) } void -TcpDataSentCbTestCase::FinalChecks() +TcpDataSentCbTestCase::FinalChecks () { - NS_TEST_ASSERT_MSG_EQ (m_notifiedData, GetPktSize () * GetPktCount () , + NS_TEST_ASSERT_MSG_EQ (m_notifiedData, GetPktSize () * GetPktCount (), "Notified more data than application sent"); } diff --git a/src/internet/test/tcp-fast-retr-test.cc b/src/internet/test/tcp-fast-retr-test.cc index 18d39afaa..ab0c0c8f2 100644 --- a/src/internet/test/tcp-fast-retr-test.cc +++ b/src/internet/test/tcp-fast-retr-test.cc @@ -27,17 +27,31 @@ NS_LOG_COMPONENT_DEFINE ("TcpFastRetrTest"); TcpFastRetrTest::TcpFastRetrTest (TypeId typeId, uint32_t seqToKill, const std::string &msg) - : TcpGeneralTest (msg, 500, 100, Seconds (0.01), Seconds (0.5), Seconds (10), - 0, 1, 500, typeId, 1500), - m_pktDropped (false), - m_pktWasDropped (false), - m_seqToKill (seqToKill), - m_dupAckReceived (0), - m_sndNextExpSeq (0), - m_rcvNextExpAck (1), - m_countRetr (0), - m_bytesRcvButNotAcked (0) + : TcpGeneralTest (msg), + m_pktDropped (false), + m_pktWasDropped (false), + m_seqToKill (seqToKill), + m_dupAckReceived (0), + m_sndNextExpSeq (0), + m_rcvNextExpAck (1), + m_countRetr (0), + m_bytesRcvButNotAcked (0) { + m_congControlTypeId = typeId; +} + +void +TcpFastRetrTest::ConfigureProperties () +{ + TcpGeneralTest::ConfigureProperties (); + SetInitialSsThresh (SENDER, 0); +} + +void +TcpFastRetrTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (100); } Ptr @@ -218,7 +232,7 @@ TcpFastRetrTest::RcvAck (const Ptr tcb, const TcpHeader &h NS_TEST_ASSERT_MSG_EQ (GetDupAckCount (SENDER), m_dupAckReceived, "Dupack count differs"); - if (GetDupAckCount(SENDER) == 0 && + if (GetDupAckCount (SENDER) == 0 && GetDupAckCount (SENDER) < GetReTxThreshold (SENDER)) { NS_TEST_ASSERT_MSG_EQ (GetCongStateFrom (tcb), TcpSocketState::CA_OPEN, @@ -288,7 +302,7 @@ TcpFastRetrTest::ProcessedAck (const Ptr tcb, const TcpHea } void -TcpFastRetrTest::RTOExpired(const Ptr tcb, SocketWho who) +TcpFastRetrTest::RTOExpired (const Ptr tcb, SocketWho who) { NS_ASSERT_MSG (true == false, "RTO isn't expected here"); } diff --git a/src/internet/test/tcp-fast-retr-test.h b/src/internet/test/tcp-fast-retr-test.h index 9d33a4d6d..2ef1820a6 100644 --- a/src/internet/test/tcp-fast-retr-test.h +++ b/src/internet/test/tcp-fast-retr-test.h @@ -58,7 +58,10 @@ protected: virtual void RTOExpired (const Ptr tcb, SocketWho who); void PktDropped (const Ipv4Header &ipH, const TcpHeader& tcpH, Ptr p); - void FinalChecks (); + virtual void FinalChecks (); + + virtual void ConfigureProperties (); + virtual void ConfigureEnvironment (); bool m_pktDropped; bool m_pktWasDropped; diff --git a/src/internet/test/tcp-general-test.cc b/src/internet/test/tcp-general-test.cc index 794467696..aafe216f0 100644 --- a/src/internet/test/tcp-general-test.cc +++ b/src/internet/test/tcp-general-test.cc @@ -32,25 +32,9 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("TcpGeneralTest"); -TcpGeneralTest::TcpGeneralTest (const std::string &desc, - uint32_t pktSize, uint32_t pktCount, - const Time& pktInterval, - const Time& propagationDelay, const Time& startTime, - uint32_t initialSlowStartThresh, uint32_t initialCwnd, - uint32_t segmentSize, - TypeId congestionControl, - uint32_t mtu) +TcpGeneralTest::TcpGeneralTest (const std::string &desc) : 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_congControlTypeId (TcpNewReno::GetTypeId ()), m_remoteAddr (Ipv4Address::GetAny (), 4477) { NS_LOG_FUNCTION (this << desc); @@ -104,9 +88,35 @@ TcpGeneralTest::DoTeardown (void) NS_LOG_INFO ("Done."); } +void +TcpGeneralTest::ConfigureEnvironment () +{ + NS_LOG_FUNCTION (this); + + SetCongestionControl (m_congControlTypeId); + SetPropagationDelay (MilliSeconds (500)); + SetTransmitStart (Seconds (10)); + SetAppPktSize (500); + SetAppPktCount (10); + SetAppPktInterval (MilliSeconds (1)); + SetMTU (1500); +} + +void +TcpGeneralTest::ConfigureProperties () +{ + NS_LOG_FUNCTION (this); + SetInitialCwnd (SENDER, 1); + SetInitialSsThresh (SENDER, UINT32_MAX); + SetSegmentSize (SENDER, 500); + SetSegmentSize (RECEIVER, 500); +} + void TcpGeneralTest::DoRun (void) { + ConfigureEnvironment (); + NS_LOG_INFO ("Create nodes."); NodeContainer nodes; nodes.Create (2); @@ -170,10 +180,7 @@ TcpGeneralTest::DoRun (void) m_receiverSocket->TraceConnectWithoutContext ("Rx", MakeCallback (&TcpGeneralTest::RxPacketCb, this)); - InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 4477); - m_receiverSocket->Bind (local); - m_receiverSocket->Listen (); - m_receiverSocket->ShutdownSend (); + InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 4477); m_receiverSocket->Bind (local); m_senderSocket = CreateSenderSocket (nodes.Get (0)); m_senderSocket->SetCloseCallbacks (MakeCallback (&TcpGeneralTest::NormalCloseCb, this), @@ -185,6 +192,8 @@ TcpGeneralTest::DoRun (void) m_senderSocket->SetUpdateRttHistoryCb (MakeCallback (&TcpGeneralTest::UpdateRttHistoryCb, this)); m_senderSocket->TraceConnectWithoutContext ("CongestionWindow", MakeCallback (&TcpGeneralTest::CWndTrace, this)); + m_senderSocket->TraceConnectWithoutContext ("SlowStartThreshold", + MakeCallback (&TcpGeneralTest::SsThreshTrace, this)); m_senderSocket->TraceConnectWithoutContext ("CongState", MakeCallback (&TcpGeneralTest::CongStateTrace, this)); m_senderSocket->TraceConnectWithoutContext ("Tx", @@ -198,6 +207,11 @@ TcpGeneralTest::DoRun (void) m_remoteAddr = InetSocketAddress (serverAddress, 4477); + ConfigureProperties (); + + m_receiverSocket->Listen (); + m_receiverSocket->ShutdownSend (); + Simulator::Schedule (Seconds (0.0), &TcpGeneralTest::DoConnect, this); Simulator::ScheduleWithContext (nodes.Get (0)->GetId (), @@ -256,10 +270,6 @@ TcpGeneralTest::CreateSocket (Ptr node, TypeId socketType, socket->SetRtt (rtt); socket->SetCongestionControlAlgorithm (algo); - socket->SetAttribute ("InitialSlowStartThreshold", UintegerValue (m_initialSlowStartThresh)); - socket->SetAttribute ("SegmentSize", UintegerValue (m_segmentSize)); - socket->SetAttribute ("InitialCwnd", UintegerValue (m_initialCwnd)); - return socket; } @@ -586,6 +596,40 @@ TcpGeneralTest::GetSegSize (SocketWho who) } } +uint32_t +TcpGeneralTest::GetInitialCwnd (SocketWho who) +{ + if (who == SENDER) + { + return DynamicCast (m_senderSocket)->GetInitialCwnd (); + } + else if (who == RECEIVER) + { + return DynamicCast (m_receiverSocket)->GetInitialCwnd (); + } + else + { + NS_FATAL_ERROR ("Not defined"); + } +} + +uint32_t +TcpGeneralTest::GetInitialSsThresh (SocketWho who) +{ + if (who == SENDER) + { + return DynamicCast (m_senderSocket)->GetInitialSSThresh (); + } + else if (who == RECEIVER) + { + return DynamicCast (m_receiverSocket)->GetInitialSSThresh (); + } + else + { + NS_FATAL_ERROR ("Not defined"); + } +} + Time TcpGeneralTest::GetRto (SocketWho who) { @@ -778,6 +822,57 @@ TcpGeneralTest::SetRcvBufSize (SocketWho who, uint32_t size) } } +void +TcpGeneralTest::SetSegmentSize (SocketWho who, uint32_t segmentSize) +{ + if (who == SENDER) + { + m_senderSocket->SetSegSize (segmentSize); + } + else if (who == RECEIVER) + { + m_receiverSocket->SetSegSize (segmentSize); + } + else + { + NS_FATAL_ERROR ("Not defined"); + } +} + +void +TcpGeneralTest::SetInitialCwnd (SocketWho who, uint32_t initialCwnd) +{ + if (who == SENDER) + { + m_senderSocket->SetInitialCwnd (initialCwnd); + } + else if (who == RECEIVER) + { + m_receiverSocket->SetInitialCwnd (initialCwnd); + } + else + { + NS_FATAL_ERROR ("Not defined"); + } +} + +void +TcpGeneralTest::SetInitialSsThresh (SocketWho who, uint32_t initialSsThresh) +{ + if (who == SENDER) + { + m_senderSocket->SetInitialSSThresh (initialSsThresh); + } + else if (who == RECEIVER) + { + m_receiverSocket->SetInitialSSThresh (initialSsThresh); + } + else + { + NS_FATAL_ERROR ("Not defined"); + } +} + NS_OBJECT_ENSURE_REGISTERED (TcpSocketMsgBase); TypeId diff --git a/src/internet/test/tcp-general-test.h b/src/internet/test/tcp-general-test.h index 9e805a52a..fd08c2391 100644 --- a/src/internet/test/tcp-general-test.h +++ b/src/internet/test/tcp-general-test.h @@ -147,7 +147,7 @@ public: { } - TcpSocketSmallAcks (const TcpSocketSmallAcks &other) + TcpSocketSmallAcks (const TcpSocketSmallAcks &other) : TcpSocketMsgBase (other), m_bytesToAck (other.m_bytesToAck), m_bytesLeftToBeAcked (other.m_bytesLeftToBeAcked), @@ -213,25 +213,12 @@ public: /** * \brief TcpGeneralTest constructor * - * \param pktSize application packet size - * \param pktCount count of application packet to generate - * \param pktInterval (application) interval between each generated packet - * \param propagationDelay propagation delay of the channel - * \param startTime time of the first application-generated packet - * \param mtu MTU of the environment + * Please use the method ConfigureEnvironment () to configure other + * parameters than the test description. + * * \param desc description of the test */ - TcpGeneralTest (const std::string &desc, - uint32_t pktSize = 500, - uint32_t pktCount = 10, - const Time& pktInterval = Seconds (0.01), - const Time& propagationDelay = Seconds (0.5), - const Time& startTime = Seconds (10), - uint32_t initialSlowStartThresh = 0xffff, - uint32_t initialCwnd = 1, - uint32_t segmentSize = 500, - TypeId congestionControl = TcpNewReno::GetTypeId (), - uint32_t mtu = 1500); + TcpGeneralTest (const std::string &desc); ~TcpGeneralTest (); /** @@ -314,9 +301,28 @@ protected: * As environment, two socket are connected through a SimpleChannel. Each device * has an MTU of 1500 bytes, and the application starts to send packet at * 10s of simulated time, through SendPacket. + * + * If you need to change parameters of the environment, please inherit an + * implement the method ConfigureEnvironment (); that will be called at the + * beginning of this method. To configure Socket parameters (i.e. parameters + * that should be applied after socket have been created) use ConfigureProperties. + * + * Please do not use any Config:: statements. + * + * \see ConfigureEnvironment */ virtual void DoRun (void); + /** + * \brief Change the configuration of the evironment + */ + virtual void ConfigureEnvironment (void); + + /** + * \brief Change the configuration of the socket properties + */ + virtual void ConfigureProperties (void); + /** * \brief Teardown the TCP test */ @@ -362,6 +368,18 @@ protected: */ uint32_t GetReTxThreshold (SocketWho who); + /** + * \brief Get the initial slow start threshold + * \return initial slow start threshold + */ + uint32_t GetInitialSsThresh (SocketWho who); + + /** + * \brief Get the initial congestion window + * \return initial cwnd + */ + uint32_t GetInitialCwnd (SocketWho who); + /** * \brief Get the number of dupack received * \param who node to get the parameter from @@ -471,6 +489,83 @@ protected: */ void SetRcvBufSize (SocketWho who, uint32_t size); + /** + * \brief Forcefully set the segment size + * + * \param who socket to force + * \param segmentSize segmentSize + */ + void SetSegmentSize (SocketWho who, uint32_t segmentSize); + + /** + * \brief Forcefully set the initial cwnd + * + * \param who socket to force + * \param initialCwnd size of the initial cwnd + */ + void SetInitialCwnd (SocketWho who, uint32_t initialCwnd); + + /** + * \brief Forcefully set the initial ssth + * + * \param who socket to force + * \param initialSsThresh size of the initial ssth + */ + void SetInitialSsThresh (SocketWho who, uint32_t initialSsThresh); + + /** + * \brief Set app packet size + * + * The application will generate packet of this size. + * + * \param pktSize size of the packet + */ + void SetAppPktSize (uint32_t pktSize) { m_pktSize = pktSize; } + + /** + * \brief Set app packet count + * + * The application will generate this count of packets. + * + * \param pktCount count of packets to generate + */ + void SetAppPktCount (uint32_t pktCount) { m_pktCount = pktCount; } + + /** + * \brief Interval between app-generated packet + * + * \param pktInterval interval + */ + void SetAppPktInterval (Time pktInterval) { m_interPacketInterval = pktInterval; } + + /** + * \brief Propagation delay of the bottleneck link + * + * \param propDelay propagation delay + */ + void SetPropagationDelay (Time propDelay) { m_propagationDelay = propDelay; } + + /** + * \brief Set the initial time at which the application sends the first data packet + * + * \param startTime start time + */ + void SetTransmitStart (Time startTime) { m_startTime = startTime; } + + /** + * \brief Congestion control of the sender socket + * + * \param congControl typeid of the congestion control algorithm + */ + void SetCongestionControl (TypeId congControl) { m_congControlTypeId = congControl; } + + /** + * \brief MTU of the bottleneck link + * + * \param mtu MTU + */ + void SetMTU (uint32_t mtu) { m_mtu = mtu; } + /** * \brief State on Ack state machine changes * \param oldValue old value @@ -503,6 +598,19 @@ protected: { } + /** + * \brief Slow start threshold changes + * + * This applies only for sender socket. + * + * + * \param oldValue old value + * \param newValue new value + */ + virtual void SsThreshTrace (uint32_t oldValue, uint32_t newValue) + { + } + /** * \brief Bytes in flight changes * @@ -690,25 +798,6 @@ protected: return m_interPacketInterval; } - /** - * \brief Get the initial slow start threshold - * \return initial slow start threshold - */ - uint32_t GetInitialSsThresh () const - { - return m_initialSlowStartThresh; - } - - /** - * \brief Get the initial congestion window - * \return initial cwnd - */ - uint32_t GetInitialCwnd () const - { - return m_initialCwnd; - } - - TypeId m_congControlTypeId; //!< Congestion control private: @@ -723,9 +812,6 @@ private: uint32_t m_pktCount; //!< Count of the application packet Time m_interPacketInterval; //!< Time between sending application packet // down to tcp socket - uint32_t m_initialSlowStartThresh; //!< Initial slow start threshold - uint32_t m_initialCwnd; //!< Initial congestion window - uint32_t m_segmentSize; //!< Segment size Ptr m_senderSocket; //!< Pointer to sender socket Ptr m_receiverSocket; //!< Pointer to receiver socket diff --git a/src/internet/test/tcp-pkts-acked-test.cc b/src/internet/test/tcp-pkts-acked-test.cc index adcd8c2cb..a89f85094 100644 --- a/src/internet/test/tcp-pkts-acked-test.cc +++ b/src/internet/test/tcp-pkts-acked-test.cc @@ -50,6 +50,8 @@ protected: virtual Ptr CreateSenderSocket (Ptr node); virtual void Rx (const Ptr p, const TcpHeader&h, SocketWho who); + virtual void ConfigureEnvironment (); + void FinalChecks (); private: @@ -94,13 +96,20 @@ DummyCongControl::GetTypeId (void) } TcpPktsAckedOpenTest::TcpPktsAckedOpenTest (const std::string &desc) - : TcpGeneralTest (desc, 500, 20, Seconds (0.01), Seconds (0.05), Seconds (2.0), - 0xffffffff,1, 500), + : TcpGeneralTest (desc), m_segmentsAcked (0), m_segmentsReceived (0) { } +void +TcpPktsAckedOpenTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (20); + SetMTU (500); +} + Ptr TcpPktsAckedOpenTest::CreateSenderSocket (Ptr node) { diff --git a/src/internet/test/tcp-rto-test.cc b/src/internet/test/tcp-rto-test.cc index 95fd01e2b..69363dc58 100644 --- a/src/internet/test/tcp-rto-test.cc +++ b/src/internet/test/tcp-rto-test.cc @@ -28,11 +28,25 @@ namespace ns3 { NS_LOG_COMPONENT_DEFINE ("TcpRtoTest"); TcpRtoTest::TcpRtoTest (TypeId &congControl, const std::string &desc) - : TcpGeneralTest (desc, 500, 100, Seconds (0.01), Seconds (0.5), - Seconds (10), 0, 1, 500, congControl, 1500), - m_rtoExpired (false), - m_segmentReceived (false) + : TcpGeneralTest (desc), + m_rtoExpired (false), + m_segmentReceived (false) { + m_congControlTypeId = congControl; +} + +void +TcpRtoTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (100); +} + +void +TcpRtoTest::ConfigureProperties () +{ + TcpGeneralTest::ConfigureProperties (); + SetInitialSsThresh (SENDER, 0); } Ptr @@ -114,14 +128,21 @@ TcpRtoTest::FinalChecks () // TcpTimeRtoTest TcpTimeRtoTest::TcpTimeRtoTest (TypeId &congControl, const std::string &desc) - : TcpGeneralTest (desc, 500, 100, Seconds (0.01), Seconds (0.5), - Seconds (10), 0xffff, 1, 500, congControl, 1500), - m_senderSentSegments (0), - m_closed (false) + : TcpGeneralTest (desc), + m_senderSentSegments (0), + m_closed (false) { - + m_congControlTypeId = congControl; } +void +TcpTimeRtoTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (100); +} + + Ptr TcpTimeRtoTest::CreateSenderSocket (Ptr node) { diff --git a/src/internet/test/tcp-rto-test.h b/src/internet/test/tcp-rto-test.h index 0e298b830..4000a0f62 100644 --- a/src/internet/test/tcp-rto-test.h +++ b/src/internet/test/tcp-rto-test.h @@ -47,6 +47,8 @@ protected: virtual void ProcessedAck (const Ptr tcb, const TcpHeader& h, SocketWho who); virtual void FinalChecks (); + virtual void ConfigureProperties (); + virtual void ConfigureEnvironment (); private: bool m_rtoExpired; @@ -71,6 +73,8 @@ protected: virtual void Tx (const Ptr p, const TcpHeader&h, SocketWho who); virtual void FinalChecks (); + virtual void ConfigureEnvironment (); + void PktDropped (const Ipv4Header &ipH, const TcpHeader& tcpH, Ptr p); private: diff --git a/src/internet/test/tcp-rtt-estimation.cc b/src/internet/test/tcp-rtt-estimation.cc index 52e149ee4..21d79a8eb 100644 --- a/src/internet/test/tcp-rtt-estimation.cc +++ b/src/internet/test/tcp-rtt-estimation.cc @@ -50,21 +50,35 @@ protected: virtual void RttTrace (Time oldTime, Time newTime); void FinalChecks (); + virtual void ConfigureEnvironment (); + private: bool m_enableTs; bool m_rttChanged; SequenceNumber32 m_highestTxSeq; + uint32_t m_pktCount; }; -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), +TcpRttEstimationTest::TcpRttEstimationTest (const std::string &desc, bool enableTs, + uint32_t pktCount) + : TcpGeneralTest (desc), m_enableTs (enableTs), m_rttChanged (false), - m_highestTxSeq (0) + m_highestTxSeq (0), + m_pktCount (pktCount) { } +void +TcpRttEstimationTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (m_pktCount); + SetPropagationDelay (MilliSeconds (50)); + SetTransmitStart (Seconds (2.0)); + SetMTU (500); +} + Ptr TcpRttEstimationTest::CreateReceiverSocket (Ptr node) { diff --git a/src/internet/test/tcp-slow-start-test.cc b/src/internet/test/tcp-slow-start-test.cc index 64ece9217..7a2225125 100644 --- a/src/internet/test/tcp-slow-start-test.cc +++ b/src/internet/test/tcp-slow-start-test.cc @@ -34,14 +34,46 @@ TcpSlowStartNormalTest::TcpSlowStartNormalTest (uint32_t segmentSize, uint32_t packets, TypeId &typeId, const std::string &desc) - : TcpGeneralTest (desc, packetSize, packets, Seconds (0.01), Seconds (0.5), - Seconds (10), initSsTh, 1, segmentSize, typeId, 1500), - m_ackedBytes (0), - m_sentBytes (0), - m_totalAckedBytes (0), - m_allowedIncrease (0), - m_initial (true) + : TcpGeneralTest (desc), + m_ackedBytes (0), + m_sentBytes (0), + m_totalAckedBytes (0), + m_allowedIncrease (0), + m_initial (true), + m_segmentSize (segmentSize), + m_packetSize (packetSize), + m_packets (packets) { + m_congControlTypeId = typeId; +} + +void +TcpSlowStartNormalTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (m_packets); + SetAppPktSize (m_packetSize); +} + +void +TcpSlowStartNormalTest::ConfigureProperties () +{ + TcpGeneralTest::ConfigureProperties (); + SetInitialSsThresh (SENDER, 400000); + SetSegmentSize (SENDER, m_segmentSize); + SetSegmentSize (RECEIVER, m_segmentSize); +} + +void +TcpSlowStartNormalTest::QueueDrop (SocketWho who) +{ + NS_FATAL_ERROR ("Drop on the queue; cannot validate slow start"); +} + +void +TcpSlowStartNormalTest::PhyDrop (SocketWho who) +{ + NS_FATAL_ERROR ("Drop on the phy: cannot validate slow start"); } /** @@ -71,7 +103,7 @@ TcpSlowStartNormalTest::CWndTrace (uint32_t oldValue, uint32_t newValue) // The increase in RFC should be <= of segSize. In ns-3 we force = segSize NS_TEST_ASSERT_MSG_EQ (increase, segSize, "Increase different than segsize"); - NS_TEST_ASSERT_MSG_LT_OR_EQ (newValue, GetInitialSsThresh (), "cWnd increased over ssth"); + NS_TEST_ASSERT_MSG_LT_OR_EQ (newValue, GetInitialSsThresh (SENDER), "cWnd increased over ssth"); NS_LOG_INFO ("Incremented cWnd by " << segSize << " bytes in Slow Start " << "achieving a value of " << newValue); @@ -98,7 +130,7 @@ TcpSlowStartNormalTest::Rx (const Ptr p, const TcpHeader &h, Socke if (who == SENDER && Simulator::Now ().GetSeconds () > 5.0) { - uint32_t acked = h.GetAckNumber().GetValue() - m_totalAckedBytes - 1; + uint32_t acked = h.GetAckNumber ().GetValue () - m_totalAckedBytes - 1; m_totalAckedBytes += acked; m_ackedBytes += acked; diff --git a/src/internet/test/tcp-slow-start-test.h b/src/internet/test/tcp-slow-start-test.h index 3eaed8a32..a49db5dcd 100644 --- a/src/internet/test/tcp-slow-start-test.h +++ b/src/internet/test/tcp-slow-start-test.h @@ -37,7 +37,7 @@ namespace ns3 { * \see CWndTrace */ class - TcpSlowStartNormalTest : public TcpGeneralTest +TcpSlowStartNormalTest : public TcpGeneralTest { public: TcpSlowStartNormalTest (uint32_t segmentSize, uint32_t packetSize, @@ -48,6 +48,11 @@ protected: virtual void CWndTrace (uint32_t oldValue, uint32_t newValue); virtual void Tx (const Ptr p, const TcpHeader &h, SocketWho who); virtual void Rx (const Ptr p, const TcpHeader &h, SocketWho who); + void QueueDrop (SocketWho who); + void PhyDrop (SocketWho who); + + virtual void ConfigureEnvironment (); + virtual void ConfigureProperties (); uint32_t m_ackedBytes; uint32_t m_sentBytes; @@ -56,6 +61,11 @@ protected: bool m_initial; +private: + uint32_t m_segmentSize; + uint32_t m_packetSize; + uint32_t initialSsTh; + uint32_t m_packets; }; /** @@ -67,7 +77,7 @@ protected: * Slow start behavior should not change. */ class - TcpSlowStartAttackerTest : public TcpSlowStartNormalTest +TcpSlowStartAttackerTest : public TcpSlowStartNormalTest { public: TcpSlowStartAttackerTest (uint32_t segmentSize, uint32_t packetSize, diff --git a/src/internet/test/tcp-zero-window-test.cc b/src/internet/test/tcp-zero-window-test.cc index d9213a2af..82a18a0f3 100644 --- a/src/internet/test/tcp-zero-window-test.cc +++ b/src/internet/test/tcp-zero-window-test.cc @@ -42,6 +42,9 @@ protected: void NormalClose (SocketWho who); void FinalChecks (); + virtual void ConfigureEnvironment (); + virtual void ConfigureProperties (); + void IncreaseBufSize (); protected: @@ -53,15 +56,31 @@ protected: }; TcpZeroWindowTest::TcpZeroWindowTest (const std::string &desc) - : TcpGeneralTest (desc, 500, 20, Seconds (0.01), Seconds (0.05), Seconds (2.0), - 0xffffffff, 10, 500), - m_zeroWindowProbe (false), - m_windowUpdated (false), - m_senderFinished (false), - m_receiverFinished (false) + : TcpGeneralTest (desc), + m_zeroWindowProbe (false), + m_windowUpdated (false), + m_senderFinished (false), + m_receiverFinished (false) { } +void +TcpZeroWindowTest::ConfigureEnvironment () +{ + TcpGeneralTest::ConfigureEnvironment (); + SetAppPktCount (20); + SetMTU (500); + SetTransmitStart (Seconds (2.0)); + SetPropagationDelay (MilliSeconds (50)); +} + +void +TcpZeroWindowTest::ConfigureProperties () +{ + TcpGeneralTest::ConfigureProperties (); + SetInitialCwnd (SENDER, 10); +} + void TcpZeroWindowTest::IncreaseBufSize () {