add byte limit implementation for cache

cache/bytes_limit_decorator.go

@@ -0,0 +1,71 @@
+package cache
+
+import (
+	"container/list"
+	"errors"
+
+	"github.com/cosmos/iavl/common"
+)
+
+type lruCacheWithBytesLimit struct {
+	lruCache
+	bytesLimit int
+	// This is called an estimate because we calculcate the number of bytes used based on the
+	// knowledge of how the underlying structs, slices and strings are represented in Go.
+	// Since Go is a garbage collected language, there is no good way to retrieve the exact number
+	// of bytes used by both the stack and the heap at any particular moment. As a result, this
+	// is named an estimate to reflect that it is not a precise number.
+	curBytesEstimate int
+}
+
+var _ Cache = (*lruCacheWithBytesLimit)(nil)
+
+func NewWithBytesLimit(bytesLimit int) Cache {
+	return &lruCacheWithBytesLimit{
+		lruCache: lruCache{
+			dict: make(map[string]*list.Element),
+			ll:   list.New(),
+		},
+		bytesLimit: bytesLimit,
+	}
+}
+
+func (c *lruCacheWithBytesLimit) GetType() Type {
+	return LRU_bytes_limit
+}
+
+func (c *lruCacheWithBytesLimit) isOverLimit() bool {
+	return c.curBytesEstimate > c.bytesLimit
+}
+
+func (c *lruCacheWithBytesLimit) add(node Node) {
+	c.curBytesEstimate += (node.GetFullSize() + getCacheElemMetadataSize())
+	c.lruCache.add(node)
+}
+
+func (c *lruCacheWithBytesLimit) remove(e *list.Element) Node {
+	removed := c.lruCache.remove(e)
+	c.curBytesEstimate -= (removed.GetFullSize() + getCacheElemMetadataSize())
+	return removed
+}
+
+// getCacheElemMetadataSize returns how much space the structures
+// that hold a cache element utilize in memory.
+// With the current design, a list.Element is created that consists of 4 pointers.
+// In addition, a pointer to the element is stored in the Go map and has string as a key
+func getCacheElemMetadataSize() int {
+	return common.GetStringSizeBytes() + // cache dict key
+		common.UintSizeBytes + // pointer to the element in dict
+		common.Uint64Size*4 // 4 pointers within list.Element
+}
+
+// getCacheCurrentBytes returns the current bytes
+// estimate of the cache if the cache is lruCacheWithBytesLimit.
+// If not, returns 0 and error.
+func getCacheCurrentBytes(c Cache) (int, error) {
+	withBytesLimit, ok := c.(*lruCacheWithBytesLimit)
+	if ok {
+		return withBytesLimit.curBytesEstimate, nil
+	}
+	return 0, errors.New("cannot get bytes limit, not lruCacheWithBytesLimit")
+}

cache/bytes_limit_decorator_test.go

@@ -0,0 +1,248 @@
+package cache_test
+
+import (
+	"testing"
+
+	"github.com/cosmos/iavl/cache"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_BytesLimit_Add(t *testing.T) {
+	testcases := map[string]func() testcase{
+		"add 1 node with size of exactly limit - added": func() testcase {
+			const nodeIdx = 0
+
+			return testcase{
+				cacheLimit: testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize(),
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:       0,
+						expectedResult:     noneRemoved,
+						expectedBytesLimit: testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize(),
+					},
+				},
+				expectedNodeIndexes: []int{nodeIdx},
+			}
+		},
+		"add 2 nodes with latter exceeding limit - added, old removed": func() testcase {
+			const nodeIdx = 0
+
+			return testcase{
+				cacheLimit: testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize(),
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:       nodeIdx,
+						expectedResult:     noneRemoved,
+						expectedBytesLimit: testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize(),
+					},
+					{
+						testNodexIdx:       nodeIdx + 1,
+						expectedResult:     nodeIdx,
+						expectedBytesLimit: testNodes[nodeIdx+1].GetFullSize() + cache.GetCacheElemMetadataSize(),
+					},
+				},
+				expectedNodeIndexes: []int{nodeIdx + 1},
+			}
+		},
+		"add 2 nodes under limit": func() testcase {
+			const nodeIdx = 0
+
+			return testcase{
+				cacheLimit: testNodes[nodeIdx].GetFullSize() + testNodes[nodeIdx+3].GetFullSize() + 2*cache.GetCacheElemMetadataSize(),
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:       nodeIdx,
+						expectedResult:     noneRemoved,
+						expectedBytesLimit: testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize(),
+					},
+					{
+						testNodexIdx:       nodeIdx + 3,
+						expectedResult:     noneRemoved,
+						expectedBytesLimit: testNodes[nodeIdx].GetFullSize() + testNodes[nodeIdx+3].GetFullSize() + 2*cache.GetCacheElemMetadataSize(),
+					},
+				},
+				expectedNodeIndexes: []int{nodeIdx, nodeIdx + 3},
+			}
+		},
+		"add 3 nodes and 4th requiring the removal of first three due to being too large": func() testcase {
+			const nodeIdx = 0
+
+			return testcase{
+				cacheLimit: testNodes[nodeIdx].GetFullSize() +
+					testNodes[nodeIdx+1].GetFullSize() +
+					testNodes[nodeIdx+2].GetFullSize() +
+					3*cache.GetCacheElemMetadataSize(),
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:       nodeIdx,
+						expectedResult:     noneRemoved,
+						expectedBytesLimit: testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize(),
+					},
+					{
+						testNodexIdx:       nodeIdx + 1,
+						expectedResult:     noneRemoved,
+						expectedBytesLimit: testNodes[nodeIdx].GetFullSize() + testNodes[nodeIdx+1].GetFullSize() + 2*cache.GetCacheElemMetadataSize(),
+					},
+					{
+						testNodexIdx:       nodeIdx + 2,
+						expectedResult:     noneRemoved,
+						expectedBytesLimit: testNodes[nodeIdx].GetFullSize() + testNodes[nodeIdx+1].GetFullSize() + testNodes[nodeIdx+2].GetFullSize() + 3*cache.GetCacheElemMetadataSize(),
+					},
+					{
+						testNodexIdx:       nodeIdx + 3,
+						expectedResult:     allButLastRemoved,
+						expectedBytesLimit: testNodes[nodeIdx+2].GetFullSize() + testNodes[nodeIdx+3].GetFullSize() + 2*cache.GetCacheElemMetadataSize(),
+					},
+				},
+				expectedNodeIndexes: []int{nodeIdx + 2, nodeIdx + 3},
+			}
+		},
+	}
+
+	for name, getTestcaseFn := range testcases {
+		t.Run(name, func(t *testing.T) {
+			tc := getTestcaseFn()
+			bytesLimitCache := cache.NewWithBytesLimit(tc.cacheLimit)
+			testAdd(t, bytesLimitCache, tc)
+		})
+	}
+}
+
+func Test_BytesLimitCache_Remove(t *testing.T) {
+	testcases := map[string]func() testcase{
+		"remove non-existent key, cache limit 0 - nil returned": func() testcase {
+			const (
+				nodeIdx    = 0
+				cacheLimit = 0
+			)
+
+			return testcase{
+				cacheLimit: cacheLimit,
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:   nodeIdx,
+						expectedResult: noneRemoved,
+					},
+				},
+			}
+		},
+		"remove non-existent key - nil returned": func() testcase {
+			const (
+				nodeIdx = 0
+			)
+
+			var (
+				cacheLimit = testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize()
+			)
+
+			return testcase{
+				setup: func(c cache.Cache) {
+					require.Empty(t, cache.MockAdd(c, testNodes[nodeIdx+1]))
+					require.Equal(t, 1, c.Len())
+				},
+				cacheLimit: cacheLimit,
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:   nodeIdx,
+						expectedResult: noneRemoved,
+					},
+				},
+				expectedNodeIndexes: []int{1},
+			}
+		},
+		"remove existent key - removed": func() testcase {
+			const (
+				nodeIdx = 0
+			)
+
+			var (
+				cacheLimit = testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize()
+			)
+
+			return testcase{
+				setup: func(c cache.Cache) {
+					require.Empty(t, cache.MockAdd(c, testNodes[nodeIdx]))
+					require.Equal(t, 1, c.Len())
+				},
+				cacheLimit: cacheLimit,
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:   nodeIdx,
+						expectedResult: nodeIdx,
+					},
+				},
+			}
+		},
+		"remove twice, cache limit 1 - removed first time, then nil": func() testcase {
+			const (
+				nodeIdx = 0
+			)
+
+			var (
+				cacheLimit = testNodes[nodeIdx].GetFullSize() + cache.GetCacheElemMetadataSize()
+			)
+
+			return testcase{
+				setup: func(c cache.Cache) {
+					require.Empty(t, cache.MockAdd(c, testNodes[nodeIdx]))
+					require.Equal(t, 1, c.Len())
+				},
+				cacheLimit: cacheLimit,
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:   nodeIdx,
+						expectedResult: nodeIdx,
+					},
+					{
+						testNodexIdx:   nodeIdx,
+						expectedResult: noneRemoved,
+					},
+				},
+			}
+		},
+		"remove all, cache limit 3": func() testcase {
+			const (
+				nodeIdx = 0
+			)
+
+			var (
+				cacheLimit = testNodes[nodeIdx].GetFullSize() +
+					testNodes[nodeIdx+1].GetFullSize() +
+					testNodes[nodeIdx+2].GetFullSize() +
+					3*cache.GetCacheElemMetadataSize()
+			)
+
+			return testcase{
+				setup: func(c cache.Cache) {
+					require.Empty(t, cache.MockAdd(c, testNodes[nodeIdx]))
+					require.Empty(t, cache.MockAdd(c, testNodes[nodeIdx+1]))
+					require.Empty(t, cache.MockAdd(c, testNodes[nodeIdx+2]))
+					require.Equal(t, 3, c.Len())
+				},
+				cacheLimit: cacheLimit,
+				cacheOps: []cacheOp{
+					{
+						testNodexIdx:   nodeIdx + 2,
+						expectedResult: nodeIdx + 2,
+					},
+					{
+						testNodexIdx:   nodeIdx,
+						expectedResult: nodeIdx,
+					},
+					{
+						testNodexIdx:   nodeIdx + 1,
+						expectedResult: nodeIdx + 1,
+					},
+				},
+			}
+		},
+	}
+
+	for name, getTestcaseFn := range testcases {
+		t.Run(name, func(t *testing.T) {
+			tc := getTestcaseFn()
+			bytesLimitCache := cache.NewWithNodeLimit(tc.cacheLimit)
+			testRemove(t, bytesLimitCache, tc)
+		})
+	}
+}