Chris Lu
4 years ago
16 changed files with 2711 additions and 24 deletions
-
2go.mod
-
4go.sum
-
37weed/command/volume.go
-
715weed/udptransfer/conn.go
-
86weed/udptransfer/conn_test.go
-
95weed/udptransfer/debug.go
-
339weed/udptransfer/endpoint.go
-
42weed/udptransfer/endpoint_test.go
-
333weed/udptransfer/linked.go
-
236weed/udptransfer/linked_test.go
-
142weed/udptransfer/packet.go
-
516weed/udptransfer/state.go
-
36weed/udptransfer/stopwatch.go
-
18weed/udptransfer/timer.go
-
32weed/udptransfer/timing_test.go
-
102weed/wdclient/volume_udp_client.go
@ -0,0 +1,715 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"encoding/binary" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
"log" |
||||
|
"net" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_MAX_RETRIES = 6 |
||||
|
_MIN_RTT = 8 |
||||
|
_MIN_RTO = 30 |
||||
|
_MIN_ATO = 2 |
||||
|
_MAX_ATO = 10 |
||||
|
_MIN_SWND = 10 |
||||
|
_MAX_SWND = 960 |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_VACK_SCHED = iota + 1 |
||||
|
_VACK_QUICK |
||||
|
_VACK_MUST |
||||
|
_VSWND_ACTIVE |
||||
|
_VRETR_IMMED |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_RETR_REST = -1 |
||||
|
_CLOSE = 0xff |
||||
|
) |
||||
|
|
||||
|
var debug int |
||||
|
|
||||
|
func nodeOf(pk *packet) *qNode { |
||||
|
return &qNode{packet: pk} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) internalRecvLoop() { |
||||
|
defer func() { |
||||
|
// avoid send to closed channel while some replaying
|
||||
|
// data packets were received in shutting down.
|
||||
|
_ = recover() |
||||
|
}() |
||||
|
var buf, body []byte |
||||
|
for { |
||||
|
select { |
||||
|
case buf = <-c.evRecv: |
||||
|
if buf != nil { |
||||
|
body = buf[_TH_SIZE:] |
||||
|
} else { // shutdown
|
||||
|
return |
||||
|
} |
||||
|
} |
||||
|
pk := new(packet) |
||||
|
// keep the original buffer, so we could recycle it in future
|
||||
|
pk.buffer = buf |
||||
|
unmarshall(pk, body) |
||||
|
if pk.flag&_F_SACK != 0 { |
||||
|
c.processSAck(pk) |
||||
|
continue |
||||
|
} |
||||
|
if pk.flag&_F_ACK != 0 { |
||||
|
c.processAck(pk) |
||||
|
} |
||||
|
if pk.flag&_F_DATA != 0 { |
||||
|
c.insertData(pk) |
||||
|
} else if pk.flag&_F_FIN != 0 { |
||||
|
if pk.flag&_F_RESET != 0 { |
||||
|
go c.forceShutdownWithLock() |
||||
|
} else { |
||||
|
go c.closeR(pk) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) internalSendLoop() { |
||||
|
var timer = time.NewTimer(time.Duration(c.rtt) * time.Millisecond) |
||||
|
for { |
||||
|
select { |
||||
|
case v := <-c.evSWnd: |
||||
|
switch v { |
||||
|
case _VRETR_IMMED: |
||||
|
c.outlock.Lock() |
||||
|
c.retransmit2() |
||||
|
c.outlock.Unlock() |
||||
|
case _VSWND_ACTIVE: |
||||
|
timer.Reset(time.Duration(c.rtt) * time.Millisecond) |
||||
|
case _CLOSE: |
||||
|
return |
||||
|
} |
||||
|
case <-timer.C: // timeout yet
|
||||
|
var notifySender bool |
||||
|
c.outlock.Lock() |
||||
|
rest, _ := c.retransmit() |
||||
|
switch rest { |
||||
|
case _RETR_REST, 0: // nothing to send
|
||||
|
if c.outQ.size() > 0 { |
||||
|
timer.Reset(time.Duration(c.rtt) * time.Millisecond) |
||||
|
} else { |
||||
|
timer.Stop() |
||||
|
// avoid sender blocking
|
||||
|
notifySender = true |
||||
|
} |
||||
|
default: // recent rto point
|
||||
|
timer.Reset(time.Duration(minI64(rest, c.rtt)) * time.Millisecond) |
||||
|
} |
||||
|
c.outlock.Unlock() |
||||
|
if notifySender { |
||||
|
select { |
||||
|
case c.evSend <- 1: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) internalAckLoop() { |
||||
|
// var ackTimer = time.NewTicker(time.Duration(c.ato))
|
||||
|
var ackTimer = time.NewTimer(time.Duration(c.ato) * time.Millisecond) |
||||
|
var lastAckState byte |
||||
|
for { |
||||
|
var v byte |
||||
|
select { |
||||
|
case <-ackTimer.C: |
||||
|
// may cause sending duplicated ack if ato>rtt
|
||||
|
v = _VACK_QUICK |
||||
|
case v = <-c.evAck: |
||||
|
ackTimer.Reset(time.Duration(c.ato) * time.Millisecond) |
||||
|
state := lastAckState |
||||
|
lastAckState = v |
||||
|
if state != v { |
||||
|
if v == _CLOSE { |
||||
|
return |
||||
|
} |
||||
|
v = _VACK_MUST |
||||
|
} |
||||
|
} |
||||
|
c.inlock.Lock() |
||||
|
if pkAck := c.makeAck(v); pkAck != nil { |
||||
|
c.internalWrite(nodeOf(pkAck)) |
||||
|
} |
||||
|
c.inlock.Unlock() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) retransmit() (rest int64, count int32) { |
||||
|
var now, rto = Now(), c.rto |
||||
|
var limit = c.cwnd |
||||
|
for item := c.outQ.head; item != nil && limit > 0; item = item.next { |
||||
|
if item.scnt != _SENT_OK { // ACKed has scnt==-1
|
||||
|
diff := now - item.sent |
||||
|
if diff > rto { // already rto
|
||||
|
c.internalWrite(item) |
||||
|
count++ |
||||
|
} else { |
||||
|
// continue search next min rto duration
|
||||
|
if rest > 0 { |
||||
|
rest = minI64(rest, rto-diff+1) |
||||
|
} else { |
||||
|
rest = rto - diff + 1 |
||||
|
} |
||||
|
limit-- |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
c.outDupCnt += int(count) |
||||
|
if count > 0 { |
||||
|
shrcond := (c.fastRetransmit && count > maxI32(c.cwnd>>5, 4)) || (!c.fastRetransmit && count > c.cwnd>>3) |
||||
|
if shrcond && now-c.lastShrink > c.rto { |
||||
|
log.Printf("shrink cwnd from=%d to=%d s/4=%d", c.cwnd, c.cwnd>>1, c.swnd>>2) |
||||
|
c.lastShrink = now |
||||
|
// shrink cwnd and ensure cwnd >= swnd/4
|
||||
|
if c.cwnd > c.swnd>>1 { |
||||
|
c.cwnd >>= 1 |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
if c.outQ.size() > 0 { |
||||
|
return |
||||
|
} |
||||
|
return _RETR_REST, 0 |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) retransmit2() (count int32) { |
||||
|
var limit, now = minI32(c.outPending>>4, 8), Now() |
||||
|
var fRtt = c.rtt |
||||
|
if now-c.lastShrink > c.rto { |
||||
|
fRtt += maxI64(c.rtt>>4, 1) |
||||
|
} else { |
||||
|
fRtt += maxI64(c.rtt>>1, 2) |
||||
|
} |
||||
|
for item := c.outQ.head; item != nil && count < limit; item = item.next { |
||||
|
if item.scnt != _SENT_OK { // ACKed has scnt==-1
|
||||
|
if item.miss >= 3 && now-item.sent >= fRtt { |
||||
|
item.miss = 0 |
||||
|
c.internalWrite(item) |
||||
|
count++ |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
c.fRCnt += int(count) |
||||
|
c.outDupCnt += int(count) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) inputAndSend(pk *packet) error { |
||||
|
item := &qNode{packet: pk} |
||||
|
if c.mySeq&3 == 1 { |
||||
|
c.tSlotT0 = NowNS() |
||||
|
} |
||||
|
c.outlock.Lock() |
||||
|
// inflight packets exceeds cwnd
|
||||
|
// inflight includes: 1, unacked; 2, missed
|
||||
|
for c.outPending >= c.cwnd+c.missed { |
||||
|
c.outlock.Unlock() |
||||
|
if c.wtmo > 0 { |
||||
|
var tmo int64 |
||||
|
tmo, c.wtmo = c.wtmo, 0 |
||||
|
select { |
||||
|
case v := <-c.evSend: |
||||
|
if v == _CLOSE { |
||||
|
return io.EOF |
||||
|
} |
||||
|
case <-NewTimerChan(tmo): |
||||
|
return ErrIOTimeout |
||||
|
} |
||||
|
} else { |
||||
|
if v := <-c.evSend; v == _CLOSE { |
||||
|
return io.EOF |
||||
|
} |
||||
|
} |
||||
|
c.outlock.Lock() |
||||
|
} |
||||
|
c.outPending++ |
||||
|
c.outPkCnt++ |
||||
|
c.mySeq++ |
||||
|
pk.seq = c.mySeq |
||||
|
c.outQ.appendTail(item) |
||||
|
c.internalWrite(item) |
||||
|
c.outlock.Unlock() |
||||
|
// active resending timer, must blocking
|
||||
|
c.evSWnd <- _VSWND_ACTIVE |
||||
|
if c.mySeq&3 == 0 && c.flatTraffic { |
||||
|
// calculate time error bewteen tslot with actual usage.
|
||||
|
// consider last sleep time error
|
||||
|
t1 := NowNS() |
||||
|
terr := c.tSlot<<2 - c.lastSErr - (t1 - c.tSlotT0) |
||||
|
// rest terr/2 if current time usage less than tslot of 100us.
|
||||
|
if terr > 1e5 { // 100us
|
||||
|
time.Sleep(time.Duration(terr >> 1)) |
||||
|
c.lastSErr = maxI64(NowNS()-t1-terr, 0) |
||||
|
} else { |
||||
|
c.lastSErr >>= 1 |
||||
|
} |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) internalWrite(item *qNode) { |
||||
|
if item.scnt >= 20 { |
||||
|
// no exception of sending fin
|
||||
|
if item.flag&_F_FIN != 0 { |
||||
|
c.fakeShutdown() |
||||
|
c.dest = nil |
||||
|
return |
||||
|
} else { |
||||
|
log.Println("Warn: too many retries", item) |
||||
|
if c.urgent > 0 { // abort
|
||||
|
c.forceShutdown() |
||||
|
return |
||||
|
} else { // continue to retry 10
|
||||
|
c.urgent++ |
||||
|
item.scnt = 10 |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
// update current sent time and prev sent time
|
||||
|
item.sent, item.sent_1 = Now(), item.sent |
||||
|
item.scnt++ |
||||
|
buf := item.marshall(c.connID) |
||||
|
if debug >= 3 { |
||||
|
var pkType = packetTypeNames[item.flag] |
||||
|
if item.flag&_F_SACK != 0 { |
||||
|
log.Printf("send %s trp=%d on=%d %x", pkType, item.seq, item.ack, buf[_AH_SIZE+4:]) |
||||
|
} else { |
||||
|
log.Printf("send %s seq=%d ack=%d scnt=%d len=%d", pkType, item.seq, item.ack, item.scnt, len(buf)-_TH_SIZE) |
||||
|
} |
||||
|
} |
||||
|
c.sock.WriteToUDP(buf, c.dest) |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) logAck(ack uint32) { |
||||
|
c.lastAck = ack |
||||
|
c.lastAckTime = Now() |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) makeLastAck() (pk *packet) { |
||||
|
c.inlock.Lock() |
||||
|
defer c.inlock.Unlock() |
||||
|
if Now()-c.lastAckTime < c.rtt { |
||||
|
return nil |
||||
|
} |
||||
|
pk = &packet{ |
||||
|
ack: maxU32(c.lastAck, c.inQ.maxCtnSeq), |
||||
|
flag: _F_ACK, |
||||
|
} |
||||
|
c.logAck(pk.ack) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) makeAck(level byte) (pk *packet) { |
||||
|
now := Now() |
||||
|
if level < _VACK_MUST && now-c.lastAckTime < c.ato { |
||||
|
if level < _VACK_QUICK || now-c.lastAckTime < minI64(c.ato>>2, 1) { |
||||
|
return |
||||
|
} |
||||
|
} |
||||
|
// ready Q <-|
|
||||
|
// |-> outQ start (or more right)
|
||||
|
// |-> bitmap start
|
||||
|
// [predecessor] [predecessor+1] [predecessor+2] .....
|
||||
|
var fakeSAck bool |
||||
|
var predecessor = c.inQ.maxCtnSeq |
||||
|
bmap, tbl := c.inQ.makeHolesBitmap(predecessor) |
||||
|
if len(bmap) <= 0 { // fake sack
|
||||
|
bmap = make([]uint64, 1) |
||||
|
bmap[0], tbl = 1, 1 |
||||
|
fakeSAck = true |
||||
|
} |
||||
|
// head 4-byte: TBL:1 | SCNT:1 | DELAY:2
|
||||
|
buf := make([]byte, len(bmap)*8+4) |
||||
|
pk = &packet{ |
||||
|
ack: predecessor + 1, |
||||
|
flag: _F_SACK, |
||||
|
payload: buf, |
||||
|
} |
||||
|
if fakeSAck { |
||||
|
pk.ack-- |
||||
|
} |
||||
|
buf[0] = byte(tbl) |
||||
|
// mark delayed time according to the time reference point
|
||||
|
if trp := c.inQ.lastIns; trp != nil { |
||||
|
delayed := now - trp.sent |
||||
|
if delayed < c.rtt { |
||||
|
pk.seq = trp.seq |
||||
|
pk.flag |= _F_TIME |
||||
|
buf[1] = trp.scnt |
||||
|
if delayed <= 0 { |
||||
|
delayed = 1 |
||||
|
} |
||||
|
binary.BigEndian.PutUint16(buf[2:], uint16(delayed)) |
||||
|
} |
||||
|
} |
||||
|
buf1 := buf[4:] |
||||
|
for i, b := range bmap { |
||||
|
binary.BigEndian.PutUint64(buf1[i*8:], b) |
||||
|
} |
||||
|
c.logAck(predecessor) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func unmarshallSAck(data []byte) (bmap []uint64, tbl uint32, delayed uint16, scnt uint8) { |
||||
|
if len(data) > 0 { |
||||
|
bmap = make([]uint64, len(data)>>3) |
||||
|
} else { |
||||
|
return |
||||
|
} |
||||
|
tbl = uint32(data[0]) |
||||
|
scnt = data[1] |
||||
|
delayed = binary.BigEndian.Uint16(data[2:]) |
||||
|
data = data[4:] |
||||
|
for i := 0; i < len(bmap); i++ { |
||||
|
bmap[i] = binary.BigEndian.Uint64(data[i*8:]) |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func calSwnd(bandwidth, rtt int64) int32 { |
||||
|
w := int32(bandwidth * rtt / (8000 * _MSS)) |
||||
|
if w <= _MAX_SWND { |
||||
|
if w >= _MIN_SWND { |
||||
|
return w |
||||
|
} else { |
||||
|
return _MIN_SWND |
||||
|
} |
||||
|
} else { |
||||
|
return _MAX_SWND |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) measure(seq uint32, delayed int64, scnt uint8) { |
||||
|
target := c.outQ.get(seq) |
||||
|
if target != nil { |
||||
|
var lastSent int64 |
||||
|
switch target.scnt - scnt { |
||||
|
case 0: |
||||
|
// not sent again since this ack was sent out
|
||||
|
lastSent = target.sent |
||||
|
case 1: |
||||
|
// sent again once since this ack was sent out
|
||||
|
// then use prev sent time
|
||||
|
lastSent = target.sent_1 |
||||
|
default: |
||||
|
// can't measure here because the packet was sent too many times
|
||||
|
return |
||||
|
} |
||||
|
// real-time rtt
|
||||
|
rtt := Now() - lastSent - delayed |
||||
|
// reject these abnormal measures:
|
||||
|
// 1. rtt too small -> rtt/8
|
||||
|
// 2. backlogging too long
|
||||
|
if rtt < maxI64(c.rtt>>3, 1) || delayed > c.rtt>>1 { |
||||
|
return |
||||
|
} |
||||
|
// srtt: update 1/8
|
||||
|
err := rtt - (c.srtt >> 3) |
||||
|
c.srtt += err |
||||
|
c.rtt = c.srtt >> 3 |
||||
|
if c.rtt < _MIN_RTT { |
||||
|
c.rtt = _MIN_RTT |
||||
|
} |
||||
|
// s-swnd: update 1/4
|
||||
|
swnd := c.swnd<<3 - c.swnd + calSwnd(c.bandwidth, c.rtt) |
||||
|
c.swnd = swnd >> 3 |
||||
|
c.tSlot = c.rtt * 1e6 / int64(c.swnd) |
||||
|
c.ato = c.rtt >> 4 |
||||
|
if c.ato < _MIN_ATO { |
||||
|
c.ato = _MIN_ATO |
||||
|
} else if c.ato > _MAX_ATO { |
||||
|
c.ato = _MAX_ATO |
||||
|
} |
||||
|
if err < 0 { |
||||
|
err = -err |
||||
|
err -= c.mdev >> 2 |
||||
|
if err > 0 { |
||||
|
err >>= 3 |
||||
|
} |
||||
|
} else { |
||||
|
err -= c.mdev >> 2 |
||||
|
} |
||||
|
// mdev: update 1/4
|
||||
|
c.mdev += err |
||||
|
rto := c.rtt + maxI64(c.rtt<<1, c.mdev) |
||||
|
if rto >= c.rto { |
||||
|
c.rto = rto |
||||
|
} else { |
||||
|
c.rto = (c.rto + rto) >> 1 |
||||
|
} |
||||
|
if c.rto < _MIN_RTO { |
||||
|
c.rto = _MIN_RTO |
||||
|
} |
||||
|
if debug >= 1 { |
||||
|
log.Printf("--- rtt=%d srtt=%d rto=%d swnd=%d", c.rtt, c.srtt, c.rto, c.swnd) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) processSAck(pk *packet) { |
||||
|
c.outlock.Lock() |
||||
|
bmap, tbl, delayed, scnt := unmarshallSAck(pk.payload) |
||||
|
if bmap == nil { // bad packet
|
||||
|
c.outlock.Unlock() |
||||
|
return |
||||
|
} |
||||
|
if pk.flag&_F_TIME != 0 { |
||||
|
c.measure(pk.seq, int64(delayed), scnt) |
||||
|
} |
||||
|
deleted, missed, continuous := c.outQ.deleteByBitmap(bmap, pk.ack, tbl) |
||||
|
if deleted > 0 { |
||||
|
c.ackHit(deleted, missed) |
||||
|
// lock is released
|
||||
|
} else { |
||||
|
c.outlock.Unlock() |
||||
|
} |
||||
|
if c.fastRetransmit && !continuous { |
||||
|
// peer Q is uncontinuous, then trigger FR
|
||||
|
if deleted == 0 { |
||||
|
c.evSWnd <- _VRETR_IMMED |
||||
|
} else { |
||||
|
select { |
||||
|
case c.evSWnd <- _VRETR_IMMED: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
if debug >= 2 { |
||||
|
log.Printf("SACK qhead=%d deleted=%d outPending=%d on=%d %016x", |
||||
|
c.outQ.distanceOfHead(0), deleted, c.outPending, pk.ack, bmap) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) processAck(pk *packet) { |
||||
|
c.outlock.Lock() |
||||
|
if end := c.outQ.get(pk.ack); end != nil { // ack hit
|
||||
|
_, deleted := c.outQ.deleteBefore(end) |
||||
|
c.ackHit(deleted, 0) // lock is released
|
||||
|
if debug >= 2 { |
||||
|
log.Printf("ACK hit on=%d", pk.ack) |
||||
|
} |
||||
|
// special case: ack the FIN
|
||||
|
if pk.seq == _FIN_ACK_SEQ { |
||||
|
select { |
||||
|
case c.evClose <- _S_FIN0: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
} else { // duplicated ack
|
||||
|
if debug >= 2 { |
||||
|
log.Printf("ACK miss on=%d", pk.ack) |
||||
|
} |
||||
|
if pk.flag&_F_SYN != 0 { // No.3 Ack lost
|
||||
|
if pkAck := c.makeLastAck(); pkAck != nil { |
||||
|
c.internalWrite(nodeOf(pkAck)) |
||||
|
} |
||||
|
} |
||||
|
c.outlock.Unlock() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) ackHit(deleted, missed int32) { |
||||
|
// must in outlock
|
||||
|
c.outPending -= deleted |
||||
|
now := Now() |
||||
|
if c.cwnd < c.swnd && now-c.lastShrink > c.rto { |
||||
|
if c.cwnd < c.swnd>>1 { |
||||
|
c.cwnd <<= 1 |
||||
|
} else { |
||||
|
c.cwnd += deleted << 1 |
||||
|
} |
||||
|
} |
||||
|
if c.cwnd > c.swnd { |
||||
|
c.cwnd = c.swnd |
||||
|
} |
||||
|
if now-c.lastRstMis > c.ato { |
||||
|
c.lastRstMis = now |
||||
|
c.missed = missed |
||||
|
} else { |
||||
|
c.missed = c.missed>>1 + missed |
||||
|
} |
||||
|
if qswnd := c.swnd >> 4; c.missed > qswnd { |
||||
|
c.missed = qswnd |
||||
|
} |
||||
|
c.outlock.Unlock() |
||||
|
select { |
||||
|
case c.evSend <- 1: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) insertData(pk *packet) { |
||||
|
c.inlock.Lock() |
||||
|
defer c.inlock.Unlock() |
||||
|
exists := c.inQ.contains(pk.seq) |
||||
|
// duplicated with already queued or history
|
||||
|
// means: last ACK were lost
|
||||
|
if exists || pk.seq <= c.inQ.maxCtnSeq { |
||||
|
// then send ACK for dups
|
||||
|
select { |
||||
|
case c.evAck <- _VACK_MUST: |
||||
|
default: |
||||
|
} |
||||
|
if debug >= 2 { |
||||
|
dumpQ(fmt.Sprint("duplicated ", pk.seq), c.inQ) |
||||
|
} |
||||
|
c.inDupCnt++ |
||||
|
return |
||||
|
} |
||||
|
// record current time in sent and regard as received time
|
||||
|
item := &qNode{packet: pk, sent: Now()} |
||||
|
dis := c.inQ.searchInsert(item, c.lastReadSeq) |
||||
|
if debug >= 3 { |
||||
|
log.Printf("\t\t\trecv DATA seq=%d dis=%d maxCtn=%d lastReadSeq=%d", item.seq, dis, c.inQ.maxCtnSeq, c.lastReadSeq) |
||||
|
} |
||||
|
|
||||
|
var ackState byte = _VACK_MUST |
||||
|
var available bool |
||||
|
switch dis { |
||||
|
case 0: // impossible
|
||||
|
return |
||||
|
case 1: |
||||
|
if c.inQDirty { |
||||
|
available = c.inQ.updateContinuous(item) |
||||
|
if c.inQ.isWholeContinuous() { // whole Q is ordered
|
||||
|
c.inQDirty = false |
||||
|
} else { //those holes still exists.
|
||||
|
ackState = _VACK_QUICK |
||||
|
} |
||||
|
} else { |
||||
|
// here is an ideal situation
|
||||
|
c.inQ.maxCtnSeq = pk.seq |
||||
|
available = true |
||||
|
ackState = _VACK_SCHED |
||||
|
} |
||||
|
|
||||
|
default: // there is an unordered packet, hole occurred here.
|
||||
|
if !c.inQDirty { |
||||
|
c.inQDirty = true |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// write valid received count
|
||||
|
c.inPkCnt++ |
||||
|
c.inQ.lastIns = item |
||||
|
// try notify ack
|
||||
|
select { |
||||
|
case c.evAck <- ackState: |
||||
|
default: |
||||
|
} |
||||
|
if available { // try notify reader
|
||||
|
select { |
||||
|
case c.evRead <- 1: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) readInQ() bool { |
||||
|
c.inlock.Lock() |
||||
|
defer c.inlock.Unlock() |
||||
|
// read already <-|-> expected Q
|
||||
|
// [lastReadSeq] | [lastReadSeq+1] [lastReadSeq+2] ......
|
||||
|
if c.inQ.isEqualsHead(c.lastReadSeq+1) && c.lastReadSeq < c.inQ.maxCtnSeq { |
||||
|
c.lastReadSeq = c.inQ.maxCtnSeq |
||||
|
availabled := c.inQ.get(c.inQ.maxCtnSeq) |
||||
|
availabled, _ = c.inQ.deleteBefore(availabled) |
||||
|
for i := availabled; i != nil; i = i.next { |
||||
|
c.inQReady = append(c.inQReady, i.payload...) |
||||
|
// data was copied, then could recycle memory
|
||||
|
bpool.Put(i.buffer) |
||||
|
i.payload = nil |
||||
|
i.buffer = nil |
||||
|
} |
||||
|
return true |
||||
|
} |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
// should not call this function concurrently.
|
||||
|
func (c *Conn) Read(buf []byte) (nr int, err error) { |
||||
|
for { |
||||
|
if len(c.inQReady) > 0 { |
||||
|
n := copy(buf, c.inQReady) |
||||
|
c.inQReady = c.inQReady[n:] |
||||
|
return n, nil |
||||
|
} |
||||
|
if !c.readInQ() { |
||||
|
if c.rtmo > 0 { |
||||
|
var tmo int64 |
||||
|
tmo, c.rtmo = c.rtmo, 0 |
||||
|
select { |
||||
|
case _, y := <-c.evRead: |
||||
|
if !y && len(c.inQReady) == 0 { |
||||
|
return 0, io.EOF |
||||
|
} |
||||
|
case <-NewTimerChan(tmo): |
||||
|
return 0, ErrIOTimeout |
||||
|
} |
||||
|
} else { |
||||
|
// only when evRead is closed and inQReady is empty
|
||||
|
// then could reply eof
|
||||
|
if _, y := <-c.evRead; !y && len(c.inQReady) == 0 { |
||||
|
return 0, io.EOF |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// should not call this function concurrently.
|
||||
|
func (c *Conn) Write(data []byte) (nr int, err error) { |
||||
|
for len(data) > 0 && err == nil { |
||||
|
//buf := make([]byte, _MSS+_AH_SIZE)
|
||||
|
buf := bpool.Get(c.mss + _AH_SIZE) |
||||
|
body := buf[_TH_SIZE+_CH_SIZE:] |
||||
|
n := copy(body, data) |
||||
|
nr += n |
||||
|
data = data[n:] |
||||
|
pk := &packet{flag: _F_DATA, payload: body[:n], buffer: buf[:_AH_SIZE+n]} |
||||
|
err = c.inputAndSend(pk) |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) LocalAddr() net.Addr { |
||||
|
return c.sock.LocalAddr() |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) RemoteAddr() net.Addr { |
||||
|
return c.dest |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) SetDeadline(t time.Time) error { |
||||
|
c.SetReadDeadline(t) |
||||
|
c.SetWriteDeadline(t) |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) SetReadDeadline(t time.Time) error { |
||||
|
if d := t.UnixNano()/Millisecond - Now(); d > 0 { |
||||
|
c.rtmo = d |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) SetWriteDeadline(t time.Time) error { |
||||
|
if d := t.UnixNano()/Millisecond - Now(); d > 0 { |
||||
|
c.wtmo = d |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
@ -0,0 +1,86 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"math/rand" |
||||
|
"sort" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
var conn *Conn |
||||
|
|
||||
|
func init() { |
||||
|
conn = &Conn{ |
||||
|
outQ: newLinkedMap(_QModeOut), |
||||
|
inQ: newLinkedMap(_QModeIn), |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func assert(cond bool, t testing.TB, format string, args ...interface{}) { |
||||
|
if !cond { |
||||
|
t.Errorf(format, args...) |
||||
|
panic("last error") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func Test_ordered_insert(t *testing.T) { |
||||
|
data := []byte{1} |
||||
|
var pk *packet |
||||
|
for i := int32(1); i < 33; i++ { |
||||
|
pk = &packet{ |
||||
|
seq: uint32(i), |
||||
|
payload: data, |
||||
|
} |
||||
|
conn.insertData(pk) |
||||
|
assert(conn.inQ.size() == i, t, "len inQ=%d", conn.inQ.size()) |
||||
|
assert(conn.inQ.maxCtnSeq == pk.seq, t, "lastCtnIn") |
||||
|
assert(!conn.inQDirty, t, "dirty") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func Test_unordered_insert(t *testing.T) { |
||||
|
conn.inQ.reset() |
||||
|
|
||||
|
data := []byte{1} |
||||
|
var pk *packet |
||||
|
var seqs = make([]int, 0xfff) |
||||
|
// unordered insert, and assert size
|
||||
|
for i := 1; i < len(seqs); i++ { |
||||
|
var seq uint32 |
||||
|
for conn.inQ.contains(seq) || seq == 0 { |
||||
|
seq = uint32(rand.Int31n(0xFFffff)) |
||||
|
} |
||||
|
seqs[i] = int(seq) |
||||
|
pk = &packet{ |
||||
|
seq: seq, |
||||
|
payload: data, |
||||
|
} |
||||
|
conn.insertData(pk) |
||||
|
assert(conn.inQ.size() == int32(i), t, "i=%d inQ.len=%d", i, conn.inQ.size()) |
||||
|
} |
||||
|
// assert lastCtnSeq
|
||||
|
sort.Ints(seqs) |
||||
|
var zero = 0 |
||||
|
var last *int |
||||
|
for i := 0; i < len(seqs); i++ { |
||||
|
if i == 0 && seqs[0] != 0 { |
||||
|
last = &zero |
||||
|
break |
||||
|
} |
||||
|
if last != nil && seqs[i]-*last > 1 { |
||||
|
if i == 1 { |
||||
|
last = &zero |
||||
|
} |
||||
|
break |
||||
|
} |
||||
|
last = &seqs[i] |
||||
|
} |
||||
|
if *last != int(conn.inQ.maxCtnSeq) { |
||||
|
for i, j := range seqs { |
||||
|
if i < 10 { |
||||
|
t.Logf("seq %d", j) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
assert(*last == int(conn.inQ.maxCtnSeq), t, "lastCtnSeq=%d but expected=%d", conn.inQ.maxCtnSeq, *last) |
||||
|
t.Logf("lastCtnSeq=%d dirty=%v", conn.inQ.maxCtnSeq, conn.inQDirty) |
||||
|
} |
||||
@ -0,0 +1,95 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"encoding/hex" |
||||
|
"fmt" |
||||
|
"log" |
||||
|
"os" |
||||
|
"os/signal" |
||||
|
"runtime" |
||||
|
"runtime/pprof" |
||||
|
"sync/atomic" |
||||
|
"syscall" |
||||
|
) |
||||
|
|
||||
|
var enable_pprof bool |
||||
|
var enable_stacktrace bool |
||||
|
var debug_inited int32 |
||||
|
|
||||
|
func set_debug_params(p *Params) { |
||||
|
if atomic.CompareAndSwapInt32(&debug_inited, 0, 1) { |
||||
|
debug = p.Debug |
||||
|
enable_pprof = p.EnablePprof |
||||
|
enable_stacktrace = p.Stacktrace |
||||
|
if enable_pprof { |
||||
|
f, err := os.Create("udptransfer.pprof") |
||||
|
if err != nil { |
||||
|
log.Fatalln(err) |
||||
|
} |
||||
|
pprof.StartCPUProfile(f) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) PrintState() { |
||||
|
log.Printf("inQ=%d inQReady=%d outQ=%d", c.inQ.size(), len(c.inQReady), c.outQ.size()) |
||||
|
log.Printf("inMaxCtnSeq=%d lastAck=%d lastReadSeq=%d", c.inQ.maxCtnSeq, c.lastAck, c.lastReadSeq) |
||||
|
if c.inPkCnt > 0 { |
||||
|
log.Printf("Rx pcnt=%d dups=%d %%d=%f%%", c.inPkCnt, c.inDupCnt, 100*float32(c.inDupCnt)/float32(c.inPkCnt)) |
||||
|
} |
||||
|
if c.outPkCnt > 0 { |
||||
|
log.Printf("Tx pcnt=%d dups=%d %%d=%f%%", c.outPkCnt, c.outDupCnt, 100*float32(c.outDupCnt)/float32(c.outPkCnt)) |
||||
|
} |
||||
|
log.Printf("current-rtt=%d FastRetransmit=%d", c.rtt, c.fRCnt) |
||||
|
if enable_stacktrace { |
||||
|
var buf = make([]byte, 6400) |
||||
|
for i := 0; i < 3; i++ { |
||||
|
n := runtime.Stack(buf, true) |
||||
|
if n >= len(buf) { |
||||
|
buf = make([]byte, len(buf)<<1) |
||||
|
} else { |
||||
|
buf = buf[:n] |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
fmt.Println(string(buf)) |
||||
|
} |
||||
|
if enable_pprof { |
||||
|
pprof.StopCPUProfile() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) internal_state() { |
||||
|
ev := make(chan os.Signal, 10) |
||||
|
signal.Notify(ev, syscall.Signal(12), syscall.SIGINT) |
||||
|
for v := range ev { |
||||
|
c.PrintState() |
||||
|
if v == syscall.SIGINT { |
||||
|
os.Exit(1) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func printBits(b uint64, j, s, d uint32) { |
||||
|
fmt.Printf("bits=%064b j=%d seq=%d dis=%d\n", b, j, s, d) |
||||
|
} |
||||
|
|
||||
|
func dumpb(label string, buf []byte) { |
||||
|
log.Println(label, "\n", hex.Dump(buf)) |
||||
|
} |
||||
|
|
||||
|
func dumpQ(s string, q *linkedMap) { |
||||
|
var seqs = make([]uint32, 0, 20) |
||||
|
n := q.head |
||||
|
for i, m := int32(0), q.size(); i < m && n != nil; i++ { |
||||
|
seqs = append(seqs, n.seq) |
||||
|
n = n.next |
||||
|
if len(seqs) == 20 { |
||||
|
log.Printf("%s: Q=%d", s, seqs) |
||||
|
seqs = seqs[:0] |
||||
|
} |
||||
|
} |
||||
|
if len(seqs) > 0 { |
||||
|
log.Printf("%s: Q=%d", s, seqs) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,339 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"encoding/binary" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
"log" |
||||
|
"math/rand" |
||||
|
"net" |
||||
|
"sort" |
||||
|
"sync" |
||||
|
"sync/atomic" |
||||
|
"time" |
||||
|
|
||||
|
"github.com/cloudflare/golibs/bytepool" |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_SO_BUF_SIZE = 8 << 20 |
||||
|
) |
||||
|
|
||||
|
var ( |
||||
|
bpool bytepool.BytePool |
||||
|
) |
||||
|
|
||||
|
type Params struct { |
||||
|
LocalAddr string |
||||
|
Bandwidth int64 |
||||
|
Mtu int |
||||
|
IsServ bool |
||||
|
FastRetransmit bool |
||||
|
FlatTraffic bool |
||||
|
EnablePprof bool |
||||
|
Stacktrace bool |
||||
|
Debug int |
||||
|
} |
||||
|
|
||||
|
type connID struct { |
||||
|
lid uint32 |
||||
|
rid uint32 |
||||
|
} |
||||
|
|
||||
|
type Endpoint struct { |
||||
|
udpconn *net.UDPConn |
||||
|
state int32 |
||||
|
idSeq uint32 |
||||
|
isServ bool |
||||
|
listenChan chan *Conn |
||||
|
lRegistry map[uint32]*Conn |
||||
|
rRegistry map[string][]uint32 |
||||
|
mlock sync.RWMutex |
||||
|
timeout *time.Timer |
||||
|
params Params |
||||
|
} |
||||
|
|
||||
|
func (c *connID) setRid(b []byte) { |
||||
|
c.rid = binary.BigEndian.Uint32(b[_MAGIC_SIZE+6:]) |
||||
|
} |
||||
|
|
||||
|
func init() { |
||||
|
bpool.Init(0, 2000) |
||||
|
rand.Seed(NowNS()) |
||||
|
} |
||||
|
|
||||
|
func NewEndpoint(p *Params) (*Endpoint, error) { |
||||
|
set_debug_params(p) |
||||
|
if p.Bandwidth <= 0 || p.Bandwidth > 100 { |
||||
|
return nil, fmt.Errorf("bw->(0,100]") |
||||
|
} |
||||
|
conn, err := net.ListenPacket("udp", p.LocalAddr) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
e := &Endpoint{ |
||||
|
udpconn: conn.(*net.UDPConn), |
||||
|
idSeq: 1, |
||||
|
isServ: p.IsServ, |
||||
|
listenChan: make(chan *Conn, 1), |
||||
|
lRegistry: make(map[uint32]*Conn), |
||||
|
rRegistry: make(map[string][]uint32), |
||||
|
timeout: time.NewTimer(0), |
||||
|
params: *p, |
||||
|
} |
||||
|
if e.isServ { |
||||
|
e.state = _S_EST0 |
||||
|
} else { // client
|
||||
|
e.state = _S_EST1 |
||||
|
e.idSeq = uint32(rand.Int31()) |
||||
|
} |
||||
|
e.params.Bandwidth = p.Bandwidth << 20 // mbps to bps
|
||||
|
e.udpconn.SetReadBuffer(_SO_BUF_SIZE) |
||||
|
go e.internal_listen() |
||||
|
return e, nil |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) internal_listen() { |
||||
|
const rtmo = time.Duration(30*time.Second) |
||||
|
var id connID |
||||
|
for { |
||||
|
//var buf = make([]byte, 1600)
|
||||
|
var buf = bpool.Get(1600) |
||||
|
e.udpconn.SetReadDeadline(time.Now().Add(rtmo)) |
||||
|
n, addr, err := e.udpconn.ReadFromUDP(buf) |
||||
|
if err == nil && n >= _AH_SIZE { |
||||
|
buf = buf[:n] |
||||
|
e.getConnID(&id, buf) |
||||
|
|
||||
|
switch id.lid { |
||||
|
case 0: // new connection
|
||||
|
if e.isServ { |
||||
|
go e.acceptNewConn(id, addr, buf) |
||||
|
} else { |
||||
|
dumpb("drop", buf) |
||||
|
} |
||||
|
|
||||
|
case _INVALID_SEQ: |
||||
|
dumpb("drop invalid", buf) |
||||
|
|
||||
|
default: // old connection
|
||||
|
e.mlock.RLock() |
||||
|
conn := e.lRegistry[id.lid] |
||||
|
e.mlock.RUnlock() |
||||
|
if conn != nil { |
||||
|
e.dispatch(conn, buf) |
||||
|
} else { |
||||
|
e.resetPeer(addr, id) |
||||
|
dumpb("drop null", buf) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} else if err != nil { |
||||
|
// idle process
|
||||
|
if nerr, y := err.(net.Error); y && nerr.Timeout() { |
||||
|
e.idleProcess() |
||||
|
continue |
||||
|
} |
||||
|
// other errors
|
||||
|
if atomic.LoadInt32(&e.state) == _S_FIN { |
||||
|
return |
||||
|
} else { |
||||
|
log.Println("Error: read sock", err) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) idleProcess() { |
||||
|
// recycle/shrink memory
|
||||
|
bpool.Drain() |
||||
|
e.mlock.Lock() |
||||
|
defer e.mlock.Unlock() |
||||
|
// reset urgent
|
||||
|
for _, c := range e.lRegistry { |
||||
|
c.outlock.Lock() |
||||
|
if c.outQ.size() == 0 && c.urgent != 0 { |
||||
|
c.urgent = 0 |
||||
|
} |
||||
|
c.outlock.Unlock() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) Dial(addr string) (*Conn, error) { |
||||
|
rAddr, err := net.ResolveUDPAddr("udp", addr) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
e.mlock.Lock() |
||||
|
e.idSeq++ |
||||
|
id := connID{e.idSeq, 0} |
||||
|
conn := NewConn(e, rAddr, id) |
||||
|
e.lRegistry[id.lid] = conn |
||||
|
e.mlock.Unlock() |
||||
|
if atomic.LoadInt32(&e.state) != _S_FIN { |
||||
|
err = conn.initConnection(nil) |
||||
|
return conn, err |
||||
|
} |
||||
|
return nil, io.EOF |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) acceptNewConn(id connID, addr *net.UDPAddr, buf []byte) { |
||||
|
rKey := addr.String() |
||||
|
e.mlock.Lock() |
||||
|
// map: remoteAddr => remoteConnID
|
||||
|
// filter duplicated syn packets
|
||||
|
if newArr := insertRid(e.rRegistry[rKey], id.rid); newArr != nil { |
||||
|
e.rRegistry[rKey] = newArr |
||||
|
} else { |
||||
|
e.mlock.Unlock() |
||||
|
log.Println("Warn: duplicated connection", addr) |
||||
|
return |
||||
|
} |
||||
|
e.idSeq++ |
||||
|
id.lid = e.idSeq |
||||
|
conn := NewConn(e, addr, id) |
||||
|
e.lRegistry[id.lid] = conn |
||||
|
e.mlock.Unlock() |
||||
|
err := conn.initConnection(buf) |
||||
|
if err == nil { |
||||
|
select { |
||||
|
case e.listenChan <- conn: |
||||
|
case <-time.After(_10ms): |
||||
|
log.Println("Warn: no listener") |
||||
|
} |
||||
|
} else { |
||||
|
e.removeConn(id, addr) |
||||
|
log.Println("Error: init_connection", addr, err) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) removeConn(id connID, addr *net.UDPAddr) { |
||||
|
e.mlock.Lock() |
||||
|
delete(e.lRegistry, id.lid) |
||||
|
rKey := addr.String() |
||||
|
if newArr := deleteRid(e.rRegistry[rKey], id.rid); newArr != nil { |
||||
|
if len(newArr) > 0 { |
||||
|
e.rRegistry[rKey] = newArr |
||||
|
} else { |
||||
|
delete(e.rRegistry, rKey) |
||||
|
} |
||||
|
} |
||||
|
e.mlock.Unlock() |
||||
|
} |
||||
|
|
||||
|
// net.Listener
|
||||
|
func (e *Endpoint) Close() error { |
||||
|
state := atomic.LoadInt32(&e.state) |
||||
|
if state > 0 && atomic.CompareAndSwapInt32(&e.state, state, _S_FIN) { |
||||
|
err := e.udpconn.Close() |
||||
|
e.lRegistry = nil |
||||
|
e.rRegistry = nil |
||||
|
select { // release listeners
|
||||
|
case e.listenChan <- nil: |
||||
|
default: |
||||
|
} |
||||
|
return err |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// net.Listener
|
||||
|
func (e *Endpoint) Addr() net.Addr { |
||||
|
return e.udpconn.LocalAddr() |
||||
|
} |
||||
|
|
||||
|
// net.Listener
|
||||
|
func (e *Endpoint) Accept() (net.Conn, error) { |
||||
|
if atomic.LoadInt32(&e.state) == _S_EST0 { |
||||
|
return <-e.listenChan, nil |
||||
|
} else { |
||||
|
return nil, io.EOF |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) Listen() *Conn { |
||||
|
if atomic.LoadInt32(&e.state) == _S_EST0 { |
||||
|
return <-e.listenChan |
||||
|
} else { |
||||
|
return nil |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// tmo in MS
|
||||
|
func (e *Endpoint) ListenTimeout(tmo int64) *Conn { |
||||
|
if tmo <= 0 { |
||||
|
return e.Listen() |
||||
|
} |
||||
|
if atomic.LoadInt32(&e.state) == _S_EST0 { |
||||
|
select { |
||||
|
case c := <-e.listenChan: |
||||
|
return c |
||||
|
case <-NewTimerChan(tmo): |
||||
|
} |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) getConnID(idPtr *connID, buf []byte) { |
||||
|
// TODO determine magic header
|
||||
|
magicAndLen := binary.BigEndian.Uint64(buf) |
||||
|
if int(magicAndLen&0xFFff) == len(buf) { |
||||
|
id := binary.BigEndian.Uint64(buf[_MAGIC_SIZE+2:]) |
||||
|
idPtr.lid = uint32(id >> 32) |
||||
|
idPtr.rid = uint32(id) |
||||
|
} else { |
||||
|
idPtr.lid = _INVALID_SEQ |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) dispatch(c *Conn, buf []byte) { |
||||
|
e.timeout.Reset(30*time.Millisecond) |
||||
|
select { |
||||
|
case c.evRecv <- buf: |
||||
|
case <-e.timeout.C: |
||||
|
log.Println("Warn: dispatch packet failed") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (e *Endpoint) resetPeer(addr *net.UDPAddr, id connID) { |
||||
|
pk := &packet{flag: _F_FIN | _F_RESET} |
||||
|
buf := nodeOf(pk).marshall(id) |
||||
|
e.udpconn.WriteToUDP(buf, addr) |
||||
|
} |
||||
|
|
||||
|
type u32Slice []uint32 |
||||
|
|
||||
|
func (p u32Slice) Len() int { return len(p) } |
||||
|
func (p u32Slice) Less(i, j int) bool { return p[i] < p[j] } |
||||
|
func (p u32Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } |
||||
|
|
||||
|
// if the rid is not existed in array then insert it return new array
|
||||
|
func insertRid(array []uint32, rid uint32) []uint32 { |
||||
|
if len(array) > 0 { |
||||
|
pos := sort.Search(len(array), func(n int) bool { |
||||
|
return array[n] >= rid |
||||
|
}) |
||||
|
if pos < len(array) && array[pos] == rid { |
||||
|
return nil |
||||
|
} |
||||
|
} |
||||
|
array = append(array, rid) |
||||
|
sort.Sort(u32Slice(array)) |
||||
|
return array |
||||
|
} |
||||
|
|
||||
|
// if rid was existed in array then delete it return new array
|
||||
|
func deleteRid(array []uint32, rid uint32) []uint32 { |
||||
|
if len(array) > 0 { |
||||
|
pos := sort.Search(len(array), func(n int) bool { |
||||
|
return array[n] >= rid |
||||
|
}) |
||||
|
if pos < len(array) && array[pos] == rid { |
||||
|
newArray := make([]uint32, len(array)-1) |
||||
|
n := copy(newArray, array[:pos]) |
||||
|
copy(newArray[n:], array[pos+1:]) |
||||
|
return newArray |
||||
|
} |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
@ -0,0 +1,42 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"math/rand" |
||||
|
"sort" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
func Test_insert_delete_rid(t *testing.T) { |
||||
|
var a []uint32 |
||||
|
var b = make([]uint32, 0, 1e3) |
||||
|
var uniq = make(map[uint32]int) |
||||
|
// insert into a with random
|
||||
|
for i := 0; i < cap(b); i++ { |
||||
|
n := uint32(rand.Int31()) |
||||
|
if _, y := uniq[n]; !y { |
||||
|
b = append(b, n) |
||||
|
uniq[n] = 1 |
||||
|
} |
||||
|
dups := 1 |
||||
|
if i&0xf == 0xf { |
||||
|
dups = 3 |
||||
|
} |
||||
|
for j := 0; j < dups; j++ { |
||||
|
if aa := insertRid(a, n); aa != nil { |
||||
|
a = aa |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
sort.Sort(u32Slice(b)) |
||||
|
bStr := fmt.Sprintf("%d", b) |
||||
|
aStr := fmt.Sprintf("%d", a) |
||||
|
assert(aStr == bStr, t, "a!=b") |
||||
|
|
||||
|
for i := 0; i < len(b); i++ { |
||||
|
if aa := deleteRid(a, b[i]); aa != nil { |
||||
|
a = aa |
||||
|
} |
||||
|
} |
||||
|
assert(len(a) == 0, t, "a!=0") |
||||
|
} |
||||
@ -0,0 +1,333 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
type qNode struct { |
||||
|
*packet |
||||
|
prev *qNode |
||||
|
next *qNode |
||||
|
sent int64 // last sent time
|
||||
|
sent_1 int64 // prev sent time
|
||||
|
miss int // sack miss count
|
||||
|
} |
||||
|
|
||||
|
type linkedMap struct { |
||||
|
head *qNode |
||||
|
tail *qNode |
||||
|
qmap map[uint32]*qNode |
||||
|
lastIns *qNode |
||||
|
maxCtnSeq uint32 |
||||
|
mode int |
||||
|
} |
||||
|
|
||||
|
const ( |
||||
|
_QModeIn = 1 |
||||
|
_QModeOut = 2 |
||||
|
) |
||||
|
|
||||
|
func newLinkedMap(qmode int) *linkedMap { |
||||
|
return &linkedMap{ |
||||
|
qmap: make(map[uint32]*qNode), |
||||
|
mode: qmode, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) get(seq uint32) (i *qNode) { |
||||
|
i = l.qmap[seq] |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) contains(seq uint32) bool { |
||||
|
_, y := l.qmap[seq] |
||||
|
return y |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) size() int32 { |
||||
|
return int32(len(l.qmap)) |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) reset() { |
||||
|
l.head = nil |
||||
|
l.tail = nil |
||||
|
l.lastIns = nil |
||||
|
l.maxCtnSeq = 0 |
||||
|
l.qmap = make(map[uint32]*qNode) |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) isEqualsHead(seq uint32) bool { |
||||
|
return l.head != nil && seq == l.head.seq |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) distanceOfHead(seq uint32) int32 { |
||||
|
if l.head != nil { |
||||
|
return int32(seq - l.head.seq) |
||||
|
} else { |
||||
|
return -1 |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) appendTail(one *qNode) { |
||||
|
if l.tail != nil { |
||||
|
l.tail.next = one |
||||
|
one.prev = l.tail |
||||
|
l.tail = one |
||||
|
} else { |
||||
|
l.head = one |
||||
|
l.tail = one |
||||
|
} |
||||
|
l.qmap[one.seq] = one |
||||
|
} |
||||
|
|
||||
|
// xxx - n - yyy
|
||||
|
// xxx - yyy
|
||||
|
func (l *linkedMap) deleteAt(n *qNode) { |
||||
|
x, y := n.prev, n.next |
||||
|
if x != nil { |
||||
|
x.next = y |
||||
|
} else { |
||||
|
l.head = y |
||||
|
} |
||||
|
if y != nil { |
||||
|
y.prev = x |
||||
|
} else { |
||||
|
l.tail = x |
||||
|
} |
||||
|
n.prev, n.next = nil, nil |
||||
|
delete(l.qmap, n.seq) |
||||
|
} |
||||
|
|
||||
|
// delete with n <- ...n |
|
||||
|
func (l *linkedMap) deleteBefore(n *qNode) (left *qNode, deleted int32) { |
||||
|
for i := n; i != nil; i = i.prev { |
||||
|
delete(l.qmap, i.seq) |
||||
|
if i.scnt != _SENT_OK { |
||||
|
deleted++ |
||||
|
// only outQ could delete at here
|
||||
|
if l.mode == _QModeOut { |
||||
|
bpool.Put(i.buffer) |
||||
|
i.buffer = nil |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
left = l.head |
||||
|
l.head = n.next |
||||
|
n.next = nil |
||||
|
if l.head != nil { |
||||
|
l.head.prev = nil |
||||
|
} else { // n.next is the tail and is nil
|
||||
|
l.tail = nil |
||||
|
} |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// xxx - ref
|
||||
|
// xxx - one - ref
|
||||
|
func (l *linkedMap) insertBefore(ref, one *qNode) { |
||||
|
x := ref.prev |
||||
|
if x != nil { |
||||
|
x.next = one |
||||
|
one.prev = x |
||||
|
} else { |
||||
|
l.head = one |
||||
|
} |
||||
|
ref.prev = one |
||||
|
one.next = ref |
||||
|
l.qmap[one.seq] = one |
||||
|
} |
||||
|
|
||||
|
// ref - zzz
|
||||
|
// ref - one - zzz
|
||||
|
func (l *linkedMap) insertAfter(ref, one *qNode) { |
||||
|
z := ref.next |
||||
|
if z == nil { // append
|
||||
|
ref.next = one |
||||
|
l.tail = one |
||||
|
} else { // insert mid
|
||||
|
z.prev = one |
||||
|
ref.next = one |
||||
|
} |
||||
|
one.prev = ref |
||||
|
one.next = z |
||||
|
l.qmap[one.seq] = one |
||||
|
} |
||||
|
|
||||
|
// baseHead: the left outside boundary
|
||||
|
// if inserted, return the distance between newNode with baseHead
|
||||
|
func (l *linkedMap) searchInsert(one *qNode, baseHead uint32) (dis int64) { |
||||
|
for i := l.tail; i != nil; i = i.prev { |
||||
|
dis = int64(one.seq) - int64(i.seq) |
||||
|
if dis > 0 { |
||||
|
l.insertAfter(i, one) |
||||
|
return |
||||
|
} else if dis == 0 { |
||||
|
// duplicated
|
||||
|
return |
||||
|
} |
||||
|
} |
||||
|
if one.seq <= baseHead { |
||||
|
return 0 |
||||
|
} |
||||
|
if l.head != nil { |
||||
|
l.insertBefore(l.head, one) |
||||
|
} else { |
||||
|
l.head = one |
||||
|
l.tail = one |
||||
|
l.qmap[one.seq] = one |
||||
|
} |
||||
|
dis = int64(one.seq) - int64(baseHead) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) updateContinuous(i *qNode) bool { |
||||
|
var lastCtnSeq = l.maxCtnSeq |
||||
|
for ; i != nil; i = i.next { |
||||
|
if i.seq-lastCtnSeq == 1 { |
||||
|
lastCtnSeq = i.seq |
||||
|
} else { |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
if lastCtnSeq != l.maxCtnSeq { |
||||
|
l.maxCtnSeq = lastCtnSeq |
||||
|
return true |
||||
|
} |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
func (l *linkedMap) isWholeContinuous() bool { |
||||
|
return l.tail != nil && l.maxCtnSeq == l.tail.seq |
||||
|
} |
||||
|
|
||||
|
/* |
||||
|
func (l *linkedMap) searchMaxContinued(baseHead uint32) (*qNode, bool) { |
||||
|
var last *qNode |
||||
|
for i := l.head; i != nil; i = i.next { |
||||
|
if last != nil { |
||||
|
if i.seq-last.seq > 1 { |
||||
|
return last, true |
||||
|
} |
||||
|
} else { |
||||
|
if i.seq != baseHead { |
||||
|
return nil, false |
||||
|
} |
||||
|
} |
||||
|
last = i |
||||
|
} |
||||
|
if last != nil { |
||||
|
return last, true |
||||
|
} else { |
||||
|
return nil, false |
||||
|
} |
||||
|
} |
||||
|
*/ |
||||
|
|
||||
|
func (q *qNode) forward(n int) *qNode { |
||||
|
for ; n > 0 && q != nil; n-- { |
||||
|
q = q.next |
||||
|
} |
||||
|
return q |
||||
|
} |
||||
|
|
||||
|
// prev of bitmap start point
|
||||
|
func (l *linkedMap) makeHolesBitmap(prev uint32) ([]uint64, uint32) { |
||||
|
var start *qNode |
||||
|
var bits uint64 |
||||
|
var j uint32 |
||||
|
for i := l.head; i != nil; i = i.next { |
||||
|
if i.seq >= prev+1 { |
||||
|
start = i |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
var bitmap []uint64 |
||||
|
// search start which is the recent successor of [prev]
|
||||
|
Iterator: |
||||
|
for i := start; i != nil; i = i.next { |
||||
|
dis := i.seq - prev |
||||
|
prev = i.seq |
||||
|
j += dis // j is next bit index
|
||||
|
for j >= 65 { |
||||
|
if len(bitmap) >= 20 { // bitmap too long
|
||||
|
break Iterator |
||||
|
} |
||||
|
bitmap = append(bitmap, bits) |
||||
|
bits = 0 |
||||
|
j -= 64 |
||||
|
} |
||||
|
bits |= 1 << (j - 1) |
||||
|
} |
||||
|
if j > 0 { |
||||
|
// j -> (0, 64]
|
||||
|
bitmap = append(bitmap, bits) |
||||
|
} |
||||
|
return bitmap, j |
||||
|
} |
||||
|
|
||||
|
// from= the bitmap start point
|
||||
|
func (l *linkedMap) deleteByBitmap(bmap []uint64, from uint32, tailBitsLen uint32) (deleted, missed int32, lastContinued bool) { |
||||
|
var start = l.qmap[from] |
||||
|
if start != nil { |
||||
|
// delete predecessors
|
||||
|
if pred := start.prev; pred != nil { |
||||
|
_, n := l.deleteBefore(pred) |
||||
|
deleted += n |
||||
|
} |
||||
|
} else { |
||||
|
// [from] is out of bounds
|
||||
|
return |
||||
|
} |
||||
|
var j, bitsLen uint32 |
||||
|
var bits uint64 |
||||
|
bits, bmap = bmap[0], bmap[1:] |
||||
|
if len(bmap) > 0 { |
||||
|
bitsLen = 64 |
||||
|
} else { |
||||
|
// bmap.len==1, tail is here
|
||||
|
bitsLen = tailBitsLen |
||||
|
} |
||||
|
// maxContinued will save the max continued node (from [start]) which could be deleted safely.
|
||||
|
// keep the queue smallest
|
||||
|
var maxContinued *qNode |
||||
|
lastContinued = true |
||||
|
|
||||
|
for i := start; i != nil; j++ { |
||||
|
if j >= bitsLen { |
||||
|
if len(bmap) > 0 { |
||||
|
j = 0 |
||||
|
bits, bmap = bmap[0], bmap[1:] |
||||
|
if len(bmap) > 0 { |
||||
|
bitsLen = 64 |
||||
|
} else { |
||||
|
bitsLen = tailBitsLen |
||||
|
} |
||||
|
} else { |
||||
|
// no more pages
|
||||
|
goto finished |
||||
|
} |
||||
|
} |
||||
|
if bits&1 == 1 { |
||||
|
if lastContinued { |
||||
|
maxContinued = i |
||||
|
} |
||||
|
if i.scnt != _SENT_OK { |
||||
|
// no mark means first deleting
|
||||
|
deleted++ |
||||
|
} |
||||
|
// don't delete, just mark it
|
||||
|
i.scnt = _SENT_OK |
||||
|
} else { |
||||
|
// known it may be lost
|
||||
|
if i.miss == 0 { |
||||
|
missed++ |
||||
|
} |
||||
|
i.miss++ |
||||
|
lastContinued = false |
||||
|
} |
||||
|
bits >>= 1 |
||||
|
i = i.next |
||||
|
} |
||||
|
|
||||
|
finished: |
||||
|
if maxContinued != nil { |
||||
|
l.deleteBefore(maxContinued) |
||||
|
} |
||||
|
return |
||||
|
} |
||||
@ -0,0 +1,236 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"math/rand" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
var lmap *linkedMap |
||||
|
|
||||
|
func init() { |
||||
|
lmap = newLinkedMap(_QModeIn) |
||||
|
} |
||||
|
|
||||
|
func node(seq int) *qNode { |
||||
|
return &qNode{packet: &packet{seq: uint32(seq)}} |
||||
|
} |
||||
|
|
||||
|
func Test_get(t *testing.T) { |
||||
|
var i, n *qNode |
||||
|
assert(!lmap.contains(0), t, "0 nil") |
||||
|
n = node(0) |
||||
|
lmap.head = n |
||||
|
lmap.tail = n |
||||
|
lmap.qmap[0] = n |
||||
|
i = lmap.get(0) |
||||
|
assert(i == n, t, "0=n") |
||||
|
} |
||||
|
|
||||
|
func Test_insert(t *testing.T) { |
||||
|
lmap.reset() |
||||
|
n := node(1) |
||||
|
// appendTail
|
||||
|
lmap.appendTail(n) |
||||
|
assert(lmap.head == n, t, "head n") |
||||
|
assert(lmap.tail == n, t, "head n") |
||||
|
n = node(2) |
||||
|
lmap.appendTail(n) |
||||
|
assert(lmap.head != n, t, "head n") |
||||
|
assert(lmap.tail == n, t, "head n") |
||||
|
assert(lmap.size() == 2, t, "size") |
||||
|
} |
||||
|
|
||||
|
func Test_insertAfter(t *testing.T) { |
||||
|
n1 := lmap.get(1) |
||||
|
n2 := n1.next |
||||
|
n3 := node(3) |
||||
|
lmap.insertAfter(n1, n3) |
||||
|
assert(n1.next == n3, t, "n3") |
||||
|
assert(n1 == n3.prev, t, "left n3") |
||||
|
assert(n2 == n3.next, t, "n3 right") |
||||
|
} |
||||
|
|
||||
|
func Test_insertBefore(t *testing.T) { |
||||
|
n3 := lmap.get(3) |
||||
|
n2 := n3.next |
||||
|
n4 := node(4) |
||||
|
lmap.insertAfter(n3, n4) |
||||
|
assert(n3.next == n4, t, "n4") |
||||
|
assert(n3 == n4.prev, t, "left n4") |
||||
|
assert(n2 == n4.next, t, "n4 right") |
||||
|
} |
||||
|
|
||||
|
func Test_deleteBefore(t *testing.T) { |
||||
|
lmap.reset() |
||||
|
for i := 1; i < 10; i++ { |
||||
|
n := node(i) |
||||
|
lmap.appendTail(n) |
||||
|
} |
||||
|
|
||||
|
var assertRangeEquals = func(n *qNode, start, wantCount int) { |
||||
|
var last *qNode |
||||
|
var count int |
||||
|
for ; n != nil; n = n.next { |
||||
|
assert(int(n.seq) == start, t, "nseq=%d start=%d", n.seq, start) |
||||
|
last = n |
||||
|
start++ |
||||
|
count++ |
||||
|
} |
||||
|
assert(last.next == nil, t, "tail nil") |
||||
|
assert(count == wantCount, t, "count") |
||||
|
} |
||||
|
assertRangeEquals(lmap.head, 1, 9) |
||||
|
var n *qNode |
||||
|
n = lmap.get(3) |
||||
|
n, _ = lmap.deleteBefore(n) |
||||
|
assertRangeEquals(n, 1, 3) |
||||
|
assert(lmap.head.seq == 4, t, "head") |
||||
|
|
||||
|
n = lmap.get(8) |
||||
|
n, _ = lmap.deleteBefore(n) |
||||
|
assertRangeEquals(n, 4, 5) |
||||
|
assert(lmap.head.seq == 9, t, "head") |
||||
|
|
||||
|
n = lmap.get(9) |
||||
|
n, _ = lmap.deleteBefore(n) |
||||
|
assertRangeEquals(n, 9, 1) |
||||
|
|
||||
|
assert(lmap.size() == 0, t, "size 0") |
||||
|
assert(lmap.head == nil, t, "head nil") |
||||
|
assert(lmap.tail == nil, t, "tail nil") |
||||
|
} |
||||
|
|
||||
|
func testBitmap(t *testing.T, bmap []uint64, prev uint32) { |
||||
|
var j uint |
||||
|
var k int |
||||
|
bits := bmap[k] |
||||
|
t.Logf("test-%d %016x", k, bits) |
||||
|
var checkNextPage = func() { |
||||
|
if j >= 64 { |
||||
|
j = 0 |
||||
|
k++ |
||||
|
bits = bmap[k] |
||||
|
t.Logf("test-%d %016x", k, bits) |
||||
|
} |
||||
|
} |
||||
|
for i := lmap.head; i != nil && k < len(bmap); i = i.next { |
||||
|
checkNextPage() |
||||
|
dis := i.seq - prev |
||||
|
prev = i.seq |
||||
|
if dis == 1 { |
||||
|
bit := (bits >> j) & 1 |
||||
|
assert(bit == 1, t, "1 bit=%d j=%d", bit, j) |
||||
|
j++ |
||||
|
} else { |
||||
|
for ; dis > 0; dis-- { |
||||
|
checkNextPage() |
||||
|
bit := (bits >> j) & 1 |
||||
|
want := uint64(0) |
||||
|
if dis == 1 { |
||||
|
want = 1 |
||||
|
} |
||||
|
assert(bit == want, t, "?=%d bit=%d j=%d", want, bit, j) |
||||
|
j++ |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
// remains bits should be 0
|
||||
|
for i := j & 63; i > 0; i-- { |
||||
|
bit := (bits >> j) & 1 |
||||
|
assert(bit == 0, t, "00 bit=%d j=%d", bit, j) |
||||
|
j++ |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func Test_bitmap(t *testing.T) { |
||||
|
var prev uint32 |
||||
|
var head uint32 = prev + 1 |
||||
|
|
||||
|
lmap.reset() |
||||
|
// test 66-%3 and record holes
|
||||
|
var holes = make([]uint32, 0, 50) |
||||
|
for i := head; i < 366; i++ { |
||||
|
if i%3 == 0 { |
||||
|
holes = append(holes, i) |
||||
|
continue |
||||
|
} |
||||
|
n := node(int(i)) |
||||
|
lmap.appendTail(n) |
||||
|
} |
||||
|
bmap, tbl := lmap.makeHolesBitmap(prev) |
||||
|
testBitmap(t, bmap, prev) |
||||
|
|
||||
|
lmap.reset() |
||||
|
// full 66, do deleteByBitmap then compare
|
||||
|
for i := head; i < 366; i++ { |
||||
|
n := node(int(i)) |
||||
|
lmap.appendTail(n) |
||||
|
} |
||||
|
|
||||
|
lmap.deleteByBitmap(bmap, head, tbl) |
||||
|
var holesResult = make([]uint32, 0, 50) |
||||
|
for i := lmap.head; i != nil; i = i.next { |
||||
|
if i.scnt != _SENT_OK { |
||||
|
holesResult = append(holesResult, i.seq) |
||||
|
} |
||||
|
} |
||||
|
a := fmt.Sprintf("%x", holes) |
||||
|
b := fmt.Sprintf("%x", holesResult) |
||||
|
assert(a == b, t, "deleteByBitmap \na=%s \nb=%s", a, b) |
||||
|
|
||||
|
lmap.reset() |
||||
|
// test stride across page 1
|
||||
|
for i := head; i < 69; i++ { |
||||
|
if i >= 63 && i <= 65 { |
||||
|
continue |
||||
|
} |
||||
|
n := node(int(i)) |
||||
|
lmap.appendTail(n) |
||||
|
} |
||||
|
bmap, _ = lmap.makeHolesBitmap(prev) |
||||
|
testBitmap(t, bmap, prev) |
||||
|
|
||||
|
lmap.reset() |
||||
|
prev = 65 |
||||
|
head = prev + 1 |
||||
|
// test stride across page 0
|
||||
|
for i := head; i < 68; i++ { |
||||
|
n := node(int(i)) |
||||
|
lmap.appendTail(n) |
||||
|
} |
||||
|
bmap, _ = lmap.makeHolesBitmap(prev) |
||||
|
testBitmap(t, bmap, prev) |
||||
|
} |
||||
|
|
||||
|
var ackbitmap []uint64 |
||||
|
|
||||
|
func init_benchmark_map() { |
||||
|
if lmap.size() != 640 { |
||||
|
lmap.reset() |
||||
|
for i := 1; i <= 640; i++ { |
||||
|
lmap.appendTail(node(i)) |
||||
|
} |
||||
|
ackbitmap = make([]uint64, 10) |
||||
|
for i := 0; i < len(ackbitmap); i++ { |
||||
|
n := rand.Int63() |
||||
|
ackbitmap[i] = uint64(n) << 1 |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func Benchmark_make_bitmap(b *testing.B) { |
||||
|
init_benchmark_map() |
||||
|
|
||||
|
for i := 0; i < b.N; i++ { |
||||
|
lmap.makeHolesBitmap(0) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func Benchmark_apply_bitmap(b *testing.B) { |
||||
|
init_benchmark_map() |
||||
|
|
||||
|
for i := 0; i < b.N; i++ { |
||||
|
lmap.deleteByBitmap(ackbitmap, 1, 64) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,142 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"encoding/binary" |
||||
|
"fmt" |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_F_NIL = 0 |
||||
|
_F_SYN = 1 |
||||
|
_F_ACK = 1 << 1 |
||||
|
_F_SACK = 1 << 2 |
||||
|
_F_TIME = 1 << 3 |
||||
|
_F_DATA = 1 << 4 |
||||
|
// reserved = 1 << 5
|
||||
|
_F_RESET = 1 << 6 |
||||
|
_F_FIN = 1 << 7 |
||||
|
) |
||||
|
|
||||
|
var packetTypeNames = map[byte]string{ |
||||
|
0: "NOOP", |
||||
|
1: "SYN", |
||||
|
2: "ACK", |
||||
|
3: "SYN+ACK", |
||||
|
4: "SACK", |
||||
|
8: "TIME", |
||||
|
12: "SACK+TIME", |
||||
|
16: "DATA", |
||||
|
64: "RESET", |
||||
|
128: "FIN", |
||||
|
192: "FIN+RESET", |
||||
|
} |
||||
|
|
||||
|
const ( |
||||
|
_S_FIN = iota |
||||
|
_S_FIN0 |
||||
|
_S_FIN1 |
||||
|
_S_SYN0 |
||||
|
_S_SYN1 |
||||
|
_S_EST0 |
||||
|
_S_EST1 |
||||
|
) |
||||
|
|
||||
|
// Magic-6 | TH-10 | CH-10 | payload
|
||||
|
const ( |
||||
|
_MAGIC_SIZE = 6 |
||||
|
_TH_SIZE = 10 + _MAGIC_SIZE |
||||
|
_CH_SIZE = 10 |
||||
|
_AH_SIZE = _TH_SIZE + _CH_SIZE |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
// Max UDP payload: 1500 MTU - 20 IP hdr - 8 UDP hdr = 1472 bytes
|
||||
|
// Then: MSS = 1472-26 = 1446
|
||||
|
// And For ADSL: 1446-8 = 1438
|
||||
|
_MSS = 1438 |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_SENT_OK = 0xff |
||||
|
) |
||||
|
|
||||
|
type packet struct { |
||||
|
seq uint32 |
||||
|
ack uint32 |
||||
|
flag uint8 |
||||
|
scnt uint8 |
||||
|
payload []byte |
||||
|
buffer []byte |
||||
|
} |
||||
|
|
||||
|
func (p *packet) marshall(id connID) []byte { |
||||
|
buf := p.buffer |
||||
|
if buf == nil { |
||||
|
buf = make([]byte, _AH_SIZE+len(p.payload)) |
||||
|
copy(buf[_TH_SIZE+10:], p.payload) |
||||
|
} |
||||
|
binary.BigEndian.PutUint16(buf[_MAGIC_SIZE:], uint16(len(buf))) |
||||
|
binary.BigEndian.PutUint32(buf[_MAGIC_SIZE+2:], id.rid) |
||||
|
binary.BigEndian.PutUint32(buf[_MAGIC_SIZE+6:], id.lid) |
||||
|
binary.BigEndian.PutUint32(buf[_TH_SIZE:], p.seq) |
||||
|
binary.BigEndian.PutUint32(buf[_TH_SIZE+4:], p.ack) |
||||
|
buf[_TH_SIZE+8] = p.flag |
||||
|
buf[_TH_SIZE+9] = p.scnt |
||||
|
return buf |
||||
|
} |
||||
|
|
||||
|
func unmarshall(pk *packet, buf []byte) { |
||||
|
if len(buf) >= _CH_SIZE { |
||||
|
pk.seq = binary.BigEndian.Uint32(buf) |
||||
|
pk.ack = binary.BigEndian.Uint32(buf[4:]) |
||||
|
pk.flag = buf[8] |
||||
|
pk.scnt = buf[9] |
||||
|
pk.payload = buf[10:] |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (n *qNode) String() string { |
||||
|
now := Now() |
||||
|
return fmt.Sprintf("type=%s seq=%d scnt=%d sndtime~=%d,%d miss=%d", |
||||
|
packetTypeNames[n.flag], n.seq, n.scnt, n.sent-now, n.sent_1-now, n.miss) |
||||
|
} |
||||
|
|
||||
|
func maxI64(a, b int64) int64 { |
||||
|
if a >= b { |
||||
|
return a |
||||
|
} else { |
||||
|
return b |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func maxU32(a, b uint32) uint32 { |
||||
|
if a >= b { |
||||
|
return a |
||||
|
} else { |
||||
|
return b |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func minI64(a, b int64) int64 { |
||||
|
if a <= b { |
||||
|
return a |
||||
|
} else { |
||||
|
return b |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func maxI32(a, b int32) int32 { |
||||
|
if a >= b { |
||||
|
return a |
||||
|
} else { |
||||
|
return b |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func minI32(a, b int32) int32 { |
||||
|
if a <= b { |
||||
|
return a |
||||
|
} else { |
||||
|
return b |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,516 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"errors" |
||||
|
"log" |
||||
|
"net" |
||||
|
"sync" |
||||
|
"sync/atomic" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_10ms = time.Millisecond * 10 |
||||
|
_100ms = time.Millisecond * 100 |
||||
|
) |
||||
|
|
||||
|
const ( |
||||
|
_FIN_ACK_SEQ uint32 = 0xffFF0000 |
||||
|
_INVALID_SEQ uint32 = 0xffFFffFF |
||||
|
) |
||||
|
|
||||
|
var ( |
||||
|
ErrIOTimeout error = &TimeoutError{} |
||||
|
ErrUnknown = errors.New("Unknown error") |
||||
|
ErrInexplicableData = errors.New("Inexplicable data") |
||||
|
ErrTooManyAttempts = errors.New("Too many attempts to connect") |
||||
|
) |
||||
|
|
||||
|
type TimeoutError struct{} |
||||
|
|
||||
|
func (e *TimeoutError) Error() string { return "i/o timeout" } |
||||
|
func (e *TimeoutError) Timeout() bool { return true } |
||||
|
func (e *TimeoutError) Temporary() bool { return true } |
||||
|
|
||||
|
type Conn struct { |
||||
|
sock *net.UDPConn |
||||
|
dest *net.UDPAddr |
||||
|
edp *Endpoint |
||||
|
connID connID // 8 bytes
|
||||
|
// events
|
||||
|
evRecv chan []byte |
||||
|
evRead chan byte |
||||
|
evSend chan byte |
||||
|
evSWnd chan byte |
||||
|
evAck chan byte |
||||
|
evClose chan byte |
||||
|
// protocol state
|
||||
|
inlock sync.Mutex |
||||
|
outlock sync.Mutex |
||||
|
state int32 |
||||
|
mySeq uint32 |
||||
|
swnd int32 |
||||
|
cwnd int32 |
||||
|
missed int32 |
||||
|
outPending int32 |
||||
|
lastAck uint32 |
||||
|
lastAckTime int64 |
||||
|
lastAckTime2 int64 |
||||
|
lastShrink int64 |
||||
|
lastRstMis int64 |
||||
|
ato int64 |
||||
|
rto int64 |
||||
|
rtt int64 |
||||
|
srtt int64 |
||||
|
mdev int64 |
||||
|
rtmo int64 |
||||
|
wtmo int64 |
||||
|
tSlot int64 |
||||
|
tSlotT0 int64 |
||||
|
lastSErr int64 |
||||
|
// queue
|
||||
|
outQ *linkedMap |
||||
|
inQ *linkedMap |
||||
|
inQReady []byte |
||||
|
inQDirty bool |
||||
|
lastReadSeq uint32 // last user read seq
|
||||
|
// params
|
||||
|
bandwidth int64 |
||||
|
fastRetransmit bool |
||||
|
flatTraffic bool |
||||
|
mss int |
||||
|
// statistics
|
||||
|
urgent int |
||||
|
inPkCnt int |
||||
|
inDupCnt int |
||||
|
outPkCnt int |
||||
|
outDupCnt int |
||||
|
fRCnt int |
||||
|
} |
||||
|
|
||||
|
func NewConn(e *Endpoint, dest *net.UDPAddr, id connID) *Conn { |
||||
|
c := &Conn{ |
||||
|
sock: e.udpconn, |
||||
|
dest: dest, |
||||
|
edp: e, |
||||
|
connID: id, |
||||
|
evRecv: make(chan []byte, 128), |
||||
|
evRead: make(chan byte, 1), |
||||
|
evSWnd: make(chan byte, 2), |
||||
|
evSend: make(chan byte, 4), |
||||
|
evAck: make(chan byte, 1), |
||||
|
evClose: make(chan byte, 2), |
||||
|
outQ: newLinkedMap(_QModeOut), |
||||
|
inQ: newLinkedMap(_QModeIn), |
||||
|
} |
||||
|
p := e.params |
||||
|
c.bandwidth = p.Bandwidth |
||||
|
c.fastRetransmit = p.FastRetransmit |
||||
|
c.flatTraffic = p.FlatTraffic |
||||
|
c.mss = _MSS |
||||
|
if dest.IP.To4() == nil { |
||||
|
// typical ipv6 header length=40
|
||||
|
c.mss -= 20 |
||||
|
} |
||||
|
return c |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) initConnection(buf []byte) (err error) { |
||||
|
if buf == nil { |
||||
|
err = c.initDialing() |
||||
|
} else { //server
|
||||
|
err = c.acceptConnection(buf[_TH_SIZE:]) |
||||
|
} |
||||
|
if err != nil { |
||||
|
return |
||||
|
} |
||||
|
if c.state == _S_EST1 { |
||||
|
c.lastReadSeq = c.lastAck |
||||
|
c.inQ.maxCtnSeq = c.lastAck |
||||
|
c.rtt = maxI64(c.rtt, _MIN_RTT) |
||||
|
c.mdev = c.rtt << 1 |
||||
|
c.srtt = c.rtt << 3 |
||||
|
c.rto = maxI64(c.rtt*2, _MIN_RTO) |
||||
|
c.ato = maxI64(c.rtt>>4, _MIN_ATO) |
||||
|
c.ato = minI64(c.ato, _MAX_ATO) |
||||
|
// initial cwnd
|
||||
|
c.swnd = calSwnd(c.bandwidth, c.rtt) >> 1 |
||||
|
c.cwnd = 8 |
||||
|
go c.internalRecvLoop() |
||||
|
go c.internalSendLoop() |
||||
|
go c.internalAckLoop() |
||||
|
if debug >= 0 { |
||||
|
go c.internal_state() |
||||
|
} |
||||
|
return nil |
||||
|
} else { |
||||
|
return ErrUnknown |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) initDialing() error { |
||||
|
// first syn
|
||||
|
pk := &packet{ |
||||
|
seq: c.mySeq, |
||||
|
flag: _F_SYN, |
||||
|
} |
||||
|
item := nodeOf(pk) |
||||
|
var buf []byte |
||||
|
c.state = _S_SYN0 |
||||
|
t0 := Now() |
||||
|
for i := 0; i < _MAX_RETRIES && c.state == _S_SYN0; i++ { |
||||
|
// send syn
|
||||
|
c.internalWrite(item) |
||||
|
select { |
||||
|
case buf = <-c.evRecv: |
||||
|
c.rtt = Now() - t0 |
||||
|
c.state = _S_SYN1 |
||||
|
c.connID.setRid(buf) |
||||
|
buf = buf[_TH_SIZE:] |
||||
|
case <-time.After(time.Second): |
||||
|
continue |
||||
|
} |
||||
|
} |
||||
|
if c.state == _S_SYN0 { |
||||
|
return ErrTooManyAttempts |
||||
|
} |
||||
|
|
||||
|
unmarshall(pk, buf) |
||||
|
// expected syn+ack
|
||||
|
if pk.flag == _F_SYN|_F_ACK && pk.ack == c.mySeq { |
||||
|
if scnt := pk.scnt - 1; scnt > 0 { |
||||
|
c.rtt -= int64(scnt) * 1e3 |
||||
|
} |
||||
|
log.Println("rtt", c.rtt) |
||||
|
c.state = _S_EST0 |
||||
|
// build ack3
|
||||
|
pk.scnt = 0 |
||||
|
pk.ack = pk.seq |
||||
|
pk.flag = _F_ACK |
||||
|
item := nodeOf(pk) |
||||
|
// send ack3
|
||||
|
c.internalWrite(item) |
||||
|
// update lastAck
|
||||
|
c.logAck(pk.ack) |
||||
|
c.state = _S_EST1 |
||||
|
return nil |
||||
|
} else { |
||||
|
return ErrInexplicableData |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) acceptConnection(buf []byte) error { |
||||
|
var pk = new(packet) |
||||
|
var item *qNode |
||||
|
unmarshall(pk, buf) |
||||
|
// expected syn
|
||||
|
if pk.flag == _F_SYN { |
||||
|
c.state = _S_SYN1 |
||||
|
// build syn+ack
|
||||
|
pk.ack = pk.seq |
||||
|
pk.seq = c.mySeq |
||||
|
pk.flag |= _F_ACK |
||||
|
// update lastAck
|
||||
|
c.logAck(pk.ack) |
||||
|
item = nodeOf(pk) |
||||
|
item.scnt = pk.scnt - 1 |
||||
|
} else { |
||||
|
dumpb("Syn1 ?", buf) |
||||
|
return ErrInexplicableData |
||||
|
} |
||||
|
for i := 0; i < 5 && c.state == _S_SYN1; i++ { |
||||
|
t0 := Now() |
||||
|
// reply syn+ack
|
||||
|
c.internalWrite(item) |
||||
|
// recv ack3
|
||||
|
select { |
||||
|
case buf = <-c.evRecv: |
||||
|
c.state = _S_EST0 |
||||
|
c.rtt = Now() - t0 |
||||
|
buf = buf[_TH_SIZE:] |
||||
|
log.Println("rtt", c.rtt) |
||||
|
case <-time.After(time.Second): |
||||
|
continue |
||||
|
} |
||||
|
} |
||||
|
if c.state == _S_SYN1 { |
||||
|
return ErrTooManyAttempts |
||||
|
} |
||||
|
|
||||
|
pk = new(packet) |
||||
|
unmarshall(pk, buf) |
||||
|
// expected ack3
|
||||
|
if pk.flag == _F_ACK && pk.ack == c.mySeq { |
||||
|
c.state = _S_EST1 |
||||
|
} else { |
||||
|
// if ack3 lost, resend syn+ack 3-times
|
||||
|
// and drop these coming data
|
||||
|
if pk.flag&_F_DATA != 0 && pk.seq > c.lastAck { |
||||
|
c.internalWrite(item) |
||||
|
c.state = _S_EST1 |
||||
|
} else { |
||||
|
dumpb("Ack3 ?", buf) |
||||
|
return ErrInexplicableData |
||||
|
} |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// 20,20,20,20, 100,100,100,100, 1s,1s,1s,1s
|
||||
|
func selfSpinWait(fn func() bool) error { |
||||
|
const _MAX_SPIN = 12 |
||||
|
for i := 0; i < _MAX_SPIN; i++ { |
||||
|
if fn() { |
||||
|
return nil |
||||
|
} else if i <= 3 { |
||||
|
time.Sleep(_10ms * 2) |
||||
|
} else if i <= 7 { |
||||
|
time.Sleep(_100ms) |
||||
|
} else { |
||||
|
time.Sleep(time.Second) |
||||
|
} |
||||
|
} |
||||
|
return ErrIOTimeout |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) IsClosed() bool { |
||||
|
return atomic.LoadInt32(&c.state) <= _S_FIN1 |
||||
|
} |
||||
|
|
||||
|
/* |
||||
|
active close: |
||||
|
1 <- send fin-W: closeW() |
||||
|
before sending, ensure all outQ items has beed sent out and all of them has been acked. |
||||
|
2 -> wait to recv ack{fin-W} |
||||
|
then trigger closeR, including send fin-R and wait to recv ack{fin-R} |
||||
|
|
||||
|
passive close: |
||||
|
-> fin: |
||||
|
if outQ is not empty then self-spin wait. |
||||
|
if outQ empty, send ack{fin-W} then goto closeW(). |
||||
|
*/ |
||||
|
func (c *Conn) Close() (err error) { |
||||
|
if !atomic.CompareAndSwapInt32(&c.state, _S_EST1, _S_FIN0) { |
||||
|
return selfSpinWait(func() bool { |
||||
|
return atomic.LoadInt32(&c.state) == _S_FIN |
||||
|
}) |
||||
|
} |
||||
|
var err0 error |
||||
|
err0 = c.closeW() |
||||
|
// waiting for fin-2 of peer
|
||||
|
err = selfSpinWait(func() bool { |
||||
|
select { |
||||
|
case v := <-c.evClose: |
||||
|
if v == _S_FIN { |
||||
|
return true |
||||
|
} else { |
||||
|
time.AfterFunc(_100ms, func() { c.evClose <- v }) |
||||
|
} |
||||
|
default: |
||||
|
} |
||||
|
return false |
||||
|
}) |
||||
|
defer c.afterShutdown() |
||||
|
if err != nil { |
||||
|
// backup path for wait ack(finW) timeout
|
||||
|
c.closeR(nil) |
||||
|
} |
||||
|
if err0 != nil { |
||||
|
return err0 |
||||
|
} else { |
||||
|
return |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) beforeCloseW() (err error) { |
||||
|
// check outQ was empty and all has been acked.
|
||||
|
// self-spin waiting
|
||||
|
for i := 0; i < 2; i++ { |
||||
|
err = selfSpinWait(func() bool { |
||||
|
return atomic.LoadInt32(&c.outPending) <= 0 |
||||
|
}) |
||||
|
if err == nil { |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
// send fin, reliably
|
||||
|
c.outlock.Lock() |
||||
|
c.mySeq++ |
||||
|
c.outPending++ |
||||
|
pk := &packet{seq: c.mySeq, flag: _F_FIN} |
||||
|
item := nodeOf(pk) |
||||
|
c.outQ.appendTail(item) |
||||
|
c.internalWrite(item) |
||||
|
c.outlock.Unlock() |
||||
|
c.evSWnd <- _VSWND_ACTIVE |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) closeW() (err error) { |
||||
|
// close resource of sending
|
||||
|
defer c.afterCloseW() |
||||
|
// send fin
|
||||
|
err = c.beforeCloseW() |
||||
|
var closed bool |
||||
|
var max = 20 |
||||
|
if c.rtt > 200 { |
||||
|
max = int(c.rtt) / 10 |
||||
|
} |
||||
|
// waiting for outQ means:
|
||||
|
// 1. all outQ has been acked, for passive
|
||||
|
// 2. fin has been acked, for active
|
||||
|
for i := 0; i < max && (atomic.LoadInt32(&c.outPending) > 0 || !closed); i++ { |
||||
|
select { |
||||
|
case v := <-c.evClose: |
||||
|
if v == _S_FIN0 { |
||||
|
// namely, last fin has been acked.
|
||||
|
closed = true |
||||
|
} else { |
||||
|
time.AfterFunc(_100ms, func() { c.evClose <- v }) |
||||
|
} |
||||
|
case <-time.After(_100ms): |
||||
|
} |
||||
|
} |
||||
|
if closed || err != nil { |
||||
|
return |
||||
|
} else { |
||||
|
return ErrIOTimeout |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) afterCloseW() { |
||||
|
// can't close(c.evRecv), avoid endpoint dispatch exception
|
||||
|
// stop pending inputAndSend
|
||||
|
select { |
||||
|
case c.evSend <- _CLOSE: |
||||
|
default: |
||||
|
} |
||||
|
// stop internalSendLoop
|
||||
|
c.evSWnd <- _CLOSE |
||||
|
} |
||||
|
|
||||
|
// called by active and passive close()
|
||||
|
func (c *Conn) afterShutdown() { |
||||
|
// stop internalRecvLoop
|
||||
|
c.evRecv <- nil |
||||
|
// remove registry
|
||||
|
c.edp.removeConn(c.connID, c.dest) |
||||
|
log.Println("shutdown", c.state) |
||||
|
} |
||||
|
|
||||
|
// trigger by reset
|
||||
|
func (c *Conn) forceShutdownWithLock() { |
||||
|
c.outlock.Lock() |
||||
|
defer c.outlock.Unlock() |
||||
|
c.forceShutdown() |
||||
|
} |
||||
|
|
||||
|
// called by:
|
||||
|
// 1/ send exception
|
||||
|
// 2/ recv reset
|
||||
|
// drop outQ and force shutdown
|
||||
|
func (c *Conn) forceShutdown() { |
||||
|
if atomic.CompareAndSwapInt32(&c.state, _S_EST1, _S_FIN) { |
||||
|
defer c.afterShutdown() |
||||
|
// stop sender
|
||||
|
for i := 0; i < cap(c.evSend); i++ { |
||||
|
select { |
||||
|
case <-c.evSend: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
select { |
||||
|
case c.evSend <- _CLOSE: |
||||
|
default: |
||||
|
} |
||||
|
c.outQ.reset() |
||||
|
// stop reader
|
||||
|
close(c.evRead) |
||||
|
c.inQ.reset() |
||||
|
// stop internalLoops
|
||||
|
c.evSWnd <- _CLOSE |
||||
|
c.evAck <- _CLOSE |
||||
|
//log.Println("force shutdown")
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// for sending fin failed
|
||||
|
func (c *Conn) fakeShutdown() { |
||||
|
select { |
||||
|
case c.evClose <- _S_FIN0: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) closeR(pk *packet) { |
||||
|
var passive = true |
||||
|
for { |
||||
|
state := atomic.LoadInt32(&c.state) |
||||
|
switch state { |
||||
|
case _S_FIN: |
||||
|
return |
||||
|
case _S_FIN1: // multiple FIN, maybe lost
|
||||
|
c.passiveCloseReply(pk, false) |
||||
|
return |
||||
|
case _S_FIN0: // active close preformed
|
||||
|
passive = false |
||||
|
} |
||||
|
if !atomic.CompareAndSwapInt32(&c.state, state, _S_FIN1) { |
||||
|
continue |
||||
|
} |
||||
|
c.passiveCloseReply(pk, true) |
||||
|
break |
||||
|
} |
||||
|
// here, R is closed.
|
||||
|
// ^^^^^^^^^^^^^^^^^^^^^
|
||||
|
if passive { |
||||
|
// passive closing call closeW contains sending fin and recv ack
|
||||
|
// may the ack of fin-2 was lost, then the closeW will timeout
|
||||
|
c.closeW() |
||||
|
} |
||||
|
// here, R,W both were closed.
|
||||
|
// ^^^^^^^^^^^^^^^^^^^^^
|
||||
|
atomic.StoreInt32(&c.state, _S_FIN) |
||||
|
// stop internalAckLoop
|
||||
|
c.evAck <- _CLOSE |
||||
|
|
||||
|
if passive { |
||||
|
// close evRecv within here
|
||||
|
c.afterShutdown() |
||||
|
} else { |
||||
|
// notify active close thread
|
||||
|
select { |
||||
|
case c.evClose <- _S_FIN: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (c *Conn) passiveCloseReply(pk *packet, first bool) { |
||||
|
if pk != nil && pk.flag&_F_FIN != 0 { |
||||
|
if first { |
||||
|
c.checkInQ(pk) |
||||
|
close(c.evRead) |
||||
|
} |
||||
|
// ack the FIN
|
||||
|
pk = &packet{seq: _FIN_ACK_SEQ, ack: pk.seq, flag: _F_ACK} |
||||
|
item := nodeOf(pk) |
||||
|
c.internalWrite(item) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// check inQ ends orderly, and copy queue data to user space
|
||||
|
func (c *Conn) checkInQ(pk *packet) { |
||||
|
if nil != selfSpinWait(func() bool { |
||||
|
return c.inQ.maxCtnSeq+1 == pk.seq |
||||
|
}) { // timeout for waiting inQ to finish
|
||||
|
return |
||||
|
} |
||||
|
c.inlock.Lock() |
||||
|
defer c.inlock.Unlock() |
||||
|
if c.inQ.size() > 0 { |
||||
|
for i := c.inQ.head; i != nil; i = i.next { |
||||
|
c.inQReady = append(c.inQReady, i.payload...) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,36 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"os" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
type watch struct { |
||||
|
label string |
||||
|
t1 time.Time |
||||
|
} |
||||
|
|
||||
|
func StartWatch(s string) *watch { |
||||
|
return &watch{ |
||||
|
label: s, |
||||
|
t1: time.Now(), |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (w *watch) StopLoops(loop int, size int) { |
||||
|
tu := time.Now().Sub(w.t1).Nanoseconds() |
||||
|
timePerLoop := float64(tu) / float64(loop) |
||||
|
throughput := float64(loop*size) * 1e6 / float64(tu) |
||||
|
tu_ms := float64(tu) / 1e6 |
||||
|
fmt.Fprintf(os.Stderr, "%s tu=%.2f ms tpl=%.0f ns throughput=%.2f K/s\n", w.label, tu_ms, timePerLoop, throughput) |
||||
|
} |
||||
|
|
||||
|
var _kt = float64(1e9 / 1024) |
||||
|
|
||||
|
func (w *watch) Stop(size int) { |
||||
|
tu := time.Now().Sub(w.t1).Nanoseconds() |
||||
|
throughput := float64(size) * _kt / float64(tu) |
||||
|
tu_ms := float64(tu) / 1e6 |
||||
|
fmt.Fprintf(os.Stderr, "%s tu=%.2f ms throughput=%.2f K/s\n", w.label, tu_ms, throughput) |
||||
|
} |
||||
@ -0,0 +1,18 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import "time" |
||||
|
|
||||
|
const Millisecond = 1e6 |
||||
|
|
||||
|
func Now() int64 { |
||||
|
return time.Now().UnixNano()/Millisecond |
||||
|
} |
||||
|
|
||||
|
func NowNS() int64 { |
||||
|
return time.Now().UnixNano() |
||||
|
} |
||||
|
|
||||
|
func NewTimerChan(d int64) <-chan time.Time { |
||||
|
ticker := time.NewTimer(time.Duration(d) * time.Millisecond) |
||||
|
return ticker.C |
||||
|
} |
||||
@ -0,0 +1,32 @@ |
|||||
|
package udptransfer |
||||
|
|
||||
|
import ( |
||||
|
"math" |
||||
|
"testing" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
func Test_sleep(t *testing.T) { |
||||
|
const loops = 10 |
||||
|
var intervals = [...]int64{1, 1e3, 1e4, 1e5, 1e6, 1e7} |
||||
|
var ret [len(intervals)][loops]int64 |
||||
|
for j := 0; j < len(intervals); j++ { |
||||
|
v := time.Duration(intervals[j]) |
||||
|
for i := 0; i < loops; i++ { |
||||
|
t0 := NowNS() |
||||
|
time.Sleep(v) |
||||
|
ret[j][i] = NowNS() - t0 |
||||
|
} |
||||
|
} |
||||
|
for j := 0; j < len(intervals); j++ { |
||||
|
var exp, sum, stdev float64 |
||||
|
exp = float64(intervals[j]) |
||||
|
for _, v := range ret[j] { |
||||
|
sum += float64(v) |
||||
|
stdev += math.Pow(float64(v)-exp, 2) |
||||
|
} |
||||
|
stdev /= float64(loops) |
||||
|
stdev = math.Sqrt(stdev) |
||||
|
t.Logf("interval=%s sleeping=%s stdev/k=%.2f", time.Duration(intervals[j]), time.Duration(sum/loops), stdev/1e3) |
||||
|
} |
||||
|
} |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue