GSOC2020Prague

From Nsnam
Revision as of 16:05, 29 August 2020 by Deepakk (Talk | contribs) (Milestones and Deliverables)

Jump to: navigation, search

Main Page - Current Development - Developer FAQ - Tools - Related Projects - Project Ideas - Summer Projects

Installation - Troubleshooting - User FAQ - HOWTOs - 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.
  • On receipt of each ACK, a sender would update the pacing rate as follows: 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 implemented the RTT independence feature in ns-3 TCP Prague.

  • The outcome was addition of ns-3 TCP Prague as a mirror of ns-3 DCTCP and implementation of the RTT independence feature following Linux Prague.
  • The 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 refactored the ns-3 Prague code to align with Linux.

  • The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" cWnd reduction approach (that Linux follows) was added on receipt of an ACK with ECE mark.
  • Along with this, experiments were conducted to obtain aligning plots between ns-3 and Linux implementations of Prague.
  • We used the one-flow scenario (and two-flow scenario in case of RTT independence) from the l4s-evaluation module to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the NeST framework).

A more elaborate description of the features added in these phases can be found in the project site.

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.