---

TCP Hybla (2004 research)

---

• Recent Improvement on Floyd's work
  • Floyd's modification on TCP (done in 1991) to achieve constant increase in Throughput has been improved by Caini and Firrincieli in 2004

  • This new TCP protocol is called: TCP Hybla

  • Although TCP Hybla has many features in common with Floyd's work, the design process of TCP Hybla is much more careful and it is worth a study.

  • Also, while Floyd only considered changing the operation of the TCP protocol to achieve constant (equal) increase in throughput in the congestion avoidance phase , Caini and Firrincieli also considered changing the operation of the TCP protocol to achieve constant (equal) increase in throughput in the slow start phase - as such, TCP Hybla is more "complete".

  ---

  ---

• Characterization of standard Reno TCP
  • The congestion window W is updated per each NEW ACK as follows:

    • SS = Slow Start phase

    • CA = Congestion Avoidance phase

  • As we know well by now, this results in:

    Doubling of W per RTT seconds during SS Increase of ONE in W per RTT seconds during CA

    ---

  • We can express W(t) as followings:
    where:

    γ is the value of the Slow Start Threshold (SSThresh) tγ is the time when TCP exits the Slow Start phase tγ can be found by solving: W(t) = tγ t ----- RTT ==> 2 = tγ t ==> ----- = log(tγ) RTT ==> t = RTT log(tγ) So: tγ = RTT *log(γ)

  • The function W(t) clearly expressed these facts:
    1. At time t = 0 , W(0) = 2⁰ = 1

    2. During SS, at time t = RTT , W(RTT) = 2¹ = 2

    3. During SS, at time t = 2*RTT , W(RTT) = 2² = 4

    4. So during SS, W(t) doubles per RTT seconds

       ---

    5. The second equation tells us that at time t = t_γ , W(t_γ) = γ

       This is the moment that TCP exits SS and enters CA

    6. Then at time t = t_γ + RTT, W(t_γ + RTT) = 1 + γ

       So the second equation indeed increases congestion window W(t) by ONE per RTT seconds.

    ---

  • The following figure shows various functions W(t) for 3 TCP flows different values of RTT - each TCP flow has the same value of SS Threshold (32) :

  • We can clearly see that the longer RTT TCP flow took a longer TIME to end the SLOW START phase

  • In other words:

    Even if we "take care of" the unfairness in throughput during the CA avoidance phase, unfairness in throughput will still persist because the TCP flows with longer RTT will be slower in the SLOW START phase

  ---

• Yet another Throughput expression for TCP Reno
  • IF we knew what the value of the slow start threshold γ was, we could obtain the Throughput of the TCP in the following manner

  • From the function for the congestion window size W(t) :

    Then the segment (packet) transmission rate of the TCP connection is:

    RTT |<-------------------------------->| W(t) ---+----------------------------------+--------- \ \ W(t) segments en route to destination W(t) Transmission rate = B(t) = ------ (# packets / sec) RTT

    NOTE: the notation B(t) in the Hybla TCP paper means: "segment transmission rate at time t" The notation B(t) in Padhye's paper means: "Throughput of TCP at time t" Yes, it's confusing, but I try to keep the same notation used in each paper

    ---

  • The throughput of the TCP connection is equal to the area under the function B(t) (which is equal to the integral of B(t)):

  • Verify with Maple:

    integrate( 2^(t/RTT)/RTT, t); / t \ |---| \RTT/ 2 ------ (+ constant) ln(2) integrate( (t-t0)/(RTT^2) +Gamma/RTT, t); 2 1/2 t - t0 t Gamma t ------------- + ------- (+ constant) 2 RTT RTT

    (This situation is similar to the relationship between velocity and distance traveled:)

    • velocity = amount of distance traveled per sec
    • distance = area under the velocity function

  ---

  ---

• Designing for Fairness in Throughput
  • In order to make the throughput of TCP independent of RTT , we must do the following:

    throughput during the CA phase must be independent of RTT BUT ALSO: throughput during the SS phase must be independent of RTT

    ---

  • To realise these objectives, they introduced the following normalized round trip time ρ:

    RTT ρ = ------ RTT0

    where RTT₀ is some pre-determined round trip time (e.g., 25 msec).

  • The key in the design for RTT fairness is:

    ALL TCP Hybla connection that have the SAME slow start threshold will that the SAME amount of time to exit the slow start phase

    ---

    ---

  • In order to make ALL TCP Hybla connection go through the SAME duration of slow start for a given SS Threshold value γ, the TCP Hybla Slow Start threshold value is changed to:

    Reno Slow Start threshold value = γ RTT TCP Hybla Slow Start threshold value = ρ * γ = ------ γ RTT0

    ---

    ---

  • Let us first give the TCP Hybla congestion window function as is (later we will determine how to increase CWND to achieve this function):

    where

    • ρ * γ is the TCP Hybla Slow Start threshold value

    • t_γ,0 is the time that TCP Hybla exits the Slow Start phase (and enters the congestion avoidance phase)

    ---

  • If we re-write W^H(t) without using ρ , some computations are simplified:

    RTT ρ 2(ρ*t/RTT) = ----- 2(t/RTT0) . . . . . . . . (SS) RTT0 WH(t) = t - tγ,0 RTT t - tγ,0 ρ ( ρ ---------- + γ ) = ----- ( --------- + γ ) . . . . (CA) RTT RTT0 RTT0

    ---

  • The TCP Hybla congestion window function has the following properties:

    1. TCP connection with the SS Threshold will take the same amount of time to exit the SS phase

       Reason:

       • Suppose the SS Threshold is γ

       • Then TCP Hybla will use this value to terminate the SS phase: ρ * γ

       • Therefore, the time t_γ,0 that a TCP Hybla agent exit the SS phase is equal to:

         RTT WH(t) = ----- 2(t/RTT0) = ρ * γ RTT0 RTT RTT ==> ----- 2(t/RTT0) = ------ * γ RTT0 RTT0 <==> 2(t/RTT0) = γ t <==> ----- = log2( γ ) RTT0 <==> t = RTT0 log2( γ ) ==> tγ,0 = RTT0 log2( γ )

       • Since t_γ,0 is independent of RTT, every TCP Hybla connection will take the same amount of time to exit the SS Phase for the same SS Threshold

       ---

    2. The segment transmission rate function of TCP Hybla is independent from RTT:

       1 = ----- 2(t/RTT0) . . . . . (SS) RTT0 WH(t) BH(t) = ----- RTT 1 t - tγ,0 = ----- ( --------- + γ ) . . . . (CA) RTT0 RTT0

       As we have just seen before, t_γ,0 is independent of RTT

       Therefore, RTT does not appear anywhere as a factor in B^H(t) --- so B^H(t) is independent of RTT

    ---

  • The following are some plots of 3 different TCP Hybla congestion window functions for different value of RTT with the SAME SS Threshold:

  • Notice that all TCP Hybla connection will exit the >Slow Start Phase at the same time

  • However, the congestion window at the exit time is &rho * γ

    A TCP Hybla connection with longer RTT needs to end up at a higher CWND to achieve the SAME throughput per time unit (second)

    ---

  • This is a simple matter of exercise (in Analysis 101 - integration theory) to show that the TCP Hybla throughput function is equal to:

  ---

  ---

• Increase and Decrease Algorithm of TCP Hybla
  • OK, we know that we want the congestion window function to be:

    Now HOW should the CWND be updated ( per each NEW ACK) so that TCP Hybla's CWND will be equal to the given function ?

    ---

  • In other words:

    What are the values for α and β for the update of CWND W:

    WHi + α . . . . (SS) WHi+1 = WHi + β . . . . (CA)

    so that:

  • According to the authors of TCP Hybla, the CWND window update must be as follows:

    WHi + 2ρ - 1 . . . . (SS) WHi+1 = ρ2 WHi + ----- . . . . (CA) WHi

    In a homework, you can verify this fact (it's a lot easier to verify the correctness of a solution than to find a solution)

    ---

  • Decrease algorithm:
    • Slow Start
      • SSThreshold = ρ * CWND/2

        NOTE: I think in their implemetation, they set:

        SSThreshold = CWND / 2

      • CWND = ρ * 1

        NOTE: The way they implemented CWND = ρ is changing wnd_init_:

        • wnd_init_ = (int)floor(rho_);

          They then call TcpAgent::timeout(tno); which will use wnd_init_ as initial cwnd_

          See: click here - look for the function void HyblaSTcpAgent::timeout(int tno)

    • Fast Recovery (Triple Duplicate ACK)
      • SSThreashold = CWND/2
      • CWND = CWND/2

        (The paper did not say - but I found the statement slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF); in the source code)

  ---

  ---

• Performance evaluation of TCP Hybla
  • Here is the throughput of 3 flows using TCP Hybla and 3 flows using TCP Reno with different RTT values:

    • As we know, the TCP Reno flows have different throughputs

    • Amazingly, ALL TCP Hybla have the (approximately) SAME throughput

  ---

  ---

• Implementation of TCP Hybla in NS
  • TCP Hybla is NOT incorporated in NS

  • But, you can added it easily to NS by following the following instructions.

  • TCP Hybla Source code: (Demo above code)                                                
    • TCP Hybla C++ header file: click here
    • TCP Hybla C++ program file: click here
    • Instructions to incorporate TCP Hybla into NS: click here