Changes between Version 28 and Version 29 of GENIEducation/SampleAssignments/TcpAssignment/ExerciseLayout/KernelModv2

12/10/13 20:36:28 (6 years ago)



  • GENIEducation/SampleAssignments/TcpAssignment/ExerciseLayout/KernelModv2

    v28 v29  
    33'''3.5 An Experimental Congestion Avoidance module for Linux'''[[BR]]
    4  Source code needed (to-be changed by you): [[BR]]
    5  - [ Makefile]
    6  - [ tcp_exp.c] [[BR]]
    7  In this exercise, you will develop and evaluate a TCP congestion control module for the Linux kernel. Linux provides a pluggable interface for TCP congestion control, which allows named congestion control modules to manipulate its sending rate and reaction to congestion events. You have already used the reno and cubic modules, and in this exercise you will create one named exp. [[BR]]
    8  Linux kernel modules must be compiled against kernel source that matches the kernel into which the module will be loaded. In order to prepare your ProtoGENI host for kernel module development, follow these steps:
    9 {{{
    10 #!comment
    11  1. Comment out the line:
    12  {{{
    13  exclude=mkinitrd* kernel*
    14  }}}
    15  in the file `/etc/yum.conf`, to allow yum to install kernel headers.
    16 }}}
    18  1. Install the required packages with this command:
    19  {{{
    20  sudo yum install kernel-devel kernel-headers
    21  }}}
    22  2. Fix up the kernel version in the installed headers to match the running kernel; this can be tricky, but these steps should handle it.
    23   a. Find your kernel sources. They are in `/usr/src/kernels`, in a directory that depends on the installed version. As of the time this handout was created, that directory is ``. We will call this directory `$KERNELSRC`.
    24   b. Identify your running kernel version by running `uname -r`. It will be something like `2.6.40-4.emulab2.fc15.i686.PAE`. The first three dotted components (`2.6.40`, in this case) are the major, minor, and micro versions, respectively, and the remainder of the version string (`-4.emulab2.fc15.i686.PAE`) is the extraversion. Note the extraversion of your kernel.
    25   c. In `$KERNELSRC/Makefile`, find the line beginning with `EXTRAVERSION`. Replace its value with the extraversion of your kernel.  FIXME: Also update `PATCHLEVEL = 0`.
    26   d. Update the kernel header tree to this new version by running the command:
    27 {{{
    28 cd $KERNELSRC
    29 sudo make include/generated/utsrelease.h
    30 }}}
    32 '''Notes'''
    33  * A Makefile for compiling the module and the source for a stub TCP congestion control module are included in [ Makefile].
    34  * The module is named `tcp_exp` (for experimental TCP), and the congestion control algorithm is named `exp`. Comments in the provided source file explain the relationship between the various functions, and more information can be found in [ pluggable congestion avoidance modules].
    35  * The compiled module (which is built with make and called `tcp_exp.ko`) can be inserted into the kernel using `sudo /sbin/insmod`. It can be removed using the command `sudo /sbin/rmmod tcp_exp` and reloaded with `/sbin/insmod` if changes are required. (If `rmmod` doesn't work initially, make sure `cat /proc/sys/net/ipv4/tcp_congestion_control` does not say `exp` and then logout and then log back into the node and try again.) 
    36  * Once the module is complete and loaded into the kernel, the algorithm implemented by the module can be selected in the same manner that reno and cubic were selected in previous exercises, by placing the keyword exp in `/proc/sys/net/ipv4/tcp_congestion_control`.
    37  * More details to handle version issues are provided at [ Building modules for a precompiled kernel].
    38  * `dmesg` may give you a clue to some errors.
    40 '''3.5.1 Algorithm Requirements''' [[BR]]
    41 The experimental congestion control module is based on Reno, but has the following modifications: [[BR]]
    42   • It uses a Slow Start exponential factor of 3. Reno uses 2. [[BR]]
    43   • It cuts ssthresh to 3 × !FlightSize/4 when entering loss recovery. Reno cuts to !FlightSize/2.
    45 '''3.5.2 Hints [[BR]]'''
    46 These hints and suggestions may help you get started.
    47  * When you start, renew your resources through the Portal so that the resources don't disappear while you are working.
    48  * Edit `tcp_exp.c` on your local machine and then use `scp` to load `Makefile` and modified versions of `tcp_exp.c` onto your nodes.  Use the same values of PORT, USERNAME, and HOSTNAME that you use to ssh onto the nodes.
    49 {{{
    50 scp -P PORT my_file.txt USERNAME@HOSTNAME:.
    51 }}}
    53  * ~~The existing congestion avoidance modules are a good start. See `net/ipv4/tcpcong.c` in the Linux source for the Linux Reno implementation.~~
    54  * ~~The file `net/ipv4/tcp_input.c` is a good place to learn how the congestion avoidance modules are used and invoked.~~
    55  * [ RFC 5681] specifies the Reno congestion control actions in detail, and may be helpful in understanding the kernel code.
    56  * ~~The Linux Cross Reference at `` may be useful for navigating and understanding how the code fits together.~~
    57  * ~~If one of the hosts becomes unresponsive due to a bug in your congestion control module, you can restart the sliver to reboot it.~~
    58  * ~~[ The Linux Kernel Module Programming Guide] provides a good introduction to kernel module programming in general.~~
    60 '''3.5.3 Evaluation [[BR]]'''
    61  Once you have implemented the algorithm described above, answer the following questions:
    62   - 1. Question: Discuss the impact of these algorithmic changes in the context of traditional Reno congestion control.
    63   - 2. Question: Compare the convergence time and fairness of your algorithm with Reno and Cubic under (a) high delay (500 ms) and (2) high loss (5%) conditions. Use [,d.dmg Jain’s fairness index], or some other quantitative measure of fairness, in your comparison.
     5This page has been moved here GENIEducation/SampleAssignments/TcpAssignment/ExerciseLayout/KernelMod