huge fixes to ring buffer implementations and mostly passing tests

tcp/txqueue.go

@@ -104,12 +104,16 @@ func (rtx *ringTx) BufferedSent() int {
 
 // Write writes data to the underlying unsent data ring buffer.
 func (rtx *ringTx) Write(b []byte) (n int, err error) {
-	r, lim := rtx.unsentRing()
-	n, err = r.WriteLimited(b, lim)
+	unsent, lim := rtx.unsentRing()
+	if rtx.sentend == 0 {
+		n, err = unsent.Write(b) // catches case where limit matches with end when both buffers empty
+	} else {
+		n, err = unsent.WriteLimited(b, lim)
+	}
 	if err != nil {
 		return 0, err
 	}
-	rtx.unsentend = r.End
+	rtx.unsentend = unsent.End
 	return n, err
 }
 
@@ -126,7 +130,7 @@ func (rtx *ringTx) MakePacket(b []byte, currentSeq Value) (int, error) {
 	}
 	// Reading unsent ring consumes unsent and converts it to "sent".
 	unsent, _ := rtx.unsentRing()
-	oldSentOff := unsent.Off
+	oldUnsentOff := unsent.Off
 	n, err := unsent.Read(b)
 	if err != nil {
 		return 0, err
@@ -134,13 +138,22 @@ func (rtx *ringTx) MakePacket(b []byte, currentSeq Value) (int, error) {
 	// unsentOff increases, sentEnd matches this value.
 	// Start of buffer will be SENT, end of buffer will be UNSENT(or empty).
 	// Packet generated has offset at old unsentOff.
-	newUnsentOff := unsent.Off
-	pkt := rtx.slist.AddPacket(n, oldSentOff, rtx.Size())
-	if pkt.off != oldSentOff || pkt.end != addEnd(pkt.off, n, rtx.Size()) {
+	size := rtx.Size()
+	pkt := rtx.slist.AddPacket(n, oldUnsentOff, size)
+	if pkt.off != oldUnsentOff || pkt.end != addEnd(pkt.off, n, size) {
 		panic("invalid generated packet")
 	}
-	rtx.unsentoff = newUnsentOff
-	rtx.sentend = newUnsentOff
+	if rtx.sentend == 0 {
+		// Sent was previously empty, offset is reset from start of this packet
+		rtx.sentoff = pkt.off
+	}
+	if unsent.End == 0 {
+		// Fully read unsent buffer so offset is reset, need to recalculate.
+		rtx.unsentoff = pkt.end
+	} else {
+		rtx.unsentoff = unsent.Off
+	}
+	rtx.sentend = pkt.end
 	rtx.unsentend = unsent.End
 	return n, nil
 }
@@ -282,7 +295,7 @@ func (sl *sentlist) AddPacket(datalen, off, bufsize int) *ringidx {
 		panic("pkt buffer full")
 	}
 	lastPkt := sl.Newest()
-	if lastPkt != nil && off != lastPkt.end {
+	if lastPkt != nil && ((off != 0 && off != lastPkt.end) || (off == 0 && lastPkt.end != bufsize)) {
 		panic("new sent packet offset must match last sent packet end")
 	}
 	sl.pkts = append(sl.pkts, ringidx{

tcp/txqueue_test.go

@@ -13,7 +13,8 @@ import (
 func TestRingTx_op(t *testing.T) {
 	const maxBuf = 32
 	const maxpkt = 3
-	const Nops = 3
+	const Nops = 33
+	const log = false
 	type op uint8
 	const (
 		opWrite op = iota
@@ -21,100 +22,100 @@ func TestRingTx_op(t *testing.T) {
 		opAck
 		opmax
 	)
-
-	rng := rand.New(rand.NewSource(666))
-	randop := func() op { return op(rng.Intn(int(opmax))) }
 	var buf, auxbuf [maxBuf]byte
 	dataWritten := make([]byte, 0, maxBuf*10)
 	dataSent := make([]byte, 0, maxBuf*10)
 	var rtx ringTx
-	for itest := 0; itest < 3; itest++ {
-		bufsize := rng.Intn(maxBuf/2) + maxBuf/2
-		iss := Value(0)
-		npackets := rng.Intn(maxpkt-1) + 1
-		err := rtx.Reset(buf[:bufsize], npackets, iss)
-		if err != nil {
-			t.Fatal(err)
-		}
-		// Prepare state for keeping track of test.
-		currentAcked := iss
-		currentSeq := iss
-		nsent := 0
-		nunsent := 0
-		nacked := 0
-		dataWritten = dataWritten[:0]
-		dataSent = dataSent[:0]
-		for iop := 0; iop < Nops; iop++ {
-			free := bufsize - nsent - nunsent
-			availPkt := rtx.slist.Free()
-			op := randop()
-			var oplen int
-			var opname string
-			var opWriteData []byte
-			switch op {
-			case opWrite:
-				opname, oplen = "write", rng.Intn(free+1)+1
-				opWriteData = auxbuf[:oplen]
-				rng.Read(opWriteData)
-				clear(auxbuf[oplen:])
-			case opSend:
-				opname, oplen = "send", rng.Intn(nunsent+1)+1
-			case opAck:
-				opname, oplen = "ack", rng.Intn(nsent+1)+1
+	rng := rand.New(rand.NewSource(0))
+	for iseed := int64(0); iseed < 10000; iseed++ {
+		rng.Seed(iseed)
+		for itest := 0; itest < 32; itest++ {
+			bufsize := rng.Intn(maxBuf/2) + maxBuf/2
+			iss := Value(0)
+			npackets := rng.Intn(maxpkt-1) + 1
+			err := rtx.Reset(buf[:bufsize], npackets, iss)
+			if err != nil {
+				t.Fatal(err)
 			}
-			if itest < 2 {
-				continue // Debugging.
-			}
-			_ = opname
-			t.Logf("\n%s\nitest=%d iop=%d op=%s len=%d", rtx.mustAppendString(nil), itest, iop, opname, oplen)
-			switch op {
-			case opWrite:
-				// oplen=number of
-				nwgot, err := rtx.Write(opWriteData)
-				wantErr := oplen > free
-				if err != nil && oplen <= free {
-					t.Fatal(itest, iop, err)
-				} else if err == nil {
-					if wantErr {
-						panic("wanted write error")
+			// Prepare state for keeping track of test.
+			currentAcked := iss
+			currentSeq := iss
+			nsent := 0
+			nunsent := 0
+			nacked := 0
+			dataWritten = dataWritten[:0]
+			dataSent = dataSent[:0]
+			for iop := 0; iop < Nops; iop++ {
+				free := bufsize - nsent - nunsent
+				availPkt := rtx.slist.Free()
+				op := op(rng.Intn(int(opmax)))
+				var oplen int
+				var opname string
+				var opWriteData []byte
+				switch op {
+				case opWrite:
+					opname, oplen = "write", rng.Intn(free+1)+1
+					opWriteData = auxbuf[:oplen]
+					rng.Read(opWriteData)
+				case opSend:
+					opname, oplen = "send", rng.Intn(nunsent+1)+1
+				case opAck:
+					opname, oplen = "ack", rng.Intn(nsent+1)+1
+				}
+				if log {
+					t.Logf("\n%s\nseed=%d itest=%d iop=%d op=%s len=%d npkt=%d", rtx.mustAppendString(nil), iseed, itest, iop, opname, oplen, len(rtx.slist.pkts))
+				}
+				switch op {
+				case opWrite:
+					// oplen=number of bytes to write into unsent buffer.
+					nwgot, err := rtx.Write(opWriteData)
+					wantErr := oplen > free
+					if err != nil && oplen <= free {
+						t.Fatal(itest, iop, err)
+					} else if err == nil {
+						if wantErr {
+							panic("wanted write error")
+						}
+						nunsent += nwgot
+						dataWritten = append(dataWritten, opWriteData[:nwgot]...)
+					} else if log {
+						t.Logf("opwrite: %s", err)
 					}
-					nunsent += nwgot
-					dataWritten = append(dataWritten, opWriteData[:nwgot]...)
-				} else {
-					t.Logf("opwrite: %s", err)
-				}
-			case opSend:
-				// oplen=num bytes sent.
-				nsgot, err := rtx.MakePacket(auxbuf[:oplen], currentSeq)
-				megafail := nsgot > nunsent
-				if err != nil && oplen <= nunsent && availPkt > 0 {
-					t.Fatal(itest, iop, err)
-				} else if err == nil {
-					if megafail {
-						panic("megafail")
+					clear(opWriteData)
+				case opSend:
+					// oplen=num bytes to send in this operation.
+					nsgot, err := rtx.MakePacket(auxbuf[:oplen], currentSeq)
+					megafail := nsgot > nunsent
+					if err != nil && oplen <= nunsent && availPkt > 0 {
+						t.Fatal(itest, iop, err)
+					} else if err == nil {
+						if megafail {
+							panic("megafail")
+						}
+						nunsent -= nsgot
+						nsent += nsgot
+						dataSent = append(dataSent, auxbuf[:nsgot]...)
+						currentSeq += Value(nsgot)
+					} else if log {
+						t.Logf("opsend: %s", err)
 					}
-					nunsent -= nsgot
-					nsent += nsgot
-					dataSent = append(dataSent, auxbuf[:nsgot]...)
-					currentSeq += Value(nsgot)
-				} else {
-					t.Logf("opsend: %s", err)
+					clear(auxbuf[:oplen])
+				case opAck:
+					// oplen=acklength.
+					tryAck := currentAcked + Value(oplen)
+					err = rtx.RecvACK(tryAck)
+					if err != nil && oplen <= nsent {
+						t.Fatal(itest, iop, err)
+					} else if err == nil {
+						nsent -= oplen
+						nacked += oplen
+						currentAcked = tryAck
+					} else if log {
+						t.Logf("opack: %s", err)
+					}
+				default:
+					panic("unknown op")
 				}
-			case opAck:
-				// oplen=acklength.
-				tryAck := currentAcked + Value(oplen)
-				err = rtx.RecvACK(tryAck)
-				if err != nil && oplen <= nsent {
-					t.Fatal(itest, iop, err)
-				} else if err == nil {
-					nsent -= oplen
-					nacked += oplen
-					currentAcked = tryAck
-				} else {
-					t.Logf("opack: %s", err)
-				}
-			default:
-				panic("unknown op")
 			}
 		}
 	}