Sam’s Network Simulation Cradle Blog

Looks like someone had a similar idea to my honours project: Integration of the FreeBSD TCP/IP-stack Into the Discrete Event Simulator OMNeT++

Without 32 bit xlib development libraries, ns-2 (or its dependencies) don’t want to build.

Been wasting far too much time trying to figure out what system I can actually build everything on. Hopefully this issue will be sorted out sometime in the near future by having voodoo-iii go 32bit.

Perhaps I should fix up Linux 2.4 at least on old voodoo. And possibly do some other stuff to just have a break from this silly situation.

I don’t trust gcc 3.0 as far as I can throw it. Which isn’t very far.

So I’ve now moved on to using the AMD64 Gentoo box to develop on. This means I need to move all my development to that box. I’ve managed to figure out how to compile shared libraries statically, so they do not have any dependences while still being a shared library – I detailed this on the WLUG wiki shared library page.

Going to need to get ns-2 going on the opteron though. That wont be so fun. Oh well.

Fixing up NSC for use with the HTTP model has actually shown that there are a few problems that had not surfaced earlier in my simpler simulation scenarios.

I was really only doing bulk transfers earlier. This meant that the application would always write as much data as possible to the socket. It didn’t really matter if the odd write to the socket failed and that particular data didn’t get through. This sort of thing needs to be fixed for using with a “more realistic” application.

There are a few things here; such as the fact that a send to an NSC socket didn’t return the amount of data written, just whether it was successful writing ANY data. This and other problems are being fixed.

This has the offshoot that I am now trying to compile FreeBSD 5.3 on Debian Woody. Goodness. gcc 2.95 doesn’t understand C99, but gcc 3.0 seems to have some idea.

Got HTTP stuff working with NSC. Needed some fixing so packets could be queued for sending before a connection was established (I had thought this wasn’t a problem, but it seemed to be? Hrm… I should test this somemore).

Also, made the NSC agent upcall the application correctly so it knows when packets are received. This works well enough now.

Also made the window_ setting work properly, it is measured in packets, not bytes.

Should play with this some more tomorrow. I wasted far too much time getting this going when all it needed was a simple fix.

Remembered today that ns-2 2.28 was relased a while back. Finally got around to downloading it and compiling it. Now I just have to chuck my NSC stuff in it to see if that goes.

Also found that the HTTP stuff has code to allow sending actual data between nodes over TCP. It’s a big hack, but it looks like it would work with my framework.

The point here is to make such that I can simulate normal HTTP stuff with my agents. Quite a few papers tend to use the ns-2 HTTP models it seems.

H-TCP: TCP for high-speed and long-distance networks (2004) * H-TCP * This particular paper does some NS simulations and the site above has an NS H-TCP implementation available

Binary Increase Congestion Control for Fast Long-Distance Networks (2004) * BIC-TCP * The paper does a whole host of simulations. The link above has more information about BIC and the newer CUBIC, including simulation scripts for the simulations run in the paper above. * Note that BIC-TCP is part of Linux since 2.6.7.

Scalable TCP: Improving Performance in Highspeed Wide Area Networks (2003) * Scalable TCP * Doesn’t seem to do any simulations. Has a patch for the Linux kernel 2.4.19.

FAST TCP: motivation, architecture, algorithms, performance (2004) * FAST TCP * Doesn’t seem to do any simulations, just experiments using dummynet and iperf.

HS-TCP * HS-TCP * Some simulations done, scripts provided.

Webpages updated

Notes from Tony: * High speed TCP graphs * Talk about FAST TCP and so on

The whole high speed TCP issue is an interesting one, and perhaps I should review a bit more research in this area. Not sure how much simulation is used. The memory and CPU requirements for that sort of simulation is usually quite high.

Wireless does look like a good place to look into simulating. Wireless is often simulated because analytical models are hard to come by (wireless isn’t understood all that well just yet and is a complex domain; wired networks are bad enough and are incredibly simple in comparison) and physical test networks are hard to setup in a believeable manner. We can’t easily use software to emulate the wireless conditions of a link just yet in the way we use Dummynet or similar to model limited wired links. So simulation is used a lot. Which also means that real world stacks aren’t used in this domain much.

• 1. Mapping Peer Behavior to Packet-level Details: A Framework for Packet-level Simulation of Peer-to-Peer Systems (2003)

      * Qi He, Mostafa Ammar, George Riley, Himanshu Raj, Richard Fujimoto
  

By the people that made pdns, they describe GnutellaSim and general peer-to-peer simulation in ns-2. Actually, their approach is generic enough that it works on another simulator (GTnets) as well.

With respect to my work, this means that it would work fine over my new TCP. However, this project is very concerned with scalability, and the extra memory overhead would be a big negative for my stuff. Having said that, if my work were incorporated in pdns, then this would be less of a problem.

On the website (not in their paper), they describe how they modified ns-2’s TCP so it can actually send data. My TCP agents can already do that, of course!

• 2. The War Between Mice and Elephants (2001)

      * Liang Guo and Ibrahim Matta
  

Investigates active queue management (AQM) to allow short lived TCP flows (the mice) to get their fair share of bandwidth (normally this is hogged by the long lived flows, the elephants). Does simulations using ns-2 using the HTTP model with RED on the routers (and ECN enabled a lot of time the).

Should see how the HTTP model works with my TCP agents. I believe the rest will all just work with my TCP stuff. Though flow classification much be done for DiffServ and AQM strategies, because addressing is part of the simulator (and not my TCP), I don’t think there needs to be any modifications done to my stuff. However, I should test this for sure. Don’t support ECN at the moment. Could do, though.

• 3. TCP/IP Performance with Random Loss and Bidirectional Congestion (2000)

      * T. V. Lakshman, Upamanyu Madhow, and Bernhard Suter
  

Looks into random loss and congestion with highly asymmetric links. Doesn’t actually say what simulator it is using, but describes using Reno and Tahoe TCP variants. While being somewhat hard to follow in general, the situations simulated don’t seem to be too complex and should work fine with NSC. Lots of analytic results and not so much simulation.

• 4. The Performance of TCP/IP for Networks with High Bandwidth-Delay Products and Random Loss (1997)

      * T. V. Lakshman, Upamanyu Madhow
  

Doesn’t seem to mention the simulator they used, could be something else considering this paper is from 1997. However, the simulations performed again seem to be in the scope of NSC (just seeing what TCP does in a couple of scenarios and graphic throughput or window or buffer sizes). Again, lots of analytic stuff and not so much simulation.

• 5. TCP Performance Analysis on Asymmetric Networks Composed of Satellite and Terrestrial Links (2000)

      * Hiroyasu Obata, Kenji Ishida, Junichi Funasaka, and Kitsutaro Amano
  

Does some ns-2 simulations of satellite stuff. Just basic TCP functionality used.

• 6. TCP over Load-Reactive Links (2001)

      * Rajesh Krishnan and James P.G. Sterbenz
  

They use ns-2 to do some simulations. Just default TCP stuff is used, they just measure throughput. NSC would work well in this scenario.

• 7. The Performance of TCP over ATM on Lossy ADSL Networks (2000)

      * Guang Lu, Rob Simmonds, Xiao Zhonge, Brian Unger and Carey Williamson
  

Uses the ATM-TN simulator. Not suprising, considering it is people from Calgary. Otherwise, most of the simulation stuff here is basic enough. ATM-TN does do cell-level simulation.

• 8. Low-Rate TCP-Targeted Denial of Service Attacks (2003)

      * Aleksander Kuzmanovic and Edward W. Knightly
  

They create some traffic models in ns-2 which allows them to DOS TCP connections, doesn’t matter which TCP agent they use. Looks like NSC would work in here as well. Would be interesting to watch this with a real stack. They did do internet measurements, though, so it seems unlikely we’d find out anything new.

• 9. Performance Evaluation and Comparison of Westwood+, New Reno, and Vegas TCP Congestion Control (2004)

      * Luigi A. Grieco and Saverio Mascolo
  

Compares ns-2 models of New Reno and Vegas with the new model of Westwood+. They then go on and use the Linux kernel implementation to test how it works on the Internet. This is interesting because they do use a real implementation as well as building a model in ns-2. NSC could certainly be used in such a situation, just using the implementation to begin with. Alternatively, the implementation could be tested against the model with NSC.

• 10. TCP Congestion Window Validation (1999)

      * Mark Handley, Jitendra Padhye, and Sally Floyd
  

Implements the original idea as an “option in NS” then goes on to implement this in FreeBSD 3.2 and do some experimental validation. Of course NSC could be used in such a situation.

• 11. Analysis and Improvement of Fairness between TCP Reno and Vegas for Deployment of TCP Vegas to the Internet (2000)

      * Go Hasegawa, Kenji Kurata, and Masayuki Murata
  

Simulates ns-2 Reno and a slightly modified ns-2 Vegas. Not sure how much NSC would have helped. They would have had to implement Vegas in NSC if they wanted to simulate that with NSC. Not so useful.

• 12. A Case for Exploiting Self-Similarity of Network Traffic in TCP Congestion Control (2002)

      * Guanghui He, Yuan Gao, Jennifer C. Hou, and Kihong Park
  

This one makes a modification to TCP (called TCP-TP), simulates it in ns-2, then implements it in FreeBSD 4.1. NSC could of course be of use here.

• 13. Achieving Per-Flow Fair Rate Allocation In Diffserv (2001)

      * Na Li, Marissa Borrego, and San-qi Li
  

Uses Reno TCP, the purpose is to test the queueing models. NSC could be used for the TCP agents.

• 14. On Making TCP More Robust to Packet Reordering (2002)

      * Ethan Blamton and Mark Allman
  

Modifies ns-2 to add some stuff to allow packet reordering and modifies and fixes SACK up to have DSACK. NSC is less useful for this sort of paper.

• 15. A Comparison of RED’s Byte and Packet Modes (2003)

      * Wesley M. Eddy and Mark Allman
  

Another queueing model simulation: uses FTP and TCP SACK in ns-2. TCP agent could use NSC.

• 16. Adaptive RED: An Algorithm for Increasing the Robustness of RED’s Active Queue Management (2001)

      * Sally Floyd, Ramakrishna Gummadi, and Scott Shenker
  

Another queueing model simulation. Uses TCP, could easily use NSC.

• 17. Delay-Based Congestion Avoidance for TCP (2003)

      * Jim Martin, Arne Nilsson, and Injong Rhee
  

Does some TCP simulations. Looks at RTT from the TCP agent at first. Later uses Vegas and their own model. NSC would be less useful in this situation, though perhaps still applicable given that it can get statistics easily.

• 18. Comparative Study of TCP Version Over a Wireless Link With Correlated Losses (2003)

      * Farooq Anjum and Leandros Tassiulas
  

A largely analytical paper that also performs simulations of wireless situations. Concludes that Tahoe can be better than NewReno in a lossy wireless situation, though Sack is better again. I assume that was because Tahoe was not delaying acks, where NewReno was. I could perhaps read the paper in more detail to know this for sure, but it sounds like a likely explanation to me. Interesting enough paper, but they don’t provide enough details of their simulations from what I could see. Perhaps I missed something. They did at least say they are using ns-2. NSC would well be used to validate whether their findings have any merit for real world stacks; while using Tahoe and NewReno is fine, and building analytical models of these is fine, it might be of use to see whether what really gets implemented works like these simplified models in such a case.

• 19. Closed Queue Network Models of Interacting Long-Lived TCP Flows (2004)

      * Michele Garetto, Renato Lo Cigno, Michela Meo, and Marco Ajmone Marsan
  

Another paper which uses TCP simulation to validate the analytical models developed. NSC could well be used in this validation scenario.

• 20. Multimedia Streaming via TCP: An Analytic Performance Study (2004)

      * Bing Wang, Jim Kurose, Prashant Shenoy, and Don Towsley
  

Again, validation of an analytic model using ns-2. NSC could be used for the TCP agents in this scenario.

• 21. A Bidirectional Multi-Channel MAC Protocol for Improving TCP Performance on Multihop Wireless Ad Hoc Networks (2004)

      * Tianbo Kuang and Carey Williamson
  

They develop the MAC protocol in ns-2 then use the ns-2 TCP models for simulation over this new MAC protocol. NSC could of course be used in this situation.

• 22. TCP Performance in Wireless Multi-hop Networks (1999)

      * Mario Gerla, Ken Tang, and Rajive Bagrodia
  

Uses GloMoSim for simulation of TCP/wireless stuff. Wow, a paper that doesn’t use ns-2!

• 23. Enhancing TCP Fairness in Ad Hoc Wireless Networks Using Neighbourhood RED (2003)

      * Kaixin Xu, Mario Gerla, Lantao Qi and Yantai Shu
  

Using QualNet (apparently the successor to GloMoSim) to simulate the scenario. Seems that they develop a “neighbourgood RED” scheme and test TCP in this case.

• 24. Selfish Behavior and Stability of the Internet: A Game-Theoretic Analysis of TCP (2002)

      * Aditya Akella, Richard Karp, and Scott Shenker
  

Uses ns-2 TCP simulations to validate their analytical model. Often with this sort of paper they look at Tahoe or Reno because they are simpler. Simplicity is a useful trait when building analytic models. It is hard to say how useful NSC would be in a sitation like this. It could certainly be used and might provide extra insights into the situation at hand.

• 25. A Case for Context-Aware TCP/IP (2002)

      * Carey Williamson and Qian Wu
  

Does many TCP simulations with ns-2. Then implements a proof of concept in Linux 2.4.16. NSC could of course be used here to at least help development of the proof of concept.S

• 26. Fair Sharing of MAC under TCP in Wireless Ad Hoc Networks (1999)

      * Ken Tang and Mario Gerla
  

Uses GloMoSim and does some TCP simulations. Seems GloMoSim is quite common for wireless stuff.

• 27. Is TCP Packet Reordering Always Harmful? (2004)

      * Giovanni Neglia, Vincenzo Falletta, and Giuseppe Bianchi
  

From MASCOTS. Does some interesting TCP simulations with ns-2. Mainly playing with a loss/reordering model in specific scenarios.

• 28. Performance Analysis and Improvement of HighSpeed TCP with TailDrop/RED Routers (2004)

      * Zongsheng Zhang,  Go Hasegawa, and Masayuki Murata
  

Does ns-2 simulations of HS-TCP and makes some modifications to HS-TCP and ARED.

• 29. Quantifying the Effects of Recent Protocol Improvements to Standards-Track TCP (2003)

      * Michele C. Weigle,  Kevin Jeffay, and F. Donelson Smith
  

Short paper that tests Reno, SACK, ECN, ARED in HTTP traffic. Simulates with ns-2 and makes lots of graphs.

• 30. Split Protocol Stack Network Simulations Using the Dynamic Simulation Backplane (2001)

      * Donghua Xu,  George F. Riley,  Mostafa H. Ammar, and Richard Fujimoto
  

Interesting paper where they combine simulations: their example is using GloMoSim for its excellent wireless MAC models and using ns-2 for its TCP models. Not quite the same sort of thing as the rest of the papers here, but I thought it was interesting enough to bear mentioning anyway.

• 31. Improving Ensemble-TCP Performance on Asymmetric Networks (2001)

      * Qian Wu and Carey Williamson
  

Uses models of E-TCP developed in another paper and performs more simulations.

---

Ok, I think that is enough for now.

Sort out actual research question/statement/hypothesis for sure. Or sure-ish. Then narrow it down to roughly half a dozen sub-questions. Then for each sub-question, state how I will answer it, or how I have answered it.

Remember the scientific/research process. It is not right to say “I’ve showed this is feasible because I made an implementation.” A little more work than that needs to be done. Example: “I reviewed the literature in the major journals and conferences of the science and found that XXX and YYY was done. My implementation shows that XXX and YYY are possible, therefore this approach is feasible.” Or something similar.

Another note: It might be possible to include the stuff about debugging and testing new code in simulation. I can say, “this approach opens up a new avenue to simulation: testing and debugging. This is a new form of simulation.” Or something. Perhaps needs more thought, but it is a good idea.

Tony had some Latex macros which help with section/subsection/subsubsection. Instead the macros were of the form “up heading” vs. “down heading”. This means relocation of sections is easy; you do not need to re-section all the time.