GSOC2020Prague

Main Page - Roadmap - Summer Projects - Project Ideas - Developer FAQ - Tools - Related Projects

HOWTOs - Installation - Troubleshooting - User FAQ - Samples - Models - Education - Contributed Code - Papers

Back to GSoC 2020 projects

Project Overview

• Project Name: TCP Prague model for ns-3
• Student: Deepak K
• Mentors: Ankit Deepak, Mohit Tahiliani, Vivek Jain, Viyom Mittal
• Project Goals and Outcomes: The original plan at the start of this project was to add TCP Prague to ns-3 mirroring ns-3 DCTCP, implement Classic ECN detection, RTT independence and Dynamic pacing. After several discussions with my mentors, these goals and priorities were altered. The following features have been implemented in ns-3 at the end of this project:
  • Dynamic pacing model in TCP, along with unit tests (link to code)
  • TCP Prague that aligns with contemporary Linux implementation, along with unit tests (link to code)
  • RTT independence in TCP Prague, along with unit tests (link to code)
  • Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux (links to results)
• Future Work: Adding system-wide tests for TCP Prague is something that was in the scope of GSoC work, but could not be fully completed. (I am currently working on these tests). A few features that we chose not to address during GSoC, but would definitely help the ns-3 Prague model include: merging Dual Queue model to ns-3, adding Classic ECN detection to TCP Prague, and merging Accurate ECN to ns-3.
• Project Page: A project page was also added to give an elaborate explanation of the different features implemented as part of this work.
• Repository: https://gitlab.com/deepakkavoor/ns-3-dev
• About Me: I am a third-year undergraduate student pursuing Computer Science and Engineering at the National Institute of Technology Karnataka (NITK), India. My interests include computer networks and cryptography. Previously I have worked on implementing the Set-Associative Hashing feature for Fq-CoDel AQM in ns-3 (link to my commit).

Milestones and Deliverables

Phase 1

This phase implemented the dynamic pacing feature in ns-3 TCP.

• The outcome was achieving alignment of ns-3 pacing with Linux implementation, which sets the current pacing rate based on the congestion window and prior RTT measurements.
• pacingRate = factor * cwnd * mss / rtt
• The value of factor depends on whether TCP is currently in Slow Start or Congestion Avoidance. The default values used by Linux are 2 and 1.2 respectively, and we use the same. A higher factor in Slow Start allows TCP to probe for higher speeds early on.
• A test suite was also added to check that packets are correctly paced out as per the above update equation.
• The work done in this phase was documented in ns-3.
• I also tried to designed experiments in ns-3 to show improvements when using dynamic pacing.

Phase 2

This phase focused on RTT Independence and writing tests to validate the implementation.

• The outcome was addition of ns-3 TCP Prague as a mirror of ns-3 DCTCP and implement the RTT independence feature following Linux Prague.
• The sender cWnd increment during Congestion Avoidance is modified, so that Prague behaves as if it is operating at a (usually higher) target RTT. This reduces unfairness when Prague and other classic congestion controls (such as Reno) coexist within a common bottleneck.
• There are currently three RTT scaling heuristics in Linux: Rate, Scalable and Additive, and all were implemented in ns-3.
• As an example, the update equation for congestion window increment on receipt of each ACK using the "Rate" heuristic would be: increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd, where curRTT denotes the current RTT measurement and targetRTT denotes the target RTT at which Prague is expected to operate.
• Unit tests were added to check that RTT independence in ns-3 Prague works as expected.
• The work done in this phase was documented in ns-3.

Phase 3

This phase would refactor the ns-3 Prague code to align with Linux. Along with this, we would need to run experiments and obtain aligning plots between ns-3 and Linux implementations of Prague.

A more elaborate description on alignment results can be found here: https://deepakkavoor.github.io/gsoc-2020-prague/

Weekly Reports

Community Bonding Period (May 4 - May 31)

• Established the Wiki page for this project.
• Rebased the GSoC 2018 implementation of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my repository
• Went through the TCP models and architecture in ns-3 and studied about Paced Chirping.

After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on pacing in TCP Prague.

Week 1 (June 1 - June 7) (Start of Phase 1)

• Agreed upon the pacing structure for TCP Prague in ns-3. The document can be found here.
• Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods PacingEnabled and UpdatePacingRate. This allows any congestion control to dynamically update its pacing rate depending on whether it is in Slow Start or Congestion Avoidance.

Week 2 (June 8 - June 14)

• Aligned ns-3 Prague with Linux by enabling TcpPrague::CongControl.
• Designed a test suite TcpPacingTest to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
• Rebased Joakim Misund's work on ns-3 Prague to latest ns-3-dev.
• Generated an MR to add support for TCP Prague and pacing, along with the above test suite.

Week 3 (June 15 - June 21)

• Worked on fixing a few issues with the MR generated in Week 2.
• Went through the code for RTT Independence in Linux Prague, and gathered a few notes in this document (work in progress).
• Added code to enable different scaling heuristics (similar to Linux).

  typedef enum
  {
    RTT_CONTROL_NONE,      //!< No RTT Independence
    RTT_CONTROL_RATE,      //!< Flows with e2e RTT < target try to achieve same throughput
    RTT_CONTROL_SCALABLE,  //!< At low RTT, trade throughput balance for same marks/RTT
    RTT_CONTROL_ADDITIVE   //!< Behave as a flow operating with extra target RTT
  } RttScalingMode_t;

• The initial commit can be found here.

Week 4 (June 22 - June 28)

• Divided the MR (from Week 2) to now separately add support for dynamic pacing (!339) and TCP Prague (!331).
• Ran experiments using Linux namespaces to check the behaviour of TCP flows when dynamic pacing is enabled.
• Compared the plots from Linux and ns-3 for congestion window and pacing rate, and observed significant differences; we are currently trying to identify why linux has more frequent cwnd oscillations compared to ns-3.

Week 5 (June 29 - July 5)

• Generated merge requests for ECN++ and AccECN (rebased from Wenying Dai's GSoC 2018 work).
• Added dynamic pacing to other congestion controls in ns-3.
• Analyzed packet traces (using Wireshark) for topologies designed in Linux namespaces, and inferred the following: if a Linux TCP sender has more than two eligible packets to be sent, the first two are sent back-to-back, and the rest are paced out.

Week 6 (July 6 - July 12)

• Extended examples/tcp/tcp-pacing.cc to highlight dynamic pacing and produce time-series plots of Congestion Window, Slow Start threshold and current Pacing Rate.
• Added documentation regarding dynamic pacing in ns-3, and its similarities and differences to that in Linux.

Week 7 (July 13 - July 19)

• Explored different topologies and configurations that would show the benefits of TCP pacing.
• Modified the pacing example to follow the topology as given in Figure 2 here.
• Continued the work on RTT Independence and added/modified the following methods:
  • TcpPrague::AiAckIncrease (): Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
  • TcpPrague::IncreaseWindow (): Consider the RTT scaling factor when updating cWnd during AI.
  • TcpPrague::PktsAcked (): Apply the EWMA update equation and increase round count only if the value returned by TcpPrague::ShouldUpdateEwma () is true.

Week 8 (July 20 - July 26)

• Improved and refactored the code for Prague RTT independence.
• Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
• Fixed bugs in ECN++ and AccECN code that were causing DCTCP tests to fail.
• Participated in the IETF 108 Hackathon and helped with integration of Prague alongside other L4S components.

Week 9 (July 27 - August 02)

• Setup and built a kernel supporting Prague, DualQueue and AccurateEcn by referring to the Linux development branch here.
• Worked on setting up a topology in this kernel using Linux namespaces.

Week 10 (August 03 - August 09)

• Tried to run experiments with the l4s-evaluation module to show that Prague experiences higher throughput in presence of other Classic flows.

Week 11 (August 10 - August 16)

• Major refactoring of ns-3 Prague code to match the Linux implementation.
• Validated this implementation against Linux namespaces and obtained alignment in the one-flow scenario.

Week 12 (August 17 - August 23)

• Worked on obtaining results in the two-flow scenario to test working of RTT independence.
• Worked on documentation of ns-3 Prague.
• Worked on project site.

Week 13 (August 24 - August 30)

• Added doxygen comments and slight cleanup of TCP Prague code.
• Setup an MR for the TCP Prague model.
• Fixed issues related to delayed acknowledgements in the TCP pacing test suite.
• Worked on understanding how TCP system tests are written in ns-3.