Nsnam - User contributions [en]

GSOC2020Prague

2020-08-31T16:24:46Z

Deepakk: /* Week 10 (August 03 - August 09) */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** <s>The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to ns-3, and is in its final stages of review</s> This has been successfully [https://gitlab.com/nsnam/ns-3-dev/-/commit/3552db04ce9a44dd0fdc92913edc747676800357 merged] to mainline ns-3.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

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

Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.

Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.

Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cWnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with [https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the ns-3 [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master l4s-evaluation] module to show that Prague experiences higher throughput in presence of other Classic flows when RTT independence is disabled in ns-3 Prague.

=== Week 11 (August 10 - August 16)===
* Major refactoring of ns-3 Prague code to match the Linux implementation. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T16:23:45Z

Deepakk: /* Week 8 (July 20 - July 26) */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** <s>The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to ns-3, and is in its final stages of review</s> This has been successfully [https://gitlab.com/nsnam/ns-3-dev/-/commit/3552db04ce9a44dd0fdc92913edc747676800357 merged] to mainline ns-3.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

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

Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.

Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.

Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cWnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with [https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T16:22:57Z

Deepakk: /* Week 4 (June 22 - June 28) */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** <s>The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to ns-3, and is in its final stages of review</s> This has been successfully [https://gitlab.com/nsnam/ns-3-dev/-/commit/3552db04ce9a44dd0fdc92913edc747676800357 merged] to mainline ns-3.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

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

Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.

Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.

Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cWnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T16:21:56Z

Deepakk: /* Week 2 (June 8 - June 14) */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** <s>The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to ns-3, and is in its final stages of review</s> This has been successfully [https://gitlab.com/nsnam/ns-3-dev/-/commit/3552db04ce9a44dd0fdc92913edc747676800357 merged] to mainline ns-3.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

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

Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.

Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.

Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T16:20:20Z

Deepakk: /* Week 2 (June 8 - June 14) */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** <s>The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to ns-3, and is in its final stages of review</s> This has been successfully [https://gitlab.com/nsnam/ns-3-dev/-/commit/3552db04ce9a44dd0fdc92913edc747676800357 merged] to mainline ns-3.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

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

Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.

Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.

Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T16:02:38Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** <s>The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to ns-3, and is in its final stages of review</s> This has been successfully [https://gitlab.com/nsnam/ns-3-dev/-/commit/3552db04ce9a44dd0fdc92913edc747676800357 merged] to mainline ns-3.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

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

Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.

Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.

Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T05:54:13Z

Deepakk: /* Milestones and Deliverables */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to mainline ns-3, and is in its final stages of review.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

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

Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.

Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.

Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T05:53:19Z

Deepakk: /* Milestones and Deliverables */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to mainline ns-3, and is in its final stages of review.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

=== Phase 1 ===
This phase implemented the dynamic pacing feature in ns-3 TCP.
Link to Phase 1 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b click here]
* 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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.
Link to Phase 2 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b click here]
* 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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.
Link to Phase 3 code: [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 click here]
* The structure of ns-3 Prague was moved away from ns-3 DCTCP. A "PRR-like" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T05:49:18Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5b GSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to mainline ns-3, and is in its final stages of review.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T05:48:34Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5bGSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to mainline ns-3, and is in its final stages of review.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-31T05:47:38Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests
** RTT independence in TCP Prague, along with unit tests
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux
* '''Links to code written in each phase:'''
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/ea5a5d5b8e7b451912f240f6f505313ccf63223b GSoC 2020 Phase 1: Add dynamic pacing rate model to TCP]
** [ https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/3419114ce112665cffebd2ced62f286316b82e5bGSoC 2020 Phase 2: Add base TCP Prague model with RTT independence]
** [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/f4460afb9d8b09d394faaa1ff9de756f8384d331 GSoC 2020 Phase 3: Refactor TCP Prague and align with Linux]
** Alignment plots in the [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- one-flow] and [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ two-flow] scenarios.
* '''Future work:'''
** The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to mainline ns-3, and is in its final stages of review.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-29T16:47:45Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ to] results)
* '''Future Work:'''
** The merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 dynamic pacing] is almost merged to mainline ns-3, and is in its final stages of review.
** 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). As such, the merge request for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 TCP Prague] will soon be merged once these system tests are implemented.
** 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-29T16:41:35Z

Deepakk: /* Weekly Reports */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev.
* Went through the documentation for TCP model in ns-3 and read about [https://github.com/JoakimMisund/PacedChirping paced chirping].
After a discussion with mentors and the L4S Team, it was decided that the first phase of this project should focus on dynamic 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled ()</code> and <code> UpdatePacingRate ()</code>. 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) ===
* Designed a test suite <code>TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 MR] to add support for dynamic 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document].
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 !373]).
* 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 several differences; I am trying to identify why Linux has more frequent cwnd oscillations compared to ns-3.

=== Week 5 (June 29 - July 5)===
* Generated merge requests for [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 dynamic pacing.
* Modified the pacing example to follow the topology as given in Figure 2 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued to work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> is true.

=== Week 8 (July 20 - July 26)===
* Improved and refactored the code for Prague RTT independence to align with Linux.
* Added unit tests to check correct increment of Congestion window for different RTT scaling heuristics.
* Fixed [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/hackathon-prague bugs] in ECN++ and AccECN code that were causing DCTCP tests to fail.
* Participated in the [https://registration.ietf.org/108/participants/hackathon/ IETF 108 Hackathon] and helped with https://gitlab.com/tomhenderson/ns-3-dev/-/commits/hackathon/master integration] of ns-3 Prague model alongside other L4S components (such as Dual Queue).

=== Week 9 (July 27 - August 02)===
* Setup a Linux kernel supporting TCP Prague, Dual Queue model and Accurate Ecn by referring to the contemporary Linux development [https://github.com/l4steam/linux branch] maintained by the L4S team.
* Worked on setting up a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/prague.py topology] in this kernel corresponding to the one-flow scenario using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Worked on experiments using the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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. The following methods were added:
** <code>TcpPrague::UpdateCwnd ()</code>: Update the congestion window on receipt of each ACK, and use a "PRR-like" reduction on ECE marks.
** <code>TcpPrague::UpdateAlpha ()</code>: Update the value of alpha (which corresponds to an EWMA of the fraction of bytes that were CE marked) based on <code>TcpPrague::ShouldUpdateEwma ()</code>.
** <code>TcpPrague::SlowStart ()</code>: When <code>cWnd < ssThresh / 2</code> use a slow start algorithm similar to <code>ns3::TcpLinuxReno</code>.
** <code>TcpPrague::CwndChanged ()</code>: Call <code>TcpPrague::AiAckIncrease</code> whenever congestion window is updated.
** <code>TcpPrague::EnterLoss ()</code>: On encountering a packet loss, gradually reduce congestion window to half its original value.
* Validated this refactored implementation against Linux namespaces and obtained [https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- alignment] in the one-flow scenario.

=== Week 12 (August 17 - August 23)===
* Implemented a [https://gitlab.com/deepakkavoor/nest/-/blob/prague-expt/examples/rtt-indep-prague.py topology] in Linux namespaces corresponding to the two-flow scenario, with Prague and Reno running over a common bottleneck supporting Dual Queue.
* Obtained aligning [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ results] in the two-flow scenario that validates RTT independence in ns-3 Prague with that of Linux.
* Worked on adding final documentation of TCP Prague to ns-3.
* Worked on the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

=== Week 13 (August 24 - August 30)===
* Added doxygen comments to the ns-3 Prague model.
* Updated the [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 MR] for ns-3 Prague model.
* Fixed [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 issues] related to delayed acknowledgements in the TCP pacing test suite.
* Worked on understanding how TCP system tests are written in ns-3.

GSOC2020Prague

2020-08-29T16:10:58Z

Deepakk: /* Milestones and Deliverables */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].
Along with the above features, I also worked on the following aspects that were indirectly related to TCP Prague:
* ECN++ and Accurate ECN, which were implemented in ns-3 as part of a 2018 [https://ecnpp-accecn-gsoc-2018.github.io/ GSoC project] was rebased onto ns-3-dev, along with a few revisions to test suites. The rebased branch can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commits/squash-accecn-rebased here].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T16:05:11Z

Deepakk: /* Milestones and Deliverables */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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" <code>cWnd</code> 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 [https://gitlab.com/tomhend/modules/l4s-evaluation l4s-evaluation module] to validate ns-3 Prague with Linux. The topology was evaluated in Linux using network namespaces (specifically using the [https://gitlab.com/nitk-nest/nest NeST framework]).

A more elaborate description of the features added in these phases can be found in the [https://deepakkavoor.github.io/gsoc-2020-prague/ project site].

= Weekly Reports =
=== Community Bonding Period (May 4 - May 31) ===
* Established the Wiki page for this project.
* Rebased the GSoC 2018 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T14:43:44Z

Deepakk: /* Milestones and Deliverables */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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: <code>pacingRate = factor * cWnd * MSS / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T14:42:07Z

Deepakk: /* Milestones and Deliverables */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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.
* <code>pacingRate = factor * cwnd * mss / rtt</code>
* The value of <code>factor</code> 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 <code>cWnd</code> 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: <code>increment = (curRTT / targetRTT) * (curRTT / targetRTT) * 1 / cWnd</code>, where <code>curRTT</code> denotes the current RTT measurement and <code>targetRTT</code> 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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T14:15:33Z

Deepakk: /* Milestones and Deliverables */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 commit]).

= Milestones and Deliverables =

=== Phase 1 ===
* It was decided that TCP 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.
* <code>pacingRate = factor * cwnd * mss / rtt</code>
* The value of <code>factor</code> 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.
* Ran experiments in ns-3 to try and show improvements when using dynamic pacing.

=== 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 ===
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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T04:48:32Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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 <code>factor</code> 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.
<pre>pacing_rate = factor * cwnd * mss / rtt</pre>
* 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 ===
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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T04:46:57Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 were not part of GSoC scope of work, 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 [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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 <code>factor</code> 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.
<pre>pacing_rate = factor * cwnd * mss / rtt</pre>
* 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 ===
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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T04:44:26Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, along with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ 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 this aspect. A few features that were not part of GSoC scope, but would definitely help the ns-3 Prague model include merging Dual Queue model to ns-3, adding Classic ECN detection feature to TCP Prague and merging Accurate ECN to ns-3.
* '''Project Page:''' A [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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 <code>factor</code> 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.
<pre>pacing_rate = factor * cwnd * mss / rtt</pre>
* 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 ===
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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-29T04:03:03Z

Deepakk: /* Project Overview */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 to TCP with a test suite ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 link to code])
** TCP Prague that aligns with contemporary Linux implementation, with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** RTT independence in TCP Prague, with unit tests ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 link to code])
** Experiments to generate plots and validate the ns-3 implementation of TCP Prague with Linux ([https://drive.google.com/drive/folders/1qUhWiFwFO9eM8JQZWinMoD2TZVkC4Ca- links] [https://drive.google.com/drive/folders/1hBZ2SUlfSWEO1gRhXeUmGfAzXmd8DRGJ to] results)
* '''Future Work:'''
* '''Project Page:''' A [https://deepakkavoor.github.io/gsoc-2020-prague/ 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 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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 <code>factor</code> 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.
<pre>pacing_rate = factor * cwnd * mss / rtt</pre>
* 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 ===
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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-28T14:12:58Z

Deepakk: /* Weekly Reports */

{{TOC}}

Back to [[Summer_Projects#Google_Summer_of_Code_2020 | GSoC 2020 projects]]

= Project Overview =

* '''Project Name:''' TCP Prague model for ns-3
* '''Student:''' [mailto:deepakkavoor99@gmail.com Deepak K]
* '''Mentors:''' [mailto:adadeepak8@gmail.com Ankit Deepak], [mailto:tahiliani.nitk@gmail.com Mohit Tahiliani], [mailto:jain.vivek.anand@gmail.com Vivek Jain], [mailto:viyommittal@gmail.com 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 [https://docs.google.com/document/d/17WmcPW74gGmAB_mg1y4B_ZRptNgEPkPWAzpEyK86RA4/edit?usp=sharing here].
* '''Repository:''' [https://gitlab.com/deepakkavoor/ns-3-dev 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 [https://gitlab.com/nsnam/ns-3-dev/-/commit/94495ca0ef8bc0ed92ebb7430bcedb520f9e3847 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 <code>factor</code> 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.
<pre>pacing_rate = factor * cwnd * mss / rtt</pre>
* 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 ===
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 [https://www.nsnam.org/wiki/GSOC2018AccECN_ECN%2B%2B implementation] of ECN++ and AccECN (without TCP options) to the latest ns-3-dev. The rebased branches can be found in my [https://gitlab.com/deepakkavoor/ns-3-dev repository]
* Went through the TCP models and architecture in ns-3 and studied about [https://github.com/JoakimMisund/PacedChirping 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 [https://docs.google.com/document/d/1PPSLOHv_t2GCkvd9b7YFWQGyQuFtsExJX2oAwQx5tEs/edit?usp=sharing here].
* Integrated basic pacing model for New Reno, DCTCP and TCP Prague in ns-3 by adding methods <code> PacingEnabled</code> and <code> UpdatePacingRate</code>. 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 <code> TcpPrague::CongControl</code>.
* Designed a test suite <code> TcpPacingTest</code> to test TCP packet pacing rate during Slow Start and Congestion Avoidance.
* Rebased Joakim Misund's [https://gitlab.com/JoakimMisund/l4s-evaluation/-/tree/tcp-prague/ work] on ns-3 Prague to latest ns-3-dev.
* Generated an [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 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 [https://docs.google.com/document/d/1uSFm7tdjHJcvLan7vKVtjtj0ZlrwSmoaw_O2-n-qd20/edit?usp=sharing document] (work in progress).
* Added code to enable different scaling heuristics (similar to Linux).
<pre>
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;
</pre>
* The initial commit can be found [https://gitlab.com/deepakkavoor/ns-3-dev/-/commit/d10dcdcd8c7697d0e6f223167b673a79bcc70542 here].

=== Week 4 (June 22 - June 28) ===
* Divided the MR (from Week 2) to now separately add support for dynamic pacing ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/339 !339]) and TCP Prague ([https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/331 !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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/341 ECN++] and [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/342 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 <code>examples/tcp/tcp-pacing.cc</code> 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 [https://homes.cs.washington.edu/~tom/pubs/pacing.pdf here].
* Continued the work on RTT Independence and added/modified the following methods:
** <code>TcpPrague::AiAckIncrease ()</code>: Update the per-ACK cWnd AI increase factor depending on the current RTT scaling heuristic.
** <code>TcpPrague::IncreaseWindow ()</code>: Consider the RTT scaling factor when updating cWnd during AI.
** <code>TcpPrague::PktsAcked ()</code>: Apply the EWMA update equation and increase round count only if the value returned by <code>TcpPrague::ShouldUpdateEwma ()</code> 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 [https://github.com/l4steam/linux here].
* Worked on setting up a [https://gitlab.com/tomhend/modules/l4s-evaluation/-/blob/hackathon/master/examples/tsvwg-scenarios.cc topology] in this kernel using Linux namespaces.

=== Week 10 (August 03 - August 09)===
* Tried to run experiments with the [https://gitlab.com/tomhend/modules/l4s-evaluation/-/tree/hackathon/master 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 [https://gitlab.com/nsnam/ns-3-dev/-/merge_requests/373 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.

GSOC2020Prague

2020-08-28T14:10:04Z

Deepakk: /* Phase 3 */

GSOC2020Prague

2020-08-21T15:53:08Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-08-21T15:50:31Z

Deepakk: /* Phase 3 */

GSOC2020Prague

2020-08-07T17:20:35Z

Deepakk: /* Week 9 (July 27 - August 02) */

GSOC2020Prague

2020-08-07T17:20:07Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-07-29T19:41:02Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-07-17T06:54:11Z

Deepakk: /* Week 7 (July 13 - July 19) */

GSOC2020Prague

2020-07-17T06:53:18Z

Deepakk: /* Week 7 (July 13 - July 19) */

GSOC2020Prague

2020-07-17T06:52:26Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-07-17T06:51:03Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-07-10T17:05:41Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-07-10T17:05:11Z

Deepakk: /* Week 6 (July 13 - July 19) */

GSOC2020Prague

2020-07-10T17:04:12Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-07-02T08:18:30Z

Deepakk: /* Community Bonding Period (May 4 - May 31) */

GSOC2020Prague

2020-07-02T08:17:36Z

Deepakk: /* Phase 1 details */

GSOC2020Prague

2020-06-25T12:02:14Z

Deepakk: /* Project Overview */

GSOC2020Prague

2020-06-25T11:52:06Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-06-15T05:23:54Z

Deepakk: /* Week 2 Reports */

GSOC2020Prague

2020-06-08T17:22:26Z

Deepakk: /* Weekly Reports */

GSOC2020Prague

2020-06-01T10:24:46Z

Deepakk: /* Updated first month progress */

GSOC2020Prague

2020-05-06T10:42:41Z

Deepakk: /* Project Overview - Provided link to my proposal */

GSOC2020Prague

2020-05-06T10:03:22Z

Deepakk: /* Project Overview - Added student and project details */