utils: switch to builtin min and max funtions

These functions were added in Go 1.21.
quic-go · marten-seemann · Dec 28, 2023 · Dec 28, 2023 · Dec 28, 2023 · 576eb9941890e2f93ca7866b4cff884ddb93fc45
commit 576eb9941890e2f93ca7866b4cff884ddb93fc45
diff --git a/conn_id_generator.go b/conn_id_generator.go
@@ -5,7 +5,6 @@ import (
 
  "github.com/quic-go/quic-go/internal/protocol"
  "github.com/quic-go/quic-go/internal/qerr"
- "github.com/quic-go/quic-go/internal/utils"
  "github.com/quic-go/quic-go/internal/wire"
 )
 
@@ -60,7 +59,7 @@ func (m *connIDGenerator) SetMaxActiveConnIDs(limit uint64) error {
  // transport parameter.
  // We currently don't send the preferred_address transport parameter,
  // so we can issue (limit - 1) connection IDs.
- for i := uint64(len(m.activeSrcConnIDs)); i < utils.Min(limit, protocol.MaxIssuedConnectionIDs); i++ {
+ for i := uint64(len(m.activeSrcConnIDs)); i < min(limit, protocol.MaxIssuedConnectionIDs); i++ {
  if err := m.issueNewConnID(); err != nil {
  return err
  }

diff --git a/conn_id_manager.go b/conn_id_manager.go
@@ -145,7 +145,7 @@ func (h *connIDManager) updateConnectionID() {
  h.queueControlFrame(&wire.RetireConnectionIDFrame{
  SequenceNumber: h.activeSequenceNumber,
  })
- h.highestRetired = utils.Max(h.highestRetired, h.activeSequenceNumber)
+ h.highestRetired = max(h.highestRetired, h.activeSequenceNumber)
  if h.activeStatelessResetToken != nil {
  h.removeStatelessResetToken(*h.activeStatelessResetToken)
  }

diff --git a/connection.go b/connection.go
@@ -681,7 +681,7 @@ func (s *connection) ConnectionState() ConnectionState {
 
 // Time when the connection should time out
 func (s *connection) nextIdleTimeoutTime() time.Time {
- idleTimeout := utils.Max(s.idleTimeout, s.rttStats.PTO(true)*3)
+ idleTimeout := max(s.idleTimeout, s.rttStats.PTO(true)*3)
  return s.idleTimeoutStartTime().Add(idleTimeout)
 }
 
@@ -691,7 +691,7 @@ func (s *connection) nextKeepAliveTime() time.Time {
  if s.config.KeepAlivePeriod == 0 || s.keepAlivePingSent || !s.firstAckElicitingPacketAfterIdleSentTime.IsZero() {
  return time.Time{}
  }
- keepAliveInterval := utils.Max(s.keepAliveInterval, s.rttStats.PTO(true)*3/2)
+ keepAliveInterval := max(s.keepAliveInterval, s.rttStats.PTO(true)*3/2)
  return s.lastPacketReceivedTime.Add(keepAliveInterval)
 }
 
@@ -780,7 +780,7 @@ func (s *connection) handleHandshakeConfirmed() error {
  if maxPacketSize == 0 {
  maxPacketSize = protocol.MaxByteCount
  }
- s.mtuDiscoverer.Start(utils.Min(maxPacketSize, protocol.MaxPacketBufferSize))
+ s.mtuDiscoverer.Start(min(maxPacketSize, protocol.MaxPacketBufferSize))
  }
  return nil
 }
@@ -1755,7 +1755,7 @@ func (s *connection) applyTransportParameters() {
  params := s.peerParams
  // Our local idle timeout will always be > 0.
  s.idleTimeout = utils.MinNonZeroDuration(s.config.MaxIdleTimeout, params.MaxIdleTimeout)
- s.keepAliveInterval = utils.Min(s.config.KeepAlivePeriod, utils.Min(s.idleTimeout/2, protocol.MaxKeepAliveInterval))
+ s.keepAliveInterval = min(s.config.KeepAlivePeriod, min(s.idleTimeout/2, protocol.MaxKeepAliveInterval))
  s.streamsMap.UpdateLimits(params)
  s.frameParser.SetAckDelayExponent(params.AckDelayExponent)
  s.connFlowController.UpdateSendWindow(params.InitialMaxData)

diff --git a/crypto_stream.go b/crypto_stream.go
@@ -6,7 +6,6 @@ import (
 
  "github.com/quic-go/quic-go/internal/protocol"
  "github.com/quic-go/quic-go/internal/qerr"
- "github.com/quic-go/quic-go/internal/utils"
  "github.com/quic-go/quic-go/internal/wire"
 )
 
@@ -56,7 +55,7 @@ func (s *cryptoStreamImpl) HandleCryptoFrame(f *wire.CryptoFrame) error {
  // could e.g. be a retransmission
  return nil
  }
- s.highestOffset = utils.Max(s.highestOffset, highestOffset)
+ s.highestOffset = max(s.highestOffset, highestOffset)
  if err := s.queue.Push(f.Data, f.Offset, nil); err != nil {
  return err
  }
@@ -99,7 +98,7 @@ func (s *cryptoStreamImpl) HasData() bool {
 
 func (s *cryptoStreamImpl) PopCryptoFrame(maxLen protocol.ByteCount) *wire.CryptoFrame {
  f := &wire.CryptoFrame{Offset: s.writeOffset}
- n := utils.Min(f.MaxDataLen(maxLen), protocol.ByteCount(len(s.writeBuf)))
+ n := min(f.MaxDataLen(maxLen), protocol.ByteCount(len(s.writeBuf)))
  f.Data = s.writeBuf[:n]
  s.writeBuf = s.writeBuf[n:]
  s.writeOffset += n

diff --git a/http3/http_stream.go b/http3/http_stream.go
@@ -5,7 +5,6 @@ import (
  "fmt"
 
  "github.com/quic-go/quic-go"
- "github.com/quic-go/quic-go/internal/utils"
 )
 
 // A Stream is a HTTP/3 stream.
@@ -115,7 +114,7 @@ func (s *lengthLimitedStream) Read(b []byte) (int, error) {
  if err := s.checkContentLengthViolation(); err != nil {
  return 0, err
  }
- n, err := s.stream.Read(b[:utils.Min(int64(len(b)), s.contentLength-s.read)])
+ n, err := s.stream.Read(b[:min(int64(len(b)), s.contentLength-s.read)])
  s.read += int64(n)
  if err := s.checkContentLengthViolation(); err != nil {
  return n, err

diff --git a/internal/ackhandler/packet_number_generator.go b/internal/ackhandler/packet_number_generator.go
@@ -80,5 +80,5 @@ func (p *skippingPacketNumberGenerator) Pop() (bool, protocol.PacketNumber) {
 func (p *skippingPacketNumberGenerator) generateNewSkip() {
  // make sure that there are never two consecutive packet numbers that are skipped
  p.nextToSkip = p.next + 3 + protocol.PacketNumber(p.rng.Int31n(int32(2*p.period)))
- p.period = utils.Min(2*p.period, p.maxPeriod)
+ p.period = min(2*p.period, p.maxPeriod)
 }
diff --git a/internal/ackhandler/received_packet_tracker.go b/internal/ackhandler/received_packet_tracker.go
@@ -179,7 +179,7 @@ func (h *receivedPacketTracker) GetAckFrame(onlyIfQueued bool) *wire.AckFrame {
  ack = &wire.AckFrame{}
  }
  ack.Reset()
- ack.DelayTime = utils.Max(0, now.Sub(h.largestObservedRcvdTime))
+ ack.DelayTime = max(0, now.Sub(h.largestObservedRcvdTime))
  ack.ECT0 = h.ect0
  ack.ECT1 = h.ect1
  ack.ECNCE = h.ecnce

diff --git a/internal/ackhandler/sent_packet_handler.go b/internal/ackhandler/sent_packet_handler.go
@@ -245,7 +245,7 @@ func (h *sentPacketHandler) SentPacket(
 
  pnSpace := h.getPacketNumberSpace(encLevel)
  if h.logger.Debug() && pnSpace.history.HasOutstandingPackets() {
- for p := utils.Max(0, pnSpace.largestSent+1); p < pn; p++ {
+ for p := max(0, pnSpace.largestSent+1); p < pn; p++ {
  h.logger.Debugf("Skipping packet number %d", p)
  }
  }
@@ -336,7 +336,7 @@ func (h *sentPacketHandler) ReceivedAck(ack *wire.AckFrame, encLevel protocol.En
  // don't use the ack delay for Initial and Handshake packets
  var ackDelay time.Duration
  if encLevel == protocol.Encryption1RTT {
- ackDelay = utils.Min(ack.DelayTime, h.rttStats.MaxAckDelay())
+ ackDelay = min(ack.DelayTime, h.rttStats.MaxAckDelay())
  }
  h.rttStats.UpdateRTT(rcvTime.Sub(p.SendTime), ackDelay, rcvTime)
  if h.logger.Debug() {
@@ -354,7 +354,7 @@ func (h *sentPacketHandler) ReceivedAck(ack *wire.AckFrame, encLevel protocol.En
  }
  }
 
- pnSpace.largestAcked = utils.Max(pnSpace.largestAcked, largestAcked)
+ pnSpace.largestAcked = max(pnSpace.largestAcked, largestAcked)
 
  if err := h.detectLostPackets(rcvTime, encLevel); err != nil {
  return false, err
@@ -446,7 +446,7 @@ func (h *sentPacketHandler) detectAndRemoveAckedPackets(ack *wire.AckFrame, encL
 
  for _, p := range h.ackedPackets {
  if p.LargestAcked != protocol.InvalidPacketNumber && encLevel == protocol.Encryption1RTT {
- h.lowestNotConfirmedAcked = utils.Max(h.lowestNotConfirmedAcked, p.LargestAcked+1)
+ h.lowestNotConfirmedAcked = max(h.lowestNotConfirmedAcked, p.LargestAcked+1)
  }
 
  for _, f := range p.Frames {
@@ -607,11 +607,11 @@ func (h *sentPacketHandler) detectLostPackets(now time.Time, encLevel protocol.E
  pnSpace := h.getPacketNumberSpace(encLevel)
  pnSpace.lossTime = time.Time{}
 
- maxRTT := float64(utils.Max(h.rttStats.LatestRTT(), h.rttStats.SmoothedRTT()))
+ maxRTT := float64(max(h.rttStats.LatestRTT(), h.rttStats.SmoothedRTT()))
  lossDelay := time.Duration(timeThreshold * maxRTT)
 
  // Minimum time of granularity before packets are deemed lost.
- lossDelay = utils.Max(lossDelay, protocol.TimerGranularity)
+ lossDelay = max(lossDelay, protocol.TimerGranularity)
 
  // Packets sent before this time are deemed lost.
  lostSendTime := now.Add(-lossDelay)
@@ -890,7 +890,7 @@ func (h *sentPacketHandler) ResetForRetry(now time.Time) error {
  // Otherwise, we don't know which Initial the Retry was sent in response to.
  if h.ptoCount == 0 {
  // Don't set the RTT to a value lower than 5ms here.
- h.rttStats.UpdateRTT(utils.Max(minRTTAfterRetry, now.Sub(firstPacketSendTime)), 0, now)
+ h.rttStats.UpdateRTT(max(minRTTAfterRetry, now.Sub(firstPacketSendTime)), 0, now)
  if h.logger.Debug() {
  h.logger.Debugf("\tupdated RTT: %s (σ: %s)", h.rttStats.SmoothedRTT(), h.rttStats.MeanDeviation())
  }

diff --git a/internal/congestion/cubic.go b/internal/congestion/cubic.go
@@ -5,7 +5,6 @@ import (
  "time"
 
  "github.com/quic-go/quic-go/internal/protocol"
- "github.com/quic-go/quic-go/internal/utils"
 )
 
 // This cubic implementation is based on the one found in Chromiums's QUIC
@@ -187,7 +186,7 @@ func (c *Cubic) CongestionWindowAfterAck(
  targetCongestionWindow = c.originPointCongestionWindow - deltaCongestionWindow
  }
  // Limit the CWND increase to half the acked bytes.
- targetCongestionWindow = utils.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/internal/congestion/cubic_sender.go b/internal/congestion/cubic_sender.go
@@ -178,7 +178,7 @@ func (c *cubicSender) OnPacketAcked(
  priorInFlight protocol.ByteCount,
  eventTime time.Time,
 ) {
- c.largestAckedPacketNumber = utils.Max(ackedPacketNumber, c.largestAckedPacketNumber)
+ c.largestAckedPacketNumber = max(ackedPacketNumber, c.largestAckedPacketNumber)
  if c.InRecovery() {
  return
  }
@@ -246,7 +246,7 @@ func (c *cubicSender) maybeIncreaseCwnd(
  c.numAckedPackets = 0
  }
  } else {
- c.congestionWindow = utils.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/internal/congestion/hybrid_slow_start.go b/internal/congestion/hybrid_slow_start.go
@@ -4,7 +4,6 @@ import (
  "time"
 
  "github.com/quic-go/quic-go/internal/protocol"
- "github.com/quic-go/quic-go/internal/utils"
 )
 
 // Note(pwestin): the magic clamping numbers come from the original code in
@@ -75,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 = utils.Min(minRTTincreaseThresholdUs, hybridStartDelayMaxThresholdUs)
- minRTTincreaseThreshold := time.Duration(utils.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/internal/congestion/pacer.go b/internal/congestion/pacer.go
@@ -4,7 +4,6 @@ import (
  "time"
 
  "github.com/quic-go/quic-go/internal/protocol"
- "github.com/quic-go/quic-go/internal/utils"
 )
 
 const maxBurstSizePackets = 10
@@ -52,11 +51,11 @@ func (p *pacer) Budget(now time.Time) protocol.ByteCount {
  if budget < 0 { // protect against overflows
  budget = protocol.MaxByteCount
  }
- return utils.Min(p.maxBurstSize(), budget)
+ return min(p.maxBurstSize(), budget)
 }
 
 func (p *pacer) maxBurstSize() protocol.ByteCount {
- return utils.Max(
+ return max(
  protocol.ByteCount(uint64((protocol.MinPacingDelay+protocol.TimerGranularity).Nanoseconds())*p.adjustedBandwidth())/1e9,
  maxBurstSizePackets*p.maxDatagramSize,
  )
@@ -77,7 +76,7 @@ func (p *pacer) TimeUntilSend() time.Time {
  if diff%bw > 0 {
  d++
  }
- return p.lastSentTime.Add(utils.Max(protocol.MinPacingDelay, time.Duration(d)*time.Nanosecond))
+ return p.lastSentTime.Add(max(protocol.MinPacingDelay, time.Duration(d)*time.Nanosecond))
 }
 
 func (p *pacer) SetMaxDatagramSize(s protocol.ByteCount) {

diff --git a/internal/flowcontrol/base_flow_controller.go b/internal/flowcontrol/base_flow_controller.go
@@ -107,7 +107,7 @@ func (c *baseFlowController) maybeAdjustWindowSize() {
  now := time.Now()
  if now.Sub(c.epochStartTime) < time.Duration(4*fraction*float64(rtt)) {
  // window is consumed too fast, try to increase the window size
- newSize := utils.Min(2*c.receiveWindowSize, c.maxReceiveWindowSize)
+ newSize := min(2*c.receiveWindowSize, c.maxReceiveWindowSize)
  if newSize > c.receiveWindowSize && (c.allowWindowIncrease == nil || c.allowWindowIncrease(newSize-c.receiveWindowSize)) {
  c.receiveWindowSize = newSize
  }

diff --git a/internal/flowcontrol/connection_flow_controller.go b/internal/flowcontrol/connection_flow_controller.go
@@ -87,7 +87,7 @@ func (c *connectionFlowController) EnsureMinimumWindowSize(inc protocol.ByteCoun
  c.mutex.Lock()
  if inc > c.receiveWindowSize {
  c.logger.Debugf("Increasing receive flow control window for the connection to %d kB, in response to stream flow control window increase", c.receiveWindowSize/(1<<10))
- newSize := utils.Min(inc, c.maxReceiveWindowSize)
+ newSize := min(inc, c.maxReceiveWindowSize)
  if delta := newSize - c.receiveWindowSize; delta > 0 && c.allowWindowIncrease(delta) {
  c.receiveWindowSize = newSize
  }

diff --git a/internal/flowcontrol/stream_flow_controller.go b/internal/flowcontrol/stream_flow_controller.go
@@ -123,7 +123,7 @@ func (c *streamFlowController) AddBytesSent(n protocol.ByteCount) {
 }
 
 func (c *streamFlowController) SendWindowSize() protocol.ByteCount {
- return utils.Min(c.baseFlowController.sendWindowSize(), c.connection.SendWindowSize())
+ return min(c.baseFlowController.sendWindowSize(), c.connection.SendWindowSize())
 }
 
 func (c *streamFlowController) shouldQueueWindowUpdate() bool {

diff --git a/internal/handshake/aead.go b/internal/handshake/aead.go
@@ -5,7 +5,6 @@ import (
  "encoding/binary"
 
  "github.com/quic-go/quic-go/internal/protocol"
- "github.com/quic-go/quic-go/internal/utils"
 )
 
 func createAEAD(suite *cipherSuite, trafficSecret []byte, v protocol.VersionNumber) cipher.AEAD {
@@ -82,7 +81,7 @@ func (o *longHeaderOpener) Open(dst, src []byte, pn protocol.PacketNumber, ad []
  // It uses the nonce provided here and XOR it with the IV.
  dec, err := o.aead.Open(dst, o.nonceBuf, src, ad)
  if err == nil {
- o.highestRcvdPN = utils.Max(o.highestRcvdPN, pn)
+ o.highestRcvdPN = max(o.highestRcvdPN, pn)
  } else {
  err = ErrDecryptionFailed
  }

diff --git a/internal/handshake/updatable_aead.go b/internal/handshake/updatable_aead.go
@@ -172,7 +172,7 @@ func (a *updatableAEAD) Open(dst, src []byte, rcvTime time.Time, pn protocol.Pac
  }
  }
  if err == nil {
- a.highestRcvdPN = utils.Max(a.highestRcvdPN, pn)
+ a.highestRcvdPN = max(a.highestRcvdPN, pn)
  }
  return dec, err
 }

diff --git a/internal/utils/minmax.go b/internal/utils/minmax.go
@@ -3,27 +3,11 @@ package utils
 import (
  "math"
  "time"
-
- "golang.org/x/exp/constraints"
 )
 
 // InfDuration is a duration of infinite length
 const InfDuration = time.Duration(math.MaxInt64)
 
-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
-}
-
 // MinNonZeroDuration return the minimum duration that's not zero.
 func MinNonZeroDuration(a, b time.Duration) time.Duration {
  if a == 0 {
@@ -32,7 +16,7 @@ func MinNonZeroDuration(a, b time.Duration) time.Duration {
  if b == 0 {
  return a
  }
- return Min(a, b)
+ return min(a, b)
 }
 
 // MinTime returns the earlier time

diff --git a/internal/utils/minmax_test.go b/internal/utils/minmax_test.go
@@ -8,16 +8,6 @@ import (
 )
 
 var _ = Describe("Min / Max", func() {
- It("returns the maximum", func() {
- Expect(Max(5, 7)).To(Equal(7))
- Expect(Max(5.5, 5.7)).To(Equal(5.7))
- })
-
- It("returns the minimum", func() {
- Expect(Min(5, 7)).To(Equal(5))
- Expect(Min(5.5, 5.7)).To(Equal(5.5))
- })
-
  It("returns the maximum time", func() {
  a := time.Now()
  b := a.Add(time.Second)

diff --git a/internal/utils/rtt_stats.go b/internal/utils/rtt_stats.go
@@ -55,7 +55,7 @@ func (r *RTTStats) PTO(includeMaxAckDelay bool) time.Duration {
  if r.SmoothedRTT() == 0 {
  return 2 * defaultInitialRTT
  }
- pto := r.SmoothedRTT() + Max(4*r.MeanDeviation(), protocol.TimerGranularity)
+ pto := r.SmoothedRTT() + max(4*r.MeanDeviation(), protocol.TimerGranularity)
  if includeMaxAckDelay {
  pto += r.MaxAckDelay()
  }
@@ -126,6 +126,6 @@ func (r *RTTStats) OnConnectionMigration() {
 // is larger. The mean deviation is increased to the most recent deviation if
 // it's larger.
 func (r *RTTStats) ExpireSmoothedMetrics() {
- r.meanDeviation = Max(r.meanDeviation, (r.smoothedRTT - r.latestRTT).Abs())
- r.smoothedRTT = Max(r.smoothedRTT, r.latestRTT)
+ r.meanDeviation = max(r.meanDeviation, (r.smoothedRTT - r.latestRTT).Abs())
+ r.smoothedRTT = max(r.smoothedRTT, r.latestRTT)
 }
diff --git a/internal/wire/transport_parameters.go b/internal/wire/transport_parameters.go
@@ -294,7 +294,7 @@ func (p *TransportParameters) readNumericTransportParameter(
  return fmt.Errorf("initial_max_streams_uni too large: %d (maximum %d)", p.MaxUniStreamNum, protocol.MaxStreamCount)
  }
  case maxIdleTimeoutParameterID:
- p.MaxIdleTimeout = utils.Max(protocol.MinRemoteIdleTimeout, time.Duration(val)*time.Millisecond)
+ p.MaxIdleTimeout = max(protocol.MinRemoteIdleTimeout, time.Duration(val)*time.Millisecond)
  case maxUDPPayloadSizeParameterID:
  if val < 1200 {
  return fmt.Errorf("invalid value for max_packet_size: %d (minimum 1200)", val)