Designing a new variant of TCP protocol using NS

Location of relevant files of NS
- Assume that the NS source files are located in the directory NS_DIR
  (If you have followed the instructions in this page ( click here), the directory NS_DIR will be ~/cs558/NS)
- These files are relevant for the TCP protocol implementation in NS:
  - NS_DIR/tcp/tcp.h - header file
  - NS_DIR/tcp/tcp.cc - TCP protocol
- The NS source copy of these files that I used to teach teach this class are located here:
  - NS_DIR/tcp/tcp.h: click here
  - NS_DIR/tcp.cc: click here

Important variables in the TCP protocol

The TCP agent in NS is a C++ class.

The name of the TCP agent class is TcpAgent and the source code can be found in the files tcp.h and tcp.cc.

The header definition is as follows:

class TcpAgent : public Agent { friend class XcpEndsys; public: TcpAgent(); virtual ~TcpAgent() {free(tss);} virtual void recv(Packet*, Handler*); virtual void timeout(int tno); virtual void timeout_nonrtx(int tno); int command(int argc, const char*const* argv); virtual void sendmsg(int nbytes, const char *flags = 0); void trace(TracedVar* v); virtual void advanceby(int delta); ... // Numerous variabls... }

Click on tcp.h and look for the "class TcpAgent" definition to see the full definition.

Some important variables that determine the performance of TCP are:
- cwnd_ - current congestion window
- t_rtt_ - round trip time estimate
- t_srtt_ - smoothed round trip time estimate (averaged over a number of periods)
- t_rttvar_ - variance in round trip time
The variable cwnd_ is the TCP congestion window size (the unit is number of packets)
The other variables are various RTT (round trip time) values
The TCP agent measures the RTT of each packet.
The RTT estimates are used to set the time out value for packets.
Some TCP flow control method uses RTT values to adjust cwnd_ (e.g., TCP Vegas)

How NS's TCP implementation increments its congestion window

When the TCP agent receives a new ACK, it attemps to "open" the congestion window by invoking the TcpAgent::opencwnd() method
(To see the actual code, click on tcp.cc and look inside for the definition of the function "opencwnd()")

The structure of the opencwnd() function is as follows:

void TcpAgent::opencwnd() { double increment; if (cwnd_ < ssthresh_) { // perform slow start algorithm // There is only one slow start alg. now, // But you can add more... } else { // perform a congestion avoidance algorithm // based on the value of the variable "wnd_option_" } // if maxcwnd_ is set (= nonzero), make sure cwnd_ <= maxcwnd_ if (maxcwnd_ && (int(cwnd_) > maxcwnd_)) cwnd_ = maxcwnd_; }

You can add an implementation of your own TCP congestion control method by inserting your code.
You can change the slow start algorithm by inserting code in the "then" part of "if (cwnd_ < ssthresh_)
You can change the congestion avoidance algorithm by inserting code in the "else" part of "if (cwnd_ < ssthresh_)

How NS's TCP simulation decrements its congestion window

Depending on the situation (triple duplicate ACK, timeout or other indications - e.g., Early Congestion Notification), TCP can close the congestion window by invoking the TcpAgent::slowdown(int how) method
(To see the actual code, click on tcp.cc and look inside for the definition of the function "slowdown()")
The how parameter is a series of flags that you can set to indicate how fast/slow TCP must slow down.
TCP must adjust Slow Start Threshold (ssthresh) and Congestion Window size (cwnd) in the slow down
(cwnd controls the the congestion window size)
(ssthresh controls HOW the congestion window size is increased)
So a typical call of the TcpAgent::slowdown(how) method needs 2 flag parameters.
For example:
- The flag (bit) CLOSE_SSTHRESH_HALF controls how the Slow Start Threshold (ssthresh) will be reduced
- The flag (bit) CLOSE_CWND_RESTART controls how the Congestion Window size (cwnd) will be reduced

The structure of the slowdown() function is as follows:

// **************************************** // Reduce Slow Start Threshold (ssthresh) // **************************************** if ( how & CLOSE_SSTHRESH_HALF ) { ssthresh_ = cwnd_ / 2; } else if ( how & THREE_QUARTER_SSTHRESH ) { ... } // **************************************** // Reduce Congestion Window (cwnd) // **************************************** if ( how & CLOSE_CWND_HALF ) { cwnd_ = cwnd_ / 2; } else if ( how & CLOSE_CWND_RESTART ) { cwnd_ = 1; } else if ... (more variants available, but omitted here)

The value CLOSE_SSTHRESH_HALF (flag) is equal to 0x00000001
The value THREE_QUARTER_SSTHRESH (flag) is equal to 0x00000080
These values are defined in tcp.h

Make your own flavor of TCP congestion control
- If you need to change TCP's increase algorithm, you add the increase algorithm as follows:
  1. Pick an unused value of wnd_option_ (check the list in opencwnd()
  2. Add a new case option and Write your code to increase TCP's cwnd_ variable
- To instruct the TCP agent to use your new TCP algorithm:
  - The value 99 is the new case in the "opencwnd()" switch statement
- If you need to change TCP's decrease algorithm, you add the decrease algorithm as follows:
  1. Pick an unused value of flag option (check the list in tcp.h)
  2. Add a new if option in slowdown and Write your code to decrease TCP's ssthresh_ and cwnd_ variables

Example: TCP using a constant Congestion Window

We will replace the TCP module with a simple-minded TCP window scheme using a constant congestion window size
(Don't laugh, this was how TCP worked before 1988)

A Simple-minded Implementation:

void TcpAgent::opencwnd() { double increment; cwnd_ = 10; // Add these lines in "tcp.cc" return; // These have become "dead code" if (cwnd_ < ssthresh_) { switch (wnd_option_) { .....

The above solution uses a fixed (= 10) window size, we will make the windows size updatable later...

Compile a new NS

cd ~/cs558/NS make

You should see:

cs558 (330)> make g++ -c -Wall -DTCP_DELAY_BIND_ALL ...... -o tcp/tcp.o tcp/tcp.cc g++ -o ns \ common/tclAppInit.o tools/random.o tools/rng.o tools/ranvar.o ......

After successfully compiling a new NS, you can use a Tcl script to run a simulation using the new fixed window size TCP
I have attachec an NS script below...
Example Program: (Demo above code)
- Prog file: click here
NOTE: you need to run this program with the MODIFIED NS program inside /home/cs558000/cs558/NS/bin/ns
This NS can be used to run the NS script "FixedCWND.tcl":

Example: TCP using a constant Congestion Window - take 2

The simple implementation of a "constant congestion window" does not allow the user to choose a different CWND size (it's compiled in)

To make the TCP congestion protocol more flexible, we introduce a variable into the TCPAgent class:

class TcpAgent : public Agent { ... (existing definitions) /* ------------------------------------------ Cheung: my new variables ------------------------------------------ */ int FixedWindowSize; };

We can now write an Improved Constant CWND TCP implementation:

void TcpAgent::opencwnd() { double increment; if (cwnd_ < ssthresh_) { switch (wnd_option_) { case 98: cwnd_ = FixedWindowSize; break; (other cases omitted) .....

We need to give the variable FixedWindowSize some initial value; then TCP's "opencwnd()" will set the cwnd_ variable to the (fixed) given window size
The TCL programming language provides a variable binding mechanism to associate:
- an (instance) variable in C++, with
- an (instance) variable in TCL
To associate a variable named X in C++ with a variable named Y in TCL, put the following C++ statement in the constructor of the class:
(You put the statement in the constructor so that the statement will be executed when an object of that class is created !!!)

In our example, we put the following statement in TcpAgent::TcpAgent() (this is the constructor of the class TcpAgent):

TcpAgent::TcpAgent() ... { bind( "FixedWindowSize", &FixedWindowSize); }

Finally, OTCL wants the variable to be initialized (or else it will complain that it was not defined).
To initialize the "bound" variable, we add this set command in the file tcl/lib/ns-default.tcl (a script that is used to initial all bound variables):
- FixedWindowSize is the name of the bound variable
Example Program: (Demo above code)
- The tcp.cc Prog file: click here
  Look for "FixedWindowSize" tcp.cc for the changes
- The tcp.cc Prog file: click here
  Look for "FixedWindowSize" tcp.cc for the changes
- The ns-default.tcl Prog file: click here
  Look towards the end in ns-default.tcl for the changes
- A NS script that sets the "FixedWindowSize" variable: click here

Associating C++ class name with OTcl class name

Agent/TCP is the name of the OTCL class that is associated with the C++ class TcpAgent
This will be discussed in the next lecture in more detail (when we define a new class in NS)
But to satistfy yur curiocity, there is a special class in OTcl called TclClass that create a new identifer in the OTcl class name space.

The OTcl class name Agent/TCP is introduced in OTcl as follows: (see inside tcp.cc)

static class TcpClass : public TclClass { public: TcpClass() : TclClass("Agent/TCP") {} TclObject* create(int , const char*const*) { return (new TcpAgent()); } }; static TclClass class_tcp; // force constructor to be run once...

This name can be used to invoke an associated create() method to create a C++ object:

External NS tutorials
- NS by Example: click here
- Marc Greis' NS Tutorial: click here