mirror of
https://github.com/jech/galene.git
synced 2024-12-23 07:45:46 +01:00
94c42ea784
Also add a test.
261 lines
5 KiB
Go
261 lines
5 KiB
Go
package packetcache
|
|
|
|
import (
|
|
"sync"
|
|
)
|
|
|
|
const BufSize = 1500
|
|
|
|
type entry struct {
|
|
seqno uint16
|
|
length uint16
|
|
buf [BufSize]byte
|
|
}
|
|
|
|
type Cache struct {
|
|
mu sync.Mutex
|
|
//stats
|
|
last uint16
|
|
cycle uint16
|
|
lastValid bool
|
|
expected uint32
|
|
lost uint32
|
|
totalLost uint32
|
|
// bitmap
|
|
first uint16
|
|
bitmap uint32
|
|
// packet cache
|
|
tail uint16
|
|
entries []entry
|
|
}
|
|
|
|
func New(capacity int) *Cache {
|
|
if capacity > int(^uint16(0)) {
|
|
return nil
|
|
}
|
|
return &Cache{
|
|
entries: make([]entry, capacity),
|
|
}
|
|
}
|
|
|
|
func seqnoInvalid(seqno, reference uint16) bool {
|
|
if ((seqno - reference) & 0x8000) == 0 {
|
|
return false
|
|
}
|
|
|
|
if reference-seqno > 0x100 {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// Set a bit in the bitmap, shifting first if necessary.
|
|
func (cache *Cache) set(seqno uint16) {
|
|
if cache.bitmap == 0 || seqnoInvalid(seqno, cache.first) {
|
|
cache.first = seqno
|
|
cache.bitmap = 1
|
|
return
|
|
}
|
|
|
|
if ((seqno - cache.first) & 0x8000) != 0 {
|
|
return
|
|
}
|
|
|
|
if seqno-cache.first < 32 {
|
|
cache.bitmap |= (1 << uint16(seqno-cache.first))
|
|
return
|
|
}
|
|
|
|
shift := seqno - cache.first - 31
|
|
cache.bitmap >>= shift
|
|
cache.first += shift
|
|
cache.bitmap |= (1 << uint16(seqno-cache.first))
|
|
return
|
|
}
|
|
|
|
// Store a packet, setting bitmap at the same time
|
|
func (cache *Cache) Store(seqno uint16, buf []byte) (uint16, uint16) {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
if !cache.lastValid || seqnoInvalid(seqno, cache.last) {
|
|
cache.last = seqno
|
|
cache.lastValid = true
|
|
cache.expected++
|
|
} else {
|
|
if ((cache.last - seqno) & 0x8000) != 0 {
|
|
cache.expected += uint32(seqno - cache.last)
|
|
cache.lost += uint32(seqno - cache.last - 1)
|
|
if seqno < cache.last {
|
|
cache.cycle++
|
|
}
|
|
cache.last = seqno
|
|
} else {
|
|
if cache.lost > 0 {
|
|
cache.lost--
|
|
}
|
|
}
|
|
}
|
|
|
|
cache.set(seqno)
|
|
|
|
i := cache.tail
|
|
cache.entries[i].seqno = seqno
|
|
copy(cache.entries[i].buf[:], buf)
|
|
cache.entries[i].length = uint16(len(buf))
|
|
cache.tail = (i + 1) % uint16(len(cache.entries))
|
|
|
|
return cache.first, i
|
|
}
|
|
|
|
func (cache *Cache) Expect(n int) {
|
|
if n <= 0 {
|
|
return
|
|
}
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
cache.expected += uint32(n)
|
|
}
|
|
|
|
func (cache *Cache) Get(seqno uint16, result []byte) uint16 {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
for i := range cache.entries {
|
|
if cache.entries[i].length == 0 ||
|
|
cache.entries[i].seqno != seqno {
|
|
continue
|
|
}
|
|
return uint16(copy(
|
|
result[:cache.entries[i].length],
|
|
cache.entries[i].buf[:]),
|
|
)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (cache *Cache) GetLast(result []byte) uint16 {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
i := cache.tail - 1
|
|
if i >= uint16(len(cache.entries)) {
|
|
i = 0
|
|
}
|
|
|
|
return uint16(copy(
|
|
result[:cache.entries[i].length],
|
|
cache.entries[i].buf[:]),
|
|
)
|
|
}
|
|
|
|
func (cache *Cache) GetAt(seqno uint16, index uint16, result []byte) uint16 {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
if int(index) > len(cache.entries) {
|
|
return 0
|
|
}
|
|
if cache.entries[index].seqno != seqno {
|
|
return 0
|
|
}
|
|
return uint16(copy(
|
|
result[:cache.entries[index].length],
|
|
cache.entries[index].buf[:]),
|
|
)
|
|
}
|
|
|
|
func (cache *Cache) resize(capacity int) {
|
|
if len(cache.entries) == capacity {
|
|
return
|
|
}
|
|
|
|
entries := make([]entry, capacity)
|
|
|
|
if capacity > len(cache.entries) {
|
|
copy(entries, cache.entries[:cache.tail])
|
|
copy(entries[int(cache.tail)+capacity-len(cache.entries):],
|
|
cache.entries[cache.tail:])
|
|
} else if capacity > int(cache.tail) {
|
|
copy(entries, cache.entries[:cache.tail])
|
|
copy(entries[cache.tail:],
|
|
cache.entries[int(cache.tail)+
|
|
len(cache.entries)-capacity:])
|
|
} else {
|
|
// too bad, invalidate all indices
|
|
copy(entries,
|
|
cache.entries[int(cache.tail)-capacity:cache.tail])
|
|
cache.tail = 0
|
|
}
|
|
cache.entries = entries
|
|
}
|
|
|
|
func (cache *Cache) Resize(capacity int) {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
cache.resize(capacity)
|
|
}
|
|
|
|
func (cache *Cache) ResizeCond(capacity int) bool {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
current := len(cache.entries)
|
|
|
|
if current >= capacity*3/4 && current < capacity*2 {
|
|
return false
|
|
}
|
|
|
|
if capacity < current {
|
|
if int(cache.tail) > capacity {
|
|
// this would invalidate too many indices
|
|
return false
|
|
}
|
|
}
|
|
|
|
cache.resize(capacity)
|
|
return true
|
|
}
|
|
|
|
// Shift 17 bits out of the bitmap. Return a boolean indicating if any
|
|
// were 0, the index of the first 0 bit, and a bitmap indicating any
|
|
// 0 bits after the first one.
|
|
func (cache *Cache) BitmapGet() (bool, uint16, uint16) {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
first := cache.first
|
|
bitmap := (^cache.bitmap) & 0x1FFFF
|
|
cache.bitmap >>= 17
|
|
cache.first += 17
|
|
|
|
if bitmap == 0 {
|
|
return false, first, 0
|
|
}
|
|
|
|
for bitmap&1 == 0 {
|
|
bitmap >>= 1
|
|
first++
|
|
}
|
|
|
|
return true, first, uint16(bitmap >> 1)
|
|
}
|
|
|
|
func (cache *Cache) GetStats(reset bool) (uint32, uint32, uint32, uint32) {
|
|
cache.mu.Lock()
|
|
defer cache.mu.Unlock()
|
|
|
|
expected := cache.expected
|
|
lost := cache.lost
|
|
totalLost := cache.totalLost + cache.lost
|
|
eseqno := uint32(cache.cycle)<<16 | uint32(cache.last)
|
|
|
|
if reset {
|
|
cache.expected = 0
|
|
cache.totalLost += cache.lost
|
|
cache.lost = 0
|
|
}
|
|
return expected, lost, totalLost, eseqno
|
|
}
|