update circular buffer

Author: hadv

utils/circularbuff/circularbuff.go

@@ -1,26 +1,23 @@
 package circularbuff
 
 import (
-	"container/list"
 	"errors"
 )
 
 // EvictCallback is used to get a callback when a cache entry is evicted
 type EvictCallback func(key interface{}, value interface{})
 
+type key interface{}
+type value interface{}
+
 // Cache implements a non-thread safe fixed size circular cache
 // Once max size is reached, every subsequent writing would overwrite oldest element
 type Cache struct {
-	maxSize   int
-	evictList *list.List
-	items     map[interface{}]*list.Element
-	onEvict   EvictCallback
-}
-
-// entry is used to hold a value in the evictList
-type entry struct {
-	key   interface{}
-	value interface{}
+	maxSize int
+	next    int
+	buf     []key
+	items   map[key]value
+	onEvict EvictCallback
 }
 
 // New creates a circular cache of the given size.
@@ -34,118 +31,69 @@ func NewWithEvict(maxSize int, onEvict EvictCallback) (*Cache, error) {
 		return nil, errors.New("must provide a non-negative size")
 	}
 	c := &Cache{
-		maxSize:   maxSize,
-		evictList: list.New(),
-		items:     make(map[interface{}]*list.Element),
-		onEvict:   onEvict,
+		maxSize: maxSize,
+		next:    0,
+		buf:     make([]key, maxSize),
+		items:   make(map[key]value),
+		onEvict: onEvict,
 	}
 	return c, nil
 }
 
 // Purge is used to completely clear the cache.
 func (c *Cache) Purge() {
-	for k, v := range c.items {
-		e := v.Value.(*entry)
-		if c.onEvict != nil {
-			c.onEvict(k, e.value)
-		}
+	for k, _ := range c.items {
 		delete(c.items, k)
 	}
-	c.evictList.Init()
+
+	// reset cache
+	c.buf = make([]key, c.maxSize)
+	c.next = 0
 }
 
 // Add adds a value to the cache. Returns true if an eviction occurred.
 func (c *Cache) Add(key, value interface{}) (evicted bool) {
 	// Check for existing item
-	if ent, ok := c.items[key]; ok {
-		c.evictList.MoveToFront(ent)
-		existing := ent.Value.(*entry)
-		existing.value = value
-		return false
+	evicted = false
+	if c.buf[c.next] == key {
+		v, _ := c.items[key]
+		if c.onEvict != nil {
+			c.onEvict(key, v)
+			evicted = true
+		}
 	}
 
-	// Add new item
-	ent := &entry{key, value}
-	if c.Len() >= c.maxSize {
-		c.removeOldest()
-		entry := c.evictList.PushBack(ent)
-		c.items[key] = entry
-		return true
-	}
-	entry := c.evictList.PushFront(ent)
-	c.items[key] = entry
-	return false
+	delete(c.items, c.buf[c.next]) // delete old key in the map if any
+	c.buf[c.next] = key
+	c.items[key] = value
+	c.next = (c.next + 1) % c.maxSize
+	return evicted
 }
 
 // Get looks up a key's value from the cache.
-func (c *Cache) Get(key interface{}) (value interface{}, ok bool) {
-	if ent, ok := c.items[key]; ok {
-		c.evictList.MoveToFront(ent)
-		if ent.Value.(*entry) == nil {
+func (c *Cache) Get(key interface{}) (interface{}, bool) {
+	if value, ok := c.items[key]; ok {
+		if value == nil {
 			return nil, false
 		}
-		return ent.Value.(*entry).value, true
+		return value, ok
 	}
-	return
+	return nil, false
 }
 
 // Contains checks if a key is in the cache, without updating the recent-ness
 // or deleting it for being stale.
-func (c *Cache) Contains(key interface{}) (ok bool) {
-	_, ok = c.items[key]
+func (c *Cache) Contains(key interface{}) bool {
+	_, ok := c.items[key]
 	return ok
 }
 
-// Peek returns the key value (or undefined if not found) without updating
-// the "recently used"-ness of the key.
-func (c *Cache) Peek(key interface{}) (value interface{}, ok bool) {
-	var ent *list.Element
-	if ent, ok = c.items[key]; ok {
-		return ent.Value.(*entry).value, true
-	}
-	return nil, ok
-}
-
 // Remove removes the provided key from the cache, returning if the
 // key was contained.
-func (c *Cache) Remove(key interface{}) (present bool) {
-	if ent, ok := c.items[key]; ok {
-		c.removeElement(ent)
+func (c *Cache) Remove(key interface{}) bool {
+	if _, ok := c.items[key]; ok {
+		delete(c.items, key)
 		return true
 	}
 	return false
 }
-
-// Keys returns a slice of the keys in the cache, from oldest to newest.
-func (c *Cache) Keys() []interface{} {
-	keys := make([]interface{}, len(c.items))
-	i := 0
-	for ent := c.evictList.Back(); ent != nil; ent = ent.Prev() {
-		keys[i] = ent.Value.(*entry).key
-		i++
-	}
-	return keys
-}
-
-// Len returns the number of items in the cache.
-func (c *Cache) Len() int {
-	return c.evictList.Len()
-}
-
-// removeOldest removes the oldest item from the cache.
-func (c *Cache) removeOldest() {
-	ent := c.evictList.Back()
-	if ent != nil {
-		c.removeElement(ent)
-	}
-}
-
-// removeElement is used to remove a given list element from the cache
-func (c *Cache) removeElement(e *list.Element) {
-	c.evictList.Remove(e)
-	kv := e.Value.(*entry)
-	delete(c.items, kv.key)
-	if c.onEvict != nil {
-		c.onEvict(kv.key, kv.value)
-	}
-}

utils/circularbuff/circularbuff_test.go

@@ -7,68 +7,62 @@ import (
 )
 
 func TestCircularCache(t *testing.T) {
+	cache, err := New(-1)
+	require.Nil(t, cache)
+	require.Error(t, err)
+
 	size := 10
-	cache, err := New(size)
+	cache, err = New(size)
 	require.NoError(t, err)
 	// fill up cache
 	for i := 1; i <= size; i++ {
 		evicted := cache.Add(i, i)
 		require.False(t, evicted)
 	}
-	require.Equal(t, cache.Len(), size)
-	back, ok := cache.Peek(1)
-	require.True(t, ok)
-	two, ok := cache.Peek(2)
-	require.True(t, ok)
-	front, ok := cache.Peek(10)
-	require.True(t, ok)
-	_, ok = cache.Peek(11)
-	require.False(t, ok)
 
-	require.Equal(t, back, 1)
-	require.Equal(t, two, 2)
-	require.Equal(t, front, 10)
+	// adding same key on the same position but no evict becuase the evict is nil
+	require.True(t, cache.Contains(1))
+	val, _ := cache.Get(1)
+	require.Equal(t, 1, val)
+	evicted := cache.Add(1, 11)
+	require.False(t, evicted)
+	require.True(t, cache.Contains(1))
+	val, _ = cache.Get(1)
+	require.Equal(t, 11, val)
 
 	// add one more item when the cache is full
-	// 11 will replace the oldest item, a.k.a 1
-	evicted := cache.Add(11, 11)
-	require.True(t, evicted)
-	require.Equal(t, cache.Len(), size)
-
-	eleven, ok := cache.Peek(11)
-	require.True(t, ok)
-	require.Equal(t, eleven, 11)
-	_, ok = cache.Peek(1)
+	// 11 will replace the next position, a.k.a 2
+	require.True(t, cache.Contains(2))
+	val, ok := cache.Get(11)
+	require.Nil(t, val)
 	require.False(t, ok)
+	evicted = cache.Add(11, 11)
+	require.False(t, evicted)
+	require.False(t, cache.Contains(2))
 
-	// 12 will replace 11
-	evicted = cache.Add(12, 12)
-	require.True(t, evicted)
-	require.Equal(t, cache.Len(), size)
-
-	twelve, ok := cache.Get(12) // 12 is moved to front
-	require.True(t, ok)
-	require.Equal(t, twelve, 12)
-	_, ok = cache.Peek(11)
-	require.False(t, ok)
+	// Remove
+	require.True(t, cache.Contains(3))
+	require.True(t, cache.Remove(3))
+	require.False(t, cache.Remove(12))
+	require.False(t, cache.Contains(3))
 
-	// 13 will replace the oldest one, a.k.a 2
-	evicted = cache.Add(13, 13)
-	require.True(t, evicted)
-	require.Equal(t, cache.Len(), size)
+	// Purge
+	require.True(t, cache.Contains(6))
+	cache.Purge()
+	require.False(t, cache.Contains(6))
 
-	_, ok = cache.Peek(2)
+	// Add/Get nil value
+	require.False(t, cache.Add(12, nil))
+	val, ok = cache.Get(12)
+	require.Nil(t, val)
 	require.False(t, ok)
-
-	cache.Purge()
-	require.Equal(t, cache.Len(), 0)
 }
 
 func TestCircularCacheWithCallback(t *testing.T) {
 	size := 10
 	cache, err := NewWithEvict(size, func(key interface{}, value interface{}) {
-		require.Equal(t, key, 2)
-		require.Equal(t, value, 2)
+		require.Equal(t, key, 1)
+		require.Equal(t, value, 1)
 	})
 	require.NoError(t, err)
 	// fill up cache
@@ -77,13 +71,16 @@ func TestCircularCacheWithCallback(t *testing.T) {
 		require.False(t, evicted)
 	}
 
-	// re-add 1 to move it from back to front
+	// re-add 1, evict callback fundtion will be called
+	// and check that evicted item is 1/1
+	require.True(t, cache.Contains(1))
 	evicted := cache.Add(1, 1)
-	require.False(t, evicted)
+	require.True(t, evicted)
+	require.True(t, cache.Contains(1))
 
-	// Add one more item, evict callback fundtion will be called
-	// and check that evicted item is 2/2, the oldest item
+	// Add one more item into the next position, 2
+	require.True(t, cache.Contains(2))
 	evicted = cache.Add(11, 11)
-	require.True(t, evicted)
-	require.Equal(t, cache.Len(), size)
+	require.False(t, evicted)
+	require.False(t, cache.Contains(2))
 }