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: Scalable congestion controls such as DCTCP improve performance over Reno and Cubic, which perform badly in high-speed networks (because of their slow response with large congestion windows). Several additional modifications over DCTCP have been drafted into the protocol called TCP Prague, that aims to integrate scalable congestion control into the Internet while still allowing it to coexist with current Classic protocols. This project would complete the integration and testing of fallback detection, RTT independence and pacing into the TCP Prague model of ns-3. The project would also validate the aforementioned implemenation against Linux and document the changes made. My proposal can be found here.
• 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, protocol design, cryptography and security. 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

The original goal as per the proposal was to add Classic ECN Detection for TCP Prague in Phase 1, RTT Independence in Phase 2, and Pacing in Phase 3.

Phase 1

• It was decided that dynamic pacing should be integrated first. The goal is to align ns-3 pacing with Linux implementation, which sets the current pacing rate based on the congestion window and prior RTT measurements. 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.

pacing_rate = factor * cwnd * mss / rtt

• Rebased Joakim Misund's TCP Prague implementation and added the above dynamic pacing feature to it.
• A test suite was also added to check that packets are correctly paced out as per the above update equation.
• Generated plots for congestion windows and pacing rates in ns-3 and Linux, and justified the differences if any (this is currently being done).

Phase 2

This phase would focus on RTT Independence, and writing tests to validate the implementation. During this phase, the following additional tasks need to be considered as well:

• Adding documentation to Paced Chirping implementation from Joakim Misund
• Restructuring the Paced Chirping implementation to reduce close coupling with ns-3 Congestion Controls.
• Finalizing the rebased ECN++ and AccECN code written during GSoC 2018.

Phase 3

Add Classic ECN detection to 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 (): Let the cWnd update during AI consider the RTT scaling factor.
  • 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)

(Todo)