From 62266010aca1510d7e10a5cbbbfbbb682b7605fb Mon Sep 17 00:00:00 2001 From: wwqgtxx Date: Thu, 21 Sep 2023 08:25:26 +0800 Subject: [PATCH] Revert "migration: go 1.21" This reverts commit 33d41338ef00ff20e444e03f3d9ee7b60fc787a4. --- adapter/adapter.go | 12 ++++++------ common/observable/observable_test.go | 6 +++--- go.mod | 2 +- hub/updater/limitedreader.go | 13 ++++++++++++- transport/tuic/congestion/cubic.go | 2 +- transport/tuic/congestion/cubic_sender.go | 4 ++-- .../tuic/congestion/hybrid_slow_start.go | 4 ++-- transport/tuic/congestion/minmax.go | 2 +- transport/tuic/congestion/minmax_go120.go | 19 +++++++++++++++++++ transport/tuic/congestion/minmax_go121.go | 13 +++++++++++++ transport/tuic/congestion/pacer.go | 6 +++--- 11 files changed, 63 insertions(+), 20 deletions(-) create mode 100644 transport/tuic/congestion/minmax_go120.go create mode 100644 transport/tuic/congestion/minmax_go121.go diff --git a/adapter/adapter.go b/adapter/adapter.go index abef3d89..13f7f06f 100644 --- a/adapter/adapter.go +++ b/adapter/adapter.go @@ -136,21 +136,21 @@ func (p *Proxy) ExtraDelayHistory() map[string][]C.DelayHistory { // LastDelay return last history record. if proxy is not alive, return the max value of uint16. // implements C.Proxy func (p *Proxy) LastDelay() (delay uint16) { - var maxDelay uint16 = 0xffff + var max uint16 = 0xffff if !p.alive.Load() { - return maxDelay + return max } history := p.history.Last() if history.Delay == 0 { - return maxDelay + return max } return history.Delay } // LastDelayForTestUrl implements C.Proxy func (p *Proxy) LastDelayForTestUrl(url string) (delay uint16) { - var maxDelay uint16 = 0xffff + var max uint16 = 0xffff alive := p.alive.Load() history := p.history.Last() @@ -161,11 +161,11 @@ func (p *Proxy) LastDelayForTestUrl(url string) (delay uint16) { } if !alive { - return maxDelay + return max } if history.Delay == 0 { - return maxDelay + return max } return history.Delay } diff --git a/common/observable/observable_test.go b/common/observable/observable_test.go index 3f0b0e7f..5a02273d 100644 --- a/common/observable/observable_test.go +++ b/common/observable/observable_test.go @@ -85,16 +85,16 @@ func TestObservable_UnSubscribeWithNotExistSubscription(t *testing.T) { func TestObservable_SubscribeGoroutineLeak(t *testing.T) { iter := iterator[int]([]int{1, 2, 3, 4, 5}) src := NewObservable[int](iter) - total := 100 + max := 100 var list []Subscription[int] - for i := 0; i < total; i++ { + for i := 0; i < max; i++ { ch, _ := src.Subscribe() list = append(list, ch) } var wg sync.WaitGroup - wg.Add(total) + wg.Add(max) waitCh := func(ch <-chan int) { for range ch { } diff --git a/go.mod b/go.mod index ca98937b..f75f58fd 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/Dreamacro/clash -go 1.21 +go 1.20 require ( github.com/3andne/restls-client-go v0.1.6 diff --git a/hub/updater/limitedreader.go b/hub/updater/limitedreader.go index 52d7e969..c31db601 100644 --- a/hub/updater/limitedreader.go +++ b/hub/updater/limitedreader.go @@ -3,6 +3,8 @@ package updater import ( "fmt" "io" + + "golang.org/x/exp/constraints" ) // LimitReachedError records the limit and the operation that caused it. @@ -33,7 +35,7 @@ func (lr *limitedReader) Read(p []byte) (n int, err error) { } } - p = p[:min(lr.n, int64(len(p)))] + p = p[:Min(lr.n, int64(len(p)))] n, err = lr.r.Read(p) lr.n -= int64(n) @@ -54,3 +56,12 @@ func LimitReader(r io.Reader, n int64) (limited io.Reader, err error) { n: n, }, nil } + +// Min returns the smaller of x or y. +func Min[T constraints.Integer | ~string](x, y T) (res T) { + if x < y { + return x + } + + return y +} diff --git a/transport/tuic/congestion/cubic.go b/transport/tuic/congestion/cubic.go index 7dbe2b06..dd491a32 100644 --- a/transport/tuic/congestion/cubic.go +++ b/transport/tuic/congestion/cubic.go @@ -186,7 +186,7 @@ func (c *Cubic) CongestionWindowAfterAck( targetCongestionWindow = c.originPointCongestionWindow - deltaCongestionWindow } // Limit the CWND increase to half the acked bytes. - targetCongestionWindow = min(targetCongestionWindow, currentCongestionWindow+c.ackedBytesCount/2) + 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 diff --git a/transport/tuic/congestion/cubic_sender.go b/transport/tuic/congestion/cubic_sender.go index a467b8c9..ca20b420 100644 --- a/transport/tuic/congestion/cubic_sender.go +++ b/transport/tuic/congestion/cubic_sender.go @@ -177,7 +177,7 @@ func (c *cubicSender) OnPacketAcked( priorInFlight congestion.ByteCount, eventTime time.Time, ) { - c.largestAckedPacketNumber = max(ackedPacketNumber, c.largestAckedPacketNumber) + c.largestAckedPacketNumber = Max(ackedPacketNumber, c.largestAckedPacketNumber) if c.InRecovery() { return } @@ -245,7 +245,7 @@ func (c *cubicSender) maybeIncreaseCwnd( c.numAckedPackets = 0 } } else { - c.congestionWindow = min(c.maxCongestionWindow(), c.cubic.CongestionWindowAfterAck(ackedBytes, c.congestionWindow, c.rttStats.MinRTT(), eventTime)) + c.congestionWindow = Min(c.maxCongestionWindow(), c.cubic.CongestionWindowAfterAck(ackedBytes, c.congestionWindow, c.rttStats.MinRTT(), eventTime)) } } diff --git a/transport/tuic/congestion/hybrid_slow_start.go b/transport/tuic/congestion/hybrid_slow_start.go index e0b42e53..7586774e 100644 --- a/transport/tuic/congestion/hybrid_slow_start.go +++ b/transport/tuic/congestion/hybrid_slow_start.go @@ -74,8 +74,8 @@ func (s *HybridSlowStart) ShouldExitSlowStart(latestRTT time.Duration, minRTT ti // Divide minRTT by 8 to get a rtt increase threshold for exiting. minRTTincreaseThresholdUs := int64(minRTT / time.Microsecond >> hybridStartDelayFactorExp) // Ensure the rtt threshold is never less than 2ms or more than 16ms. - minRTTincreaseThresholdUs = min(minRTTincreaseThresholdUs, hybridStartDelayMaxThresholdUs) - minRTTincreaseThreshold := time.Duration(max(minRTTincreaseThresholdUs, hybridStartDelayMinThresholdUs)) * time.Microsecond + minRTTincreaseThresholdUs = Min(minRTTincreaseThresholdUs, hybridStartDelayMaxThresholdUs) + minRTTincreaseThreshold := time.Duration(Max(minRTTincreaseThresholdUs, hybridStartDelayMinThresholdUs)) * time.Microsecond if s.currentMinRTT > (minRTT + minRTTincreaseThreshold) { s.hystartFound = true diff --git a/transport/tuic/congestion/minmax.go b/transport/tuic/congestion/minmax.go index 50667766..0a8f4ad4 100644 --- a/transport/tuic/congestion/minmax.go +++ b/transport/tuic/congestion/minmax.go @@ -16,7 +16,7 @@ func MinNonZeroDuration(a, b time.Duration) time.Duration { if b == 0 { return a } - return min(a, b) + return Min(a, b) } // AbsDuration returns the absolute value of a time duration diff --git a/transport/tuic/congestion/minmax_go120.go b/transport/tuic/congestion/minmax_go120.go new file mode 100644 index 00000000..1266edbc --- /dev/null +++ b/transport/tuic/congestion/minmax_go120.go @@ -0,0 +1,19 @@ +//go:build !go1.21 + +package congestion + +import "golang.org/x/exp/constraints" + +func Max[T constraints.Ordered](a, b T) T { + if a < b { + return b + } + return a +} + +func Min[T constraints.Ordered](a, b T) T { + if a < b { + return a + } + return b +} diff --git a/transport/tuic/congestion/minmax_go121.go b/transport/tuic/congestion/minmax_go121.go new file mode 100644 index 00000000..65b06726 --- /dev/null +++ b/transport/tuic/congestion/minmax_go121.go @@ -0,0 +1,13 @@ +//go:build go1.21 + +package congestion + +import "cmp" + +func Max[T cmp.Ordered](a, b T) T { + return max(a, b) +} + +func Min[T cmp.Ordered](a, b T) T { + return min(a, b) +} diff --git a/transport/tuic/congestion/pacer.go b/transport/tuic/congestion/pacer.go index 9e85107d..f60ef5fe 100644 --- a/transport/tuic/congestion/pacer.go +++ b/transport/tuic/congestion/pacer.go @@ -52,11 +52,11 @@ func (p *pacer) Budget(now time.Time) congestion.ByteCount { return p.maxBurstSize() } budget := p.budgetAtLastSent + (congestion.ByteCount(p.getAdjustedBandwidth())*congestion.ByteCount(now.Sub(p.lastSentTime).Nanoseconds()))/1e9 - return min(p.maxBurstSize(), budget) + return Min(p.maxBurstSize(), budget) } func (p *pacer) maxBurstSize() congestion.ByteCount { - return max( + return Max( congestion.ByteCount(uint64((MinPacingDelay+TimerGranularity).Nanoseconds())*p.getAdjustedBandwidth())/1e9, maxBurstSizePackets*p.maxDatagramSize, ) @@ -68,7 +68,7 @@ func (p *pacer) TimeUntilSend() time.Time { if p.budgetAtLastSent >= p.maxDatagramSize { return time.Time{} } - return p.lastSentTime.Add(max( + return p.lastSentTime.Add(Max( MinPacingDelay, time.Duration(math.Ceil(float64(p.maxDatagramSize-p.budgetAtLastSent)*1e9/float64(p.getAdjustedBandwidth())))*time.Nanosecond, ))