forked from MetaCubeX/mihomo
-
Notifications
You must be signed in to change notification settings - Fork 1
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
8 changed files
with
704 additions
and
14 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,213 @@ | ||
| package congestion | ||
|
|
||
| import ( | ||
| "math" | ||
| "time" | ||
|
|
||
| "github.com/metacubex/quic-go/congestion" | ||
| ) | ||
|
|
||
| // This cubic implementation is based on the one found in Chromiums's QUIC | ||
| // implementation, in the files net/quic/congestion_control/cubic.{hh,cc}. | ||
|
|
||
| // Constants based on TCP defaults. | ||
| // The following constants are in 2^10 fractions of a second instead of ms to | ||
| // allow a 10 shift right to divide. | ||
|
|
||
| // 1024*1024^3 (first 1024 is from 0.100^3) | ||
| // where 0.100 is 100 ms which is the scaling round trip time. | ||
| const ( | ||
| cubeScale = 40 | ||
| cubeCongestionWindowScale = 410 | ||
| cubeFactor congestion.ByteCount = 1 << cubeScale / cubeCongestionWindowScale / maxDatagramSize | ||
| // TODO: when re-enabling cubic, make sure to use the actual packet size here | ||
| maxDatagramSize = congestion.ByteCount(InitialPacketSizeIPv4) | ||
| ) | ||
|
|
||
| const defaultNumConnections = 1 | ||
|
|
||
| // Default Cubic backoff factor | ||
| const beta float32 = 0.7 | ||
|
|
||
| // Additional backoff factor when loss occurs in the concave part of the Cubic | ||
| // curve. This additional backoff factor is expected to give up bandwidth to | ||
| // new concurrent flows and speed up convergence. | ||
| const betaLastMax float32 = 0.85 | ||
|
|
||
| // Cubic implements the cubic algorithm from TCP | ||
| type Cubic struct { | ||
| clock Clock | ||
|
|
||
| // Number of connections to simulate. | ||
| numConnections int | ||
|
|
||
| // Time when this cycle started, after last loss event. | ||
| epoch time.Time | ||
|
|
||
| // Max congestion window used just before last loss event. | ||
| // Note: to improve fairness to other streams an additional back off is | ||
| // applied to this value if the new value is below our latest value. | ||
| lastMaxCongestionWindow congestion.ByteCount | ||
|
|
||
| // Number of acked bytes since the cycle started (epoch). | ||
| ackedBytesCount congestion.ByteCount | ||
|
|
||
| // TCP Reno equivalent congestion window in packets. | ||
| estimatedTCPcongestionWindow congestion.ByteCount | ||
|
|
||
| // Origin point of cubic function. | ||
| originPointCongestionWindow congestion.ByteCount | ||
|
|
||
| // Time to origin point of cubic function in 2^10 fractions of a second. | ||
| timeToOriginPoint uint32 | ||
|
|
||
| // Last congestion window in packets computed by cubic function. | ||
| lastTargetCongestionWindow congestion.ByteCount | ||
| } | ||
|
|
||
| // NewCubic returns a new Cubic instance | ||
| func NewCubic(clock Clock) *Cubic { | ||
| c := &Cubic{ | ||
| clock: clock, | ||
| numConnections: defaultNumConnections, | ||
| } | ||
| c.Reset() | ||
| return c | ||
| } | ||
|
|
||
| // Reset is called after a timeout to reset the cubic state | ||
| func (c *Cubic) Reset() { | ||
| c.epoch = time.Time{} | ||
| c.lastMaxCongestionWindow = 0 | ||
| c.ackedBytesCount = 0 | ||
| c.estimatedTCPcongestionWindow = 0 | ||
| c.originPointCongestionWindow = 0 | ||
| c.timeToOriginPoint = 0 | ||
| c.lastTargetCongestionWindow = 0 | ||
| } | ||
|
|
||
| func (c *Cubic) alpha() float32 { | ||
| // TCPFriendly alpha is described in Section 3.3 of the CUBIC paper. Note that | ||
| // beta here is a cwnd multiplier, and is equal to 1-beta from the paper. | ||
| // We derive the equivalent alpha for an N-connection emulation as: | ||
| b := c.beta() | ||
| return 3 * float32(c.numConnections) * float32(c.numConnections) * (1 - b) / (1 + b) | ||
| } | ||
|
|
||
| func (c *Cubic) beta() float32 { | ||
| // kNConnectionBeta is the backoff factor after loss for our N-connection | ||
| // emulation, which emulates the effective backoff of an ensemble of N | ||
| // TCP-Reno connections on a single loss event. The effective multiplier is | ||
| // computed as: | ||
| return (float32(c.numConnections) - 1 + beta) / float32(c.numConnections) | ||
| } | ||
|
|
||
| func (c *Cubic) betaLastMax() float32 { | ||
| // betaLastMax is the additional backoff factor after loss for our | ||
| // N-connection emulation, which emulates the additional backoff of | ||
| // an ensemble of N TCP-Reno connections on a single loss event. The | ||
| // effective multiplier is computed as: | ||
| return (float32(c.numConnections) - 1 + betaLastMax) / float32(c.numConnections) | ||
| } | ||
|
|
||
| // OnApplicationLimited is called on ack arrival when sender is unable to use | ||
| // the available congestion window. Resets Cubic state during quiescence. | ||
| func (c *Cubic) OnApplicationLimited() { | ||
| // When sender is not using the available congestion window, the window does | ||
| // not grow. But to be RTT-independent, Cubic assumes that the sender has been | ||
| // using the entire window during the time since the beginning of the current | ||
| // "epoch" (the end of the last loss recovery period). Since | ||
| // application-limited periods break this assumption, we reset the epoch when | ||
| // in such a period. This reset effectively freezes congestion window growth | ||
| // through application-limited periods and allows Cubic growth to continue | ||
| // when the entire window is being used. | ||
| c.epoch = time.Time{} | ||
| } | ||
|
|
||
| // CongestionWindowAfterPacketLoss computes a new congestion window to use after | ||
| // a loss event. Returns the new congestion window in packets. The new | ||
| // congestion window is a multiplicative decrease of our current window. | ||
| func (c *Cubic) CongestionWindowAfterPacketLoss(currentCongestionWindow congestion.ByteCount) congestion.ByteCount { | ||
| if currentCongestionWindow+maxDatagramSize < c.lastMaxCongestionWindow { | ||
| // We never reached the old max, so assume we are competing with another | ||
| // flow. Use our extra back off factor to allow the other flow to go up. | ||
| c.lastMaxCongestionWindow = congestion.ByteCount(c.betaLastMax() * float32(currentCongestionWindow)) | ||
| } else { | ||
| c.lastMaxCongestionWindow = currentCongestionWindow | ||
| } | ||
| c.epoch = time.Time{} // Reset time. | ||
| return congestion.ByteCount(float32(currentCongestionWindow) * c.beta()) | ||
| } | ||
|
|
||
| // CongestionWindowAfterAck computes a new congestion window to use after a received ACK. | ||
| // Returns the new congestion window in packets. The new congestion window | ||
| // follows a cubic function that depends on the time passed since last | ||
| // packet loss. | ||
| func (c *Cubic) CongestionWindowAfterAck( | ||
| ackedBytes congestion.ByteCount, | ||
| currentCongestionWindow congestion.ByteCount, | ||
| delayMin time.Duration, | ||
| eventTime time.Time, | ||
| ) congestion.ByteCount { | ||
| c.ackedBytesCount += ackedBytes | ||
|
|
||
| if c.epoch.IsZero() { | ||
| // First ACK after a loss event. | ||
| c.epoch = eventTime // Start of epoch. | ||
| c.ackedBytesCount = ackedBytes // Reset count. | ||
| // Reset estimated_tcp_congestion_window_ to be in sync with cubic. | ||
| c.estimatedTCPcongestionWindow = currentCongestionWindow | ||
| if c.lastMaxCongestionWindow <= currentCongestionWindow { | ||
| c.timeToOriginPoint = 0 | ||
| c.originPointCongestionWindow = currentCongestionWindow | ||
| } else { | ||
| c.timeToOriginPoint = uint32(math.Cbrt(float64(cubeFactor * (c.lastMaxCongestionWindow - currentCongestionWindow)))) | ||
| c.originPointCongestionWindow = c.lastMaxCongestionWindow | ||
| } | ||
| } | ||
|
|
||
| // Change the time unit from microseconds to 2^10 fractions per second. Take | ||
| // the round trip time in account. This is done to allow us to use shift as a | ||
| // divide operator. | ||
| elapsedTime := int64(eventTime.Add(delayMin).Sub(c.epoch)/time.Microsecond) << 10 / (1000 * 1000) | ||
|
|
||
| // Right-shifts of negative, signed numbers have implementation-dependent | ||
| // behavior, so force the offset to be positive, as is done in the kernel. | ||
| offset := int64(c.timeToOriginPoint) - elapsedTime | ||
| if offset < 0 { | ||
| offset = -offset | ||
| } | ||
|
|
||
| deltaCongestionWindow := congestion.ByteCount(cubeCongestionWindowScale*offset*offset*offset) * maxDatagramSize >> cubeScale | ||
| var targetCongestionWindow congestion.ByteCount | ||
| if elapsedTime > int64(c.timeToOriginPoint) { | ||
| targetCongestionWindow = c.originPointCongestionWindow + deltaCongestionWindow | ||
| } else { | ||
| targetCongestionWindow = c.originPointCongestionWindow - deltaCongestionWindow | ||
| } | ||
| // Limit the CWND increase to half the acked bytes. | ||
| targetCongestionWindow = Min(targetCongestionWindow, currentCongestionWindow+c.ackedBytesCount/2) | ||
|
|
||
| // Increase the window by approximately Alpha * 1 MSS of bytes every | ||
| // time we ack an estimated tcp window of bytes. For small | ||
| // congestion windows (less than 25), the formula below will | ||
| // increase slightly slower than linearly per estimated tcp window | ||
| // of bytes. | ||
| c.estimatedTCPcongestionWindow += congestion.ByteCount(float32(c.ackedBytesCount) * c.alpha() * float32(maxDatagramSize) / float32(c.estimatedTCPcongestionWindow)) | ||
| c.ackedBytesCount = 0 | ||
|
|
||
| // We have a new cubic congestion window. | ||
| c.lastTargetCongestionWindow = targetCongestionWindow | ||
|
|
||
| // Compute target congestion_window based on cubic target and estimated TCP | ||
| // congestion_window, use highest (fastest). | ||
| if targetCongestionWindow < c.estimatedTCPcongestionWindow { | ||
| targetCongestionWindow = c.estimatedTCPcongestionWindow | ||
| } | ||
| return targetCongestionWindow | ||
| } | ||
|
|
||
| // SetNumConnections sets the number of emulated connections | ||
| func (c *Cubic) SetNumConnections(n int) { | ||
| c.numConnections = n | ||
| } |
Oops, something went wrong.