Revert "utils: switch to standard library min and max functions (quic…

…-go#4218)"

This reverts commit 22411e1.

conn_id_generator.go

@@ -5,6 +5,7 @@ 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"
 )
 
@@ -59,7 +60,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 < min(limit, protocol.MaxIssuedConnectionIDs); i++ {
+ for i := uint64(len(m.activeSrcConnIDs)); i < utils.Min(limit, protocol.MaxIssuedConnectionIDs); i++ {
  if err := m.issueNewConnID(); err != nil {
  return err
  }

conn_id_manager.go

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

connection.go

@@ -686,7 +686,7 @@ func (s *connection) ConnectionState() ConnectionState {
 
 // Time when the connection should time out
 func (s *connection) nextIdleTimeoutTime() time.Time {
- idleTimeout := max(s.idleTimeout, s.rttStats.PTO(true)*3)
+ idleTimeout := utils.Max(s.idleTimeout, s.rttStats.PTO(true)*3)
  return s.idleTimeoutStartTime().Add(idleTimeout)
 }
 
@@ -696,7 +696,7 @@ func (s *connection) nextKeepAliveTime() time.Time {
  if s.config.KeepAlivePeriod == 0 || s.keepAlivePingSent || !s.firstAckElicitingPacketAfterIdleSentTime.IsZero() {
  return time.Time{}
  }
- keepAliveInterval := max(s.keepAliveInterval, s.rttStats.PTO(true)*3/2)
+ keepAliveInterval := utils.Max(s.keepAliveInterval, s.rttStats.PTO(true)*3/2)
  return s.lastPacketReceivedTime.Add(keepAliveInterval)
 }
 
@@ -785,7 +785,7 @@ func (s *connection) handleHandshakeConfirmed() error {
  if maxPacketSize == 0 {
  maxPacketSize = protocol.MaxByteCount
  }
- s.mtuDiscoverer.Start(min(maxPacketSize, protocol.MaxPacketBufferSize))
+ s.mtuDiscoverer.Start(utils.Min(maxPacketSize, protocol.MaxPacketBufferSize))
  }
  return nil
 }
@@ -1767,7 +1767,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 = min(s.config.KeepAlivePeriod, min(s.idleTimeout/2, protocol.MaxKeepAliveInterval))
+ s.keepAliveInterval = utils.Min(s.config.KeepAlivePeriod, utils.Min(s.idleTimeout/2, protocol.MaxKeepAliveInterval))
  s.streamsMap.UpdateLimits(params)
  s.frameParser.SetAckDelayExponent(params.AckDelayExponent)
  s.connFlowController.UpdateSendWindow(params.InitialMaxData)

crypto_stream.go

@@ -6,6 +6,7 @@ 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"
 )
 
@@ -55,7 +56,7 @@ func (s *cryptoStreamImpl) HandleCryptoFrame(f *wire.CryptoFrame) error {
  // could e.g. be a retransmission
  return nil
  }
- s.highestOffset = max(s.highestOffset, highestOffset)
+ s.highestOffset = utils.Max(s.highestOffset, highestOffset)
  if err := s.queue.Push(f.Data, f.Offset, nil); err != nil {
  return err
  }
@@ -98,7 +99,7 @@ func (s *cryptoStreamImpl) HasData() bool {
 
 func (s *cryptoStreamImpl) PopCryptoFrame(maxLen protocol.ByteCount) *wire.CryptoFrame {
  f := &wire.CryptoFrame{Offset: s.writeOffset}
- n := min(f.MaxDataLen(maxLen), protocol.ByteCount(len(s.writeBuf)))
+ n := utils.Min(f.MaxDataLen(maxLen), protocol.ByteCount(len(s.writeBuf)))
  f.Data = s.writeBuf[:n]
  s.writeBuf = s.writeBuf[n:]
  s.writeOffset += n

http3/http_stream.go

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

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 = min(2*p.period, p.maxPeriod)
+ p.period = utils.Min(2*p.period, p.maxPeriod)
 }

internal/ackhandler/received_packet_tracker.go

@@ -210,7 +210,7 @@ func (h *appDataReceivedPacketTracker) GetAckFrame(onlyIfQueued bool) *wire.AckF
  if ack == nil {
  return nil
  }
- ack.DelayTime = max(0, now.Sub(h.largestObservedRcvdTime))
+ ack.DelayTime = utils.Max(0, now.Sub(h.largestObservedRcvdTime))
  h.ackQueued = false
  h.ackAlarm = time.Time{}
  h.ackElicitingPacketsReceivedSinceLastAck = 0

internal/ackhandler/sent_packet_handler.go

@@ -250,7 +250,7 @@ func (h *sentPacketHandler) SentPacket(
 
  pnSpace := h.getPacketNumberSpace(encLevel)
  if h.logger.Debug() && pnSpace.history.HasOutstandingPackets() {
- for p := max(0, pnSpace.largestSent+1); p < pn; p++ {
+ for p := utils.Max(0, pnSpace.largestSent+1); p < pn; p++ {
  h.logger.Debugf("Skipping packet number %d", p)
  }
  }
@@ -346,7 +346,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 = min(ack.DelayTime, h.rttStats.MaxAckDelay())
+ ackDelay = utils.Min(ack.DelayTime, h.rttStats.MaxAckDelay())
  }
  h.rttStats.UpdateRTT(rcvTime.Sub(p.SendTime), ackDelay, rcvTime)
  if h.logger.Debug() {
@@ -364,7 +364,7 @@ func (h *sentPacketHandler) ReceivedAck(ack *wire.AckFrame, encLevel protocol.En
  }
  }
 
- pnSpace.largestAcked = max(pnSpace.largestAcked, largestAcked)
+ pnSpace.largestAcked = utils.Max(pnSpace.largestAcked, largestAcked)
 
  if err := h.detectLostPackets(rcvTime, encLevel); err != nil {
  return false, err
@@ -469,7 +469,7 @@ func (h *sentPacketHandler) detectAndRemoveAckedPackets(ack *wire.AckFrame, encL
 
  for _, p := range h.ackedPackets {
  if p.LargestAcked != protocol.InvalidPacketNumber && encLevel == protocol.Encryption1RTT {
- h.lowestNotConfirmedAcked = max(h.lowestNotConfirmedAcked, p.LargestAcked+1)
+ h.lowestNotConfirmedAcked = utils.Max(h.lowestNotConfirmedAcked, p.LargestAcked+1)
  }
 
  for _, f := range p.Frames {
@@ -631,11 +631,11 @@ func (h *sentPacketHandler) detectLostPackets(now time.Time, encLevel protocol.E
  pnSpace := h.getPacketNumberSpace(encLevel)
  pnSpace.lossTime = time.Time{}
 
- maxRTT := float64(max(h.rttStats.LatestRTT(), h.rttStats.SmoothedRTT()))
+ maxRTT := float64(utils.Max(h.rttStats.LatestRTT(), h.rttStats.SmoothedRTT()))
  lossDelay := time.Duration(timeThreshold * maxRTT)
 
  // Minimum time of granularity before packets are deemed lost.
- lossDelay = max(lossDelay, protocol.TimerGranularity)
+ lossDelay = utils.Max(lossDelay, protocol.TimerGranularity)
 
  // Packets sent before this time are deemed lost.
  lostSendTime := now.Add(-lossDelay)
@@ -930,7 +930,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(max(minRTTAfterRetry, now.Sub(firstPacketSendTime)), 0, now)
+ h.rttStats.UpdateRTT(utils.Max(minRTTAfterRetry, now.Sub(firstPacketSendTime)), 0, now)
  if h.logger.Debug() {
  h.logger.Debugf("\tupdated RTT: %s (σ: %s)", h.rttStats.SmoothedRTT(), h.rttStats.MeanDeviation())
  }

internal/congestion/cubic.go

@@ -5,6 +5,7 @@ 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
@@ -186,7 +187,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 = utils.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

internal/congestion/cubic_sender.go

@@ -178,7 +178,7 @@ func (c *cubicSender) OnPacketAcked(
  priorInFlight protocol.ByteCount,
  eventTime time.Time,
 ) {
- c.largestAckedPacketNumber = max(ackedPacketNumber, c.largestAckedPacketNumber)
+ c.largestAckedPacketNumber = utils.Max(ackedPacketNumber, c.largestAckedPacketNumber)
  if c.InRecovery() {
  return
  }
@@ -246,7 +246,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 = utils.Min(c.maxCongestionWindow(), c.cubic.CongestionWindowAfterAck(ackedBytes, c.congestionWindow, c.rttStats.MinRTT(), eventTime))
  }
 }
 

internal/congestion/hybrid_slow_start.go

@@ -4,6 +4,7 @@ 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
@@ -74,8 +75,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 = utils.Min(minRTTincreaseThresholdUs, hybridStartDelayMaxThresholdUs)
+ minRTTincreaseThreshold := time.Duration(utils.Max(minRTTincreaseThresholdUs, hybridStartDelayMinThresholdUs)) * time.Microsecond
 
  if s.currentMinRTT > (minRTT + minRTTincreaseThreshold) {
  s.hystartFound = true

internal/congestion/pacer.go

@@ -4,6 +4,7 @@ import (
  "time"
 
  "github.com/quic-go/quic-go/internal/protocol"
+ "github.com/quic-go/quic-go/internal/utils"
 )
 
 const maxBurstSizePackets = 10
@@ -51,11 +52,11 @@ func (p *pacer) Budget(now time.Time) protocol.ByteCount {
  if budget < 0 { // protect against overflows
  budget = protocol.MaxByteCount
  }
- return min(p.maxBurstSize(), budget)
+ return utils.Min(p.maxBurstSize(), budget)
 }
 
 func (p *pacer) maxBurstSize() protocol.ByteCount {
- return max(
+ return utils.Max(
  protocol.ByteCount(uint64((protocol.MinPacingDelay+protocol.TimerGranularity).Nanoseconds())*p.adjustedBandwidth())/1e9,
  maxBurstSizePackets*p.maxDatagramSize,
  )
@@ -76,7 +77,7 @@ func (p *pacer) TimeUntilSend() time.Time {
  if diff%bw > 0 {
  d++
  }
- return p.lastSentTime.Add(max(protocol.MinPacingDelay, time.Duration(d)*time.Nanosecond))
+ return p.lastSentTime.Add(utils.Max(protocol.MinPacingDelay, time.Duration(d)*time.Nanosecond))
 }
 
 func (p *pacer) SetMaxDatagramSize(s protocol.ByteCount) {

internal/flowcontrol/base_flow_controller.go

@@ -109,7 +109,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 := min(2*c.receiveWindowSize, c.maxReceiveWindowSize)
+ newSize := utils.Min(2*c.receiveWindowSize, c.maxReceiveWindowSize)
  if newSize > c.receiveWindowSize && (c.allowWindowIncrease == nil || c.allowWindowIncrease(newSize-c.receiveWindowSize)) {
  c.receiveWindowSize = newSize
  }

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 := min(inc, c.maxReceiveWindowSize)
+ newSize := utils.Min(inc, c.maxReceiveWindowSize)
  if delta := newSize - c.receiveWindowSize; delta > 0 && c.allowWindowIncrease(delta) {
  c.receiveWindowSize = newSize
  }

internal/flowcontrol/stream_flow_controller.go

@@ -123,7 +123,7 @@ func (c *streamFlowController) AddBytesSent(n protocol.ByteCount) {
 }
 
 func (c *streamFlowController) SendWindowSize() protocol.ByteCount {
- return min(c.baseFlowController.sendWindowSize(), c.connection.SendWindowSize())
+ return utils.Min(c.baseFlowController.sendWindowSize(), c.connection.SendWindowSize())
 }
 
 func (c *streamFlowController) shouldQueueWindowUpdate() bool {

internal/handshake/aead.go

@@ -4,6 +4,7 @@ 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.Version) *xorNonceAEAD {
@@ -78,7 +79,7 @@ func (o *longHeaderOpener) Open(dst, src []byte, pn protocol.PacketNumber, ad []
  binary.BigEndian.PutUint64(o.nonceBuf[:], uint64(pn))
  dec, err := o.aead.Open(dst, o.nonceBuf[:], src, ad)
  if err == nil {
- o.highestRcvdPN = max(o.highestRcvdPN, pn)
+ o.highestRcvdPN = utils.Max(o.highestRcvdPN, pn)
  } else {
  err = ErrDecryptionFailed
  }

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 = max(a.highestRcvdPN, pn)
+ a.highestRcvdPN = utils.Max(a.highestRcvdPN, pn)
  }
  return dec, err
 }

internal/utils/minmax.go

@@ -3,11 +3,27 @@ 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 {
@@ -16,7 +32,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

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)
 }

internal/wire/transport_parameters.go

@@ -289,7 +289,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 = max(protocol.MinRemoteIdleTimeout, time.Duration(val)*time.Millisecond)
+ p.MaxIdleTimeout = utils.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)

send_stream.go

@@ -274,7 +274,7 @@ func (s *sendStream) popNewStreamFrame(maxBytes, sendWindow protocol.ByteCount,
  nextFrame := s.nextFrame
  s.nextFrame = nil
 
- maxDataLen := min(sendWindow, nextFrame.MaxDataLen(maxBytes, v))
+ maxDataLen := utils.Min(sendWindow, nextFrame.MaxDataLen(maxBytes, v))
  if nextFrame.DataLen() > maxDataLen {
  s.nextFrame = wire.GetStreamFrame()
  s.nextFrame.StreamID = s.streamID
@@ -309,7 +309,7 @@ func (s *sendStream) popNewStreamFrameWithoutBuffer(f *wire.StreamFrame, maxByte
  if maxDataLen == 0 { // a STREAM frame must have at least one byte of data
  return s.dataForWriting != nil || s.nextFrame != nil || s.finishedWriting
  }
- s.getDataForWriting(f, min(maxDataLen, sendWindow))
+ s.getDataForWriting(f, utils.Min(maxDataLen, sendWindow))
 
  return s.dataForWriting != nil || s.nextFrame != nil || s.finishedWriting
 }