A Discrete-Event Network Simulator
API
tcp-scalable-test.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2016 ResiliNets, ITTC, University of Kansas
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Authors: Truc Anh N. Nguyen <annguyen@ittc.ku.edu>
19 
20  * James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
21  * ResiliNets Research Group http://wiki.ittc.ku.edu/resilinets
22  * Information and Telecommunication Technology Center (ITTC)
23  * and Department of Electrical Engineering and Computer Science
24  * The University of Kansas Lawrence, KS USA.
25  *
26  */
27 
28 #include "ns3/test.h"
29 #include "ns3/log.h"
30 #include "ns3/tcp-congestion-ops.h"
31 #include "ns3/tcp-socket-base.h"
32 #include "ns3/tcp-scalable.h"
33 
34 using namespace ns3;
35 
36 NS_LOG_COMPONENT_DEFINE ("TcpScalableTestSuite");
37 
45 {
46 public:
54  TcpScalableIncrementTest (uint32_t cWnd, uint32_t segmentSize,
55  uint32_t segmentsAcked,
56  const std::string &name);
57 
58 private:
59  virtual void DoRun (void);
60 
61  uint32_t m_cWnd;
62  uint32_t m_segmentSize;
63  uint32_t m_segmentsAcked;
65 };
66 
68  uint32_t segmentSize,
69  uint32_t segmentsAcked,
70  const std::string &name)
71  : TestCase (name),
72  m_cWnd (cWnd),
73  m_segmentSize (segmentSize),
74  m_segmentsAcked (segmentsAcked)
75 {
76 }
77 
78 void
80 {
81  m_state = CreateObject<TcpSocketState> ();
82 
85 
86  Ptr<TcpScalable> cong = CreateObject <TcpScalable> ();
87 
88  uint32_t segCwnd = m_cWnd / m_segmentSize;
89 
90  // Get default value of additive increase factor
91  UintegerValue aiFactor;
92  cong->GetAttribute ("AIFactor", aiFactor);
93 
94  // To see an increase of 1 MSS, the number of segments ACKed has to be at least
95  // min (segCwnd, aiFactor).
96 
97  uint32_t w = std::min (segCwnd, (uint32_t) aiFactor.Get ());
98  uint32_t delta = m_segmentsAcked / w;
99 
101 
103  "CWnd has not increased");
104 }
105 
113 {
114 public:
121  TcpScalableDecrementTest (uint32_t cWnd, uint32_t segmentSize,
122  const std::string &name);
123 
124 private:
125  virtual void DoRun (void);
126 
127  uint32_t m_cWnd;
128  uint32_t m_segmentSize;
130 };
131 
133  uint32_t segmentSize,
134  const std::string &name)
135  : TestCase (name),
136  m_cWnd (cWnd),
137  m_segmentSize (segmentSize)
138 {
139 }
140 
141 void
143 {
144  m_state = CreateObject<TcpSocketState> ();
145 
146  m_state->m_cWnd = m_cWnd;
148 
149  Ptr<TcpScalable> cong = CreateObject <TcpScalable> ();
150 
151  uint32_t segCwnd = m_cWnd / m_segmentSize;
152 
153  // Get default value of multiplicative decrease factor
154  DoubleValue mdFactor;
155  cong->GetAttribute ("MDFactor", mdFactor);
156 
157  double b = 1.0 - mdFactor.Get ();
158 
159  uint32_t ssThresh = std::max (2.0, segCwnd * b);
160 
161  uint32_t ssThreshInSegments = cong->GetSsThresh (m_state, m_state->m_cWnd) / m_segmentSize;
162 
163  NS_TEST_ASSERT_MSG_EQ (ssThreshInSegments, ssThresh,
164  "Scalable decrement fn not used");
165 }
166 
167 
175 {
176 public:
177  TcpScalableTestSuite () : TestSuite ("tcp-scalable-test", UNIT)
178  {
179  AddTestCase (new TcpScalableIncrementTest (38 * 536, 536, 38,
180  "Scalable increment test on cWnd = 38 segments and segmentSize = 536 bytes"),
181  TestCase::QUICK);
182  AddTestCase (new TcpScalableIncrementTest (38, 1, 100,
183  "Scalable increment test on cWnd = 38 segments and segmentSize = 1 byte"),
184  TestCase::QUICK);
185  AddTestCase (new TcpScalableIncrementTest (53 * 1446, 1446, 50,
186  "Scalable increment test on cWnd = 53 segments and segmentSize = 1446 bytes"),
187  TestCase::QUICK);
188 
190  "Scalable decrement test on cWnd = 38 segments and segmentSize = 1 byte"),
191  TestCase::QUICK);
192  AddTestCase (new TcpScalableDecrementTest (100 * 536, 536,
193  "Scalable decrement test on cWnd = 100 segments and segmentSize = 536 bytes"),
194  TestCase::QUICK);
195  AddTestCase (new TcpScalableDecrementTest (40 * 1446, 1446,
196  "Scalable decrement test on cWnd = 40 segments and segmentSize = 1446 bytes"),
197  TestCase::QUICK);
198 
199  }
200 };
201 
203 
uint32_t m_segmentsAcked
Segments ACKed.
#define min(a, b)
Definition: 80211b.c:42
A suite of tests to run.
Definition: test.h:1342
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:204
uint32_t m_segmentSize
Segment size.
virtual void IncreaseWindow(Ptr< TcpSocketState > tcb, uint32_t segmentsAcked)
Try to increase the cWnd following the NewReno specification.
encapsulates test code
Definition: test.h:1155
uint32_t m_cWnd
Congestion window.
virtual void DoRun(void)
Implementation to actually run this TestCase.
#define max(a, b)
Definition: 80211b.c:43
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
Hold an unsigned integer type.
Definition: uinteger.h:44
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:168
uint32_t m_segmentSize
Segment size.
TcpScalableIncrementTest(uint32_t cWnd, uint32_t segmentSize, uint32_t segmentsAcked, const std::string &name)
Constructor.
uint64_t Get(void) const
Definition: uinteger.cc:35
double Get(void) const
Definition: double.cc:35
Every class exported by the ns3 library is enclosed in the ns3 namespace.
static TcpScalableTestSuite g_tcpScalableTest
Static variable for test initialization.
Ptr< TcpSocketState > m_state
TCP socket state.
TcpScalableDecrementTest(uint32_t cWnd, uint32_t segmentSize, const std::string &name)
Constructor.
TracedValue< uint32_t > m_cWnd
Congestion window.
Testing the congestion avoidance increment on TcpScalable.
TcpScalable TestSuite.
T Get(void) const
Get the underlying value.
Definition: traced-value.h:218
uint32_t m_segmentSize
Segment size.
Ptr< TcpSocketState > m_state
TCP socket state.
This test suite implements a Unit Test.
Definition: test.h:1351
virtual void DoRun(void)
Implementation to actually run this TestCase.
This class can be used to hold variables of floating point type such as &#39;double&#39; or &#39;float&#39;...
Definition: double.h:41
void GetAttribute(std::string name, AttributeValue &value) const
Get the value of an attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:223
virtual uint32_t GetSsThresh(Ptr< const TcpSocketState > tcb, uint32_t bytesInFlight)
Get slow start threshold following Scalable principle (Equation 2)
uint32_t m_cWnd
Congestion window.
Testing the multiplicative decrease on TcpScalable.