CMPE252A, Fall 2014, Section 01: Projects

Here are brief descriptions of some project ideas. If any of the ideas below sounds interesting, more detailed information will be provided by the project "mentor". Students are also welcome to propose their own project ideas. 

Note that a project proposal will be required in both cases, i.e., whether students are using one of the proposed ideas below or proposing their own.

See the Project section of the main course page for the format of the proposal and for other project information.

General Ideas

  1. TCP uses the exponentially weighted moving average (EWMA) method in order to estimate the round-trip time (RTT), the time between sending a segment and receiving an ACK from the other end. Estimating the RTT accurately is critical for TCP's performance. The work reported in B. Nunes, K. Veenstra, W. Ballenthin, S. Lukin, and K. Obraczka, "A machine learning framework for TCP round-trip time estimation", EURASIP Journal on Wireless Communications and Networking, 2014, 2014:47, doi:10.1186/1687-1499-2014-47 proposes a machine-learning approach based on the Fixed-Share Experts technique to improve the accuracy of TCP's RTT estimation. In this project, you will use the ns-3 network simulator to reproduce the results presented in the Nunes et al. paper.
  2. A similar approach to the one described above can be used to estimate TCP's retransmission timeout (RTO), i.e., the interval of time the TCP sender will wait for a segment's acknowledgment from the TCP receiver before timing out and retransmitting the segment. Currently the computation of the RTO is based on TCP's estimate of the RTT. In this project, you will use the ns-3 network simulator to evaluate the performance of TCP when using the Fixed-Share Experts technique to estimate the RTO.
  3. Network simulators employ propagation models to simulate how information propagates in communication channels. However, current network simulation platforms do not account for the effects of terrain on connectivity. In the Java-based Cooja simulator, implement a new RadioMedium subclass that lets simulations account for the effects of terrain on connectivity.
  4. Determine scaling effects on the 99th delay quantile of flows contending for a single switch port. Create a dumbell topology in ns-3 with multiple TCP flows heavily contending with each other.  The TCP flows should follow a Log Normal distribution for their traffic generation (to mimic traffic in a data center). Create scatterplots showing each delay measurement (separate plots for 2K, 26K, 52K, 105K, and 262K measurements), along with a line showing the 99th quantile.  Fit a statistical distribution to the density estimate of the delay measurements. Is it also a Log Normal distribution? Graph the density estimates for increasing numbers of measurements (as in the scatterplots), along with a line for the 99th quantile. Bonus: Do the same for a Pareto distribution.
  5. Implement the IEEE 802.11 PCF in the ns-3 simulator.
  6. Reproduce the experiments used to evaluate the Data Center TCP (DC-TCP) protocols using ns-3. Compare your results with the ones on the paper.
  7. Other project ideas: in general, you can propose to reproduce results reported on a paper related to one of the topics we cover in class. For other ideas, see http://www.stanford.edu/class/cs244/pa3.html

Ideas in SDN Performance Monitoring

  1. Design and develop a Python based network monitoring and report generation library.  The library targets Mininet based networking experiments and hence would utilize common Linux tools such as bwm_ng  (bandwidth monitor), tcp_probe, iperf output, etc.  The library would use Python libraries such as matplotlib, numpy, scipy, etc. for data analysis and visualization. The reference assignments below utilize these tools but do so in an ad hoc fashion.  The idea here would be to create a library with a user-friendly API that could be dropped into any experiment using Mininet.  A final report for an experiment could be generated in pdf or html format.
  2. Design and develop a Python module that provides a performance profile of an OpenFlow SDN network.  This would primarily use the counters maintained by the Open vSwitches which Mininet utilizes.  The counters are defined in the OpenFlow specifications here: https://www.opennetworking.org/sdn-resources/onf-specifications/openflow There should be a way to get the current state of the counters from the Open vSwitch.  The POX SDN controller may have some code that already does this.  The idea here would be to collect the counter state upon some user defined intervals, summarize it, and output it possibly using Mininet's logging facility.  A detailed text based report could also be generated. Mininet can support numerous Open vSwitches during an experiment.  The objective here is to consolidate the data from multiple switches and provide a complete picture of how the SDN network performed.
  3. Design and develop a Linux kernel module that monitors the performance of an Open vSwitch instance being managed by Mininet.  The idea would be to get at any data structures/variables that would shed light on how well the switch is performing.  The model for this would be tcp_probe, which is a kernel module that provides data about TCP congestion control at runtime.  If nothing is available with Open vSwitch, then perhaps some other Linux network stack data structures/variables could be monitored instead.  This project entails kernel-level C programming, but writing kernel modules is not necessarily difficult.   This reference is maybe the best out there:  http://www.tldp.org/LDP/lkmpg/2.6/html/ 

References

These are two experiments related to the buffer sizing problem in routers.  They both use Mininet and hence, implicitly use SDN.  The original assignments were created at the Standford course but were adopted by Udacity for their networking course. The code from github is from the Udacity assignments so it may not match up exactly with the Stanford instructions.

a) Home routers: http://www.stanford.edu/class/cs244/pa1.html  (the assignment) https://github.com/udacity/gt-cs6250/tree/master/assignment-5 (associated code that can be easily made to work in the Mininet provided VM)

b) Backbone routers: http://www.stanford.edu/class/cs244/pa2.html  (the assignment) https://github.com/udacity/gt-cs6250/tree/master/assignment-3 (associated code that can be easily made to work in the Mininet provided VM)

Both of these show good examples of using Linux performance monitoring tools and generating some plots with Python's matplotlib.  Neither do anything with OpenFlow counters from the Open vSwitches which are being used by Mininet.

SDN Programming with Pyretic

Pyretic is a SDN programming that can be used to easily write policies that will be inserted into flow tables at runtime.  It's based upon Python and uses Boolean predicates and different composition statements.  It's intended to simplify the development of SDN applications.  Their website is: http://frenetic-lang.org/pyretic/.  This would be good for someone into programming language design.  It think there are research efforts out there with the goal of preventing consistency problems or race conditions when trying to apply policies to multiple OpenFlow switches across a network.

Two possible projects are:

  1. Add an extension to the language that is useful in some way.
  2. Use Pyretic to create a SDN application.  A basic firewall seems to be reasonable possibility.  Here is some starter code for an assignment where you are supposed to add rules to prevent communication between two specific hosts. https://github.com/udacity/gt-cs6250/tree/master/assignment-7 This assignment is from the Udacity networking course.