June Log Book Entries

<=May July=>

10/6

Holidays are here... NOT. Working on the project again. Anyway, implementing the core of the Simulator Engine now. The three classes that make up the Simulator engine has being defined and tested. I am implementing the classes in the TCP Layer now that implement the Flow Control algorithm plug and play mechanism. Should have this done soon.

12/6

Finished the infrastructure classes for the TCP Layer. The plug and play mechanism and the TCP Layer works now. I am using text files call patch maps that define how modules loaded into the TCP Layer are structured into handlers. I just have to implement all the damn modules that make up RFC 793 TCP and all the additional Flow Control Algorithms. I am implementing all the modules for the basic version of TCP and testing it. Hopefully everything works.

15/6

Finished implementing the base version of TCP. Starting to test it now, using dummy traffic generators to produce constant delay and loss. Doing the handshake routines first, followed by the data transfer routines, then the miscellaneous stuff.

16/6

Most of the testing on the Base TCP variant done. Had a bit of a tussle with the persistence timer implementation, as I had to implement additional modules just to allow segments on the retransmission queue to stop and start retransmitting again when the advertised window shrinks and grows. What a pain.

17/6

The Base Tahoe TCP variant should now work fully. I finalized the default patch map that loads this TCP variant into the Simulator just now. The next step is to implement all the different TCP Flow Control algorithms in modular form. Going to start with the basic stuff, like Nagles, Karns, SWS algorithms.

18/6

Argh, not as simple as I thought, these algorithms all mess with the decision as to whether new segments are formed - since this decision is made within 1 module, I will have to overwrite it. BUT doing so only allows 1 algorithm to be implemented at any 1 time.... argh

20/6

Found a solution, I can use wraparound modules that adjust the amount of data to be sent before and after that data sending module is executed. That allows multiple layers of wraparound to work. So multiple algorithms all influencing the same module can not be loaded at once. I am so brilliant.

22/6

Nagles, SWS both work now. Defined the patch maps and test loaded the modules and they can be plug and played independently. Going to start implementing Jacobson's Congestion Algorithms first as so many other Flow Control algorithms build on it.

25/6

Damn, looks like my retransmission mechanism in my Simulator is not as good as I thought, Jacobson's is having trouble with it. Going to have to rewrite some base Tahoe modules. grrr...

26/6

Got a part of Jacobson's Slow Start working and the wrap around modules that make the Simulator use cwnd to send data. Jacobson's Congestion Avoidance is next.

28/6

Congestion Avoidance modules are implemented and it looks good. cwnd is moving appropriately when losses occur and Slow Start takes over after a timeout as required. Further testing is required though.

29/6

Congestion Avoidance and Slow Start should now both work. Going to do Fast Retransmit and Jacobson's RTO formula. These should not be hard to do as they are directly module insertions that do not interoperate much with base Tahoe TCP.