Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewCubicSender

func NewCubicSender(clock Clock, rttStats *utils.RTTStats, reno bool, tracer logging.ConnectionTracer) *cubicSender

    NewCubicSender makes a new cubic sender

    Types

    type Bandwidth

    type Bandwidth uint64

      Bandwidth of a connection

      const (
      	// BitsPerSecond is 1 bit per second
      	BitsPerSecond Bandwidth = 1
      	// BytesPerSecond is 1 byte per second
      	BytesPerSecond = 8 * BitsPerSecond
      )

      func BandwidthFromDelta

      func BandwidthFromDelta(bytes protocol.ByteCount, delta time.Duration) Bandwidth

        BandwidthFromDelta calculates the bandwidth from a number of bytes and a time delta

        type Clock

        type Clock interface {
        	Now() time.Time
        }

          A Clock returns the current time

          type Cubic

          type Cubic struct {
          	// contains filtered or unexported fields
          }

            Cubic implements the cubic algorithm from TCP

            func NewCubic

            func NewCubic(clock Clock) *Cubic

              NewCubic returns a new Cubic instance

              func (*Cubic) CongestionWindowAfterAck

              func (c *Cubic) CongestionWindowAfterAck(
              	ackedBytes protocol.ByteCount,
              	currentCongestionWindow protocol.ByteCount,
              	delayMin time.Duration,
              	eventTime time.Time,
              ) protocol.ByteCount

                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 (*Cubic) CongestionWindowAfterPacketLoss

                func (c *Cubic) CongestionWindowAfterPacketLoss(currentCongestionWindow protocol.ByteCount) protocol.ByteCount

                  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 (*Cubic) OnApplicationLimited

                  func (c *Cubic) OnApplicationLimited()

                    OnApplicationLimited is called on ack arrival when sender is unable to use the available congestion window. Resets Cubic state during quiescence.

                    func (*Cubic) Reset

                    func (c *Cubic) Reset()

                      Reset is called after a timeout to reset the cubic state

                      func (*Cubic) SetNumConnections

                      func (c *Cubic) SetNumConnections(n int)

                        SetNumConnections sets the number of emulated connections

                        type DefaultClock

                        type DefaultClock struct{}

                          DefaultClock implements the Clock interface using the Go stdlib clock.

                          func (DefaultClock) Now

                          func (DefaultClock) Now() time.Time

                            Now gets the current time

                            type HybridSlowStart

                            type HybridSlowStart struct {
                            	// contains filtered or unexported fields
                            }

                              HybridSlowStart implements the TCP hybrid slow start algorithm

                              func (*HybridSlowStart) IsEndOfRound

                              func (s *HybridSlowStart) IsEndOfRound(ack protocol.PacketNumber) bool

                                IsEndOfRound returns true if this ack is the last packet number of our current slow start round.

                                func (*HybridSlowStart) OnPacketAcked

                                func (s *HybridSlowStart) OnPacketAcked(ackedPacketNumber protocol.PacketNumber)

                                  OnPacketAcked gets invoked after ShouldExitSlowStart, so it's best to end the round when the final packet of the burst is received and start it on the next incoming ack.

                                  func (*HybridSlowStart) OnPacketSent

                                  func (s *HybridSlowStart) OnPacketSent(packetNumber protocol.PacketNumber)

                                    OnPacketSent is called when a packet was sent

                                    func (*HybridSlowStart) Restart

                                    func (s *HybridSlowStart) Restart()

                                      Restart the slow start phase

                                      func (*HybridSlowStart) ShouldExitSlowStart

                                      func (s *HybridSlowStart) ShouldExitSlowStart(latestRTT time.Duration, minRTT time.Duration, congestionWindow protocol.ByteCount) bool

                                        ShouldExitSlowStart should be called on every new ack frame, since a new RTT measurement can be made then. rtt: the RTT for this ack packet. minRTT: is the lowest delay (RTT) we have seen during the session. congestionWindow: the congestion window in packets.

                                        func (*HybridSlowStart) StartReceiveRound

                                        func (s *HybridSlowStart) StartReceiveRound(lastSent protocol.PacketNumber)

                                          StartReceiveRound is called for the start of each receive round (burst) in the slow start phase.

                                          func (*HybridSlowStart) Started

                                          func (s *HybridSlowStart) Started() bool

                                            Started returns true if started

                                            type SendAlgorithm

                                            type SendAlgorithm interface {
                                            	TimeUntilSend(bytesInFlight protocol.ByteCount) time.Time
                                            	HasPacingBudget() bool
                                            	OnPacketSent(sentTime time.Time, bytesInFlight protocol.ByteCount, packetNumber protocol.PacketNumber, bytes protocol.ByteCount, isRetransmittable bool)
                                            	CanSend(bytesInFlight protocol.ByteCount) bool
                                            	MaybeExitSlowStart()
                                            	OnPacketAcked(number protocol.PacketNumber, ackedBytes protocol.ByteCount, priorInFlight protocol.ByteCount, eventTime time.Time)
                                            	OnPacketLost(number protocol.PacketNumber, lostBytes protocol.ByteCount, priorInFlight protocol.ByteCount)
                                            	OnRetransmissionTimeout(packetsRetransmitted bool)
                                            }

                                              A SendAlgorithm performs congestion control

                                              type SendAlgorithmWithDebugInfos

                                              type SendAlgorithmWithDebugInfos interface {
                                              	SendAlgorithm
                                              	InSlowStart() bool
                                              	InRecovery() bool
                                              	GetCongestionWindow() protocol.ByteCount
                                              }

                                                A SendAlgorithmWithDebugInfos is a SendAlgorithm that exposes some debug infos