gbn: make resend timeout dynamic

Prior to this commit, the timeout before a client resends the queue
of packets was always a fixed value. This fixed timeout isn't
suitable for all clients as the latency for different clients varies.

With this commit, we instead set the resend timeout based on how long
it took for the other party to respond during the handshake process.
The timeout is set to the time it took for the server to respond
multiplied by the resendMultiplier, unless the duration is shorter than
the default resend timeout. If the the resend timeout has been manually
set, the resend timeout will always be set to that value, and won't be
dynamically set.

Author: ViktorT-11

gbn/gbn_client.go

@@ -95,6 +95,7 @@ func (g *GoBackNConn) clientHandshake() error {
 	}()
 
 	var resp Message
+	var sentSYNTime time.Time
 handshake:
 	for {
 		// start Handshake
@@ -110,6 +111,10 @@ handshake:
 			return err
 		}
 
+		// Mark the time the client finished sending the SYN, and
+		// started awaiting the server's response.
+		sentSYNTime = time.Now()
+
 		for {
 			// Wait for SYN
 			log.Debugf("Client waiting for SYN")
@@ -159,6 +164,11 @@ handshake:
 		return io.EOF
 	}
 
+	// Increased the resend timeout to the time it took to receive the SYN
+	// from the server multiplied by the resend multiplier.
+	g.increaseResendTimeout(
+		time.Since(sentSYNTime) * time.Duration(g.resendMultiplier))
+
 	// Send SYNACK
 	log.Debugf("Client sending SYNACK")
 	synack, err := new(PacketSYNACK).Serialize()

gbn/gbn_conn.go

@@ -23,6 +23,7 @@ const (
 	defaultHandshakeTimeout = 100 * time.Millisecond
 	defaultResendTimeout    = 100 * time.Millisecond
 	finSendTimeout          = 1000 * time.Millisecond
+	defaultResendMultiplier = 5
 	DefaultSendTimeout      = math.MaxInt64
 	DefaultRecvTimeout      = math.MaxInt64
 )
@@ -60,10 +61,21 @@ type GoBackNConn struct {
 	recvSeq uint8
 
 	// resendTimeout is the duration that will be waited before resending
-	// the packets in the current queue.
+	// the packets in the current queue. The timeout is dynamically set
+	// during the handshake process, and is set to the time it took for the
+	// other party to respond, multiplied by the resendMultiplier.
 	resendTimeout time.Duration
 	resendTicker  *time.Ticker
 
+	// resendMultiplier defines the multiplier used when multiplying the
+	// duration it took for the other party to respond when setting the
+	// resendTimeout dynamically during the handshake.
+	resendMultiplier int
+
+	// hasSetResendTimeout is used to determine if a resend timeout
+	// has been manually set when creating a new GoBackNConn.
+	hasSetResendTimeout bool
+
 	recvFromStream recvBytesFunc
 	sendToStream   sendBytesFunc
 
@@ -164,26 +176,28 @@ func newGoBackNConn(ctx context.Context, sendFunc sendBytesFunc,
 	ctxc, cancel := context.WithCancel(ctx)
 
 	return &GoBackNConn{
-		n:                 n,
-		s:                 n + 1,
-		resendTimeout:     defaultResendTimeout,
-		recvFromStream:    recvFunc,
-		sendToStream:      sendFunc,
-		recvDataChan:      make(chan *PacketData, n),
-		sendDataChan:      make(chan *PacketData),
-		isServer:          isServer,
-		sendQueue:         newQueue(n+1, defaultHandshakeTimeout),
-		handshakeTimeout:  defaultHandshakeTimeout,
-		recvTimeout:       DefaultRecvTimeout,
-		sendTimeout:       DefaultSendTimeout,
-		receivedACKSignal: make(chan struct{}),
-		resendSignal:      make(chan struct{}, 1),
-		remoteClosed:      make(chan struct{}),
-		awaitedACKSignal:  make(chan struct{}, 1),
-		awaitedNACKSignal: make(chan struct{}, 1),
-		ctx:               ctxc,
-		cancel:            cancel,
-		quit:              make(chan struct{}),
+		n:                   n,
+		s:                   n + 1,
+		resendTimeout:       defaultResendTimeout,
+		resendMultiplier:    defaultResendMultiplier,
+		hasSetResendTimeout: false,
+		recvFromStream:      recvFunc,
+		sendToStream:        sendFunc,
+		recvDataChan:        make(chan *PacketData, n),
+		sendDataChan:        make(chan *PacketData),
+		isServer:            isServer,
+		sendQueue:           newQueue(n+1, defaultHandshakeTimeout),
+		handshakeTimeout:    defaultHandshakeTimeout,
+		recvTimeout:         DefaultRecvTimeout,
+		sendTimeout:         DefaultSendTimeout,
+		receivedACKSignal:   make(chan struct{}),
+		resendSignal:        make(chan struct{}, 1),
+		remoteClosed:        make(chan struct{}),
+		awaitedACKSignal:    make(chan struct{}, 1),
+		awaitedNACKSignal:   make(chan struct{}, 1),
+		ctx:                 ctxc,
+		cancel:              cancel,
+		quit:                make(chan struct{}),
 	}
 }
 
@@ -920,3 +934,24 @@ func (g *GoBackNConn) proceedAfterTime(catchUpId int64) {
 	// in the queue would lead to a NACK.
 	time.AfterFunc(g.resendTimeout, cb)
 }
+
+// increaseResendTimeout sets the resendTimeout to the passed duration, if the
+// passed duration is > than the current set resendTimeout.
+// If the resendTimeout has been set manually, this function will be a no op.
+func (g *GoBackNConn) increaseResendTimeout(resendTimeout time.Duration) {
+	if g.hasSetResendTimeout {
+		log.Tracef("Not increasing resendTimeout as it has been set " +
+			"manually")
+
+		return
+	}
+
+	if resendTimeout > g.resendTimeout {
+		log.Tracef("Increasing resendTimeout to %v", resendTimeout)
+		g.resendTimeout = resendTimeout
+	} else {
+		log.Tracef("Not increasing resendTimeout to %v as it is not "+
+			"greater than the current resendTimeout %v",
+			resendTimeout, g.resendTimeout)
+	}
+}

gbn/gbn_server.go

@@ -79,6 +79,7 @@ func (g *GoBackNConn) serverHandshake() error { // nolint:gocyclo
 	}()
 
 	var n uint8
+	var sentSYNTime time.Time
 
 	for {
 		log.Debugf("Waiting for client SYN")
@@ -128,6 +129,10 @@ func (g *GoBackNConn) serverHandshake() error { // nolint:gocyclo
 			return err
 		}
 
+		// Mark the time the server finished sending the SYN, and
+		// started awaiting the client's response.
+		sentSYNTime = time.Now()
+
 		// Wait for SYNACK
 		log.Debugf("Waiting for client SYNACK")
 		select {
@@ -172,6 +177,11 @@ func (g *GoBackNConn) serverHandshake() error { // nolint:gocyclo
 
 	log.Debugf("Received SYNACK")
 
+	// Increased the resend timeout to the time it took to receive the
+	// SYNACK from the client multiplied by the resend multiplier.
+	g.increaseResendTimeout(
+		time.Since(sentSYNTime) * time.Duration(g.resendMultiplier))
+
 	// Set all variables that are dependent on the value of N that we get
 	// from the client
 	g.setN(n)

gbn/options.go

@@ -19,6 +19,18 @@ func WithMaxSendSize(size int) Option {
 func WithTimeout(timeout time.Duration) Option {
 	return func(conn *GoBackNConn) {
 		conn.resendTimeout = timeout
+		conn.hasSetResendTimeout = true
+	}
+}
+
+// WithResendMultiplier is used to set the resend multiplier. This is the
+// multiplier we use when dynamically setting the resend timeout, based on how
+// long it took for other party to respond during the handshake.
+// Note that when setting the resend timeout manually with the WithTimeout
+// option, this option will have no effect.
+func WithResendMultiplier(multiplier int) Option {
+	return func(conn *GoBackNConn) {
+		conn.resendMultiplier = multiplier
 	}
 }
 

mailbox/client_conn.go

@@ -56,6 +56,11 @@ const (
 	// set up the clients send stream cipher box.
 	gbnHandshakeTimeout = 2000 * time.Millisecond
 
+	// gbnResendMultiplier is the multiplier that gbn connection will use
+	// when dynamically setting the resend timeout, based on how long it
+	// took for other party to respond during the handshake.
+	gbnResendMultiplier = 5
+
 	// gbnClientPingTimeout is the time after with the client will send the
 	// server a ping message if it has not received any packets from the
 	// server. The client will close the connection if it then does not
@@ -156,7 +161,7 @@ func NewClientConn(ctx context.Context, sid [64]byte, serverHost string,
 	c := &ClientConn{
 		transport: transport,
 		gbnOptions: []gbn.Option{
-			gbn.WithTimeout(gbnTimeout),
+			gbn.WithResendMultiplier(gbnResendMultiplier),
 			gbn.WithHandshakeTimeout(gbnHandshakeTimeout),
 			gbn.WithKeepalivePing(
 				gbnClientPingTimeout, gbnPongTimeout,

mailbox/server_conn.go

@@ -77,7 +77,7 @@ func NewServerConn(ctx context.Context, serverHost string,
 		cancel: cancel,
 		quit:   make(chan struct{}),
 		gbnOptions: []gbn.Option{
-			gbn.WithTimeout(gbnTimeout),
+			gbn.WithResendMultiplier(gbnResendMultiplier),
 			gbn.WithHandshakeTimeout(gbnHandshakeTimeout),
 			gbn.WithKeepalivePing(
 				gbnServerPingTimeout, gbnPongTimeout,