Vm sdk

cache/fifo_cache.go

@@ -0,0 +1,58 @@
+// Copyright (C) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package cache
+
+import (
+	"sync"
+
+	"github.com/ava-labs/avalanchego/utils/buffer"
+)
+
+type FIFO[K comparable, V any] struct {
+	l      sync.RWMutex
+	buffer buffer.Queue[K]
+	m      map[K]V
+}
+
+// NewFIFO creates a new First-In-First-Out cache of size [limit].
+//
+// If a duplicate item is stored, it will not be requeued but its
+// value will be changed.
+func NewFIFO[K comparable, V any](limit int) (*FIFO[K, V], error) {
+	c := &FIFO[K, V]{
+		m: make(map[K]V, limit),
+	}
+	buf, err := buffer.NewBoundedQueue(limit, c.remove)
+	if err != nil {
+		return nil, err
+	}
+	c.buffer = buf
+	return c, nil
+}
+
+func (f *FIFO[K, V]) Put(key K, val V) bool {
+	f.l.Lock()
+	defer f.l.Unlock()
+
+	_, exists := f.m[key]
+	if !exists {
+		f.buffer.Push(key) // Push removes the oldest [K] if we are at the [limit]
+	}
+	f.m[key] = val
+	return exists
+}
+
+func (f *FIFO[K, V]) Get(key K) (V, bool) {
+	f.l.RLock()
+	defer f.l.RUnlock()
+
+	v, ok := f.m[key]
+	return v, ok
+}
+
+// remove is used as the callback in [BoundedBuffer]. It is assumed that the
+// [WriteLock] is held when this is accessed.
+func (f *FIFO[K, V]) remove(key K) {
+	delete(f.m, key)
+}

cache/fifo_cache_test.go

@@ -0,0 +1,157 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package cache
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestFIFOCacheInsertion(t *testing.T) {
+	type put struct {
+		kv     int
+		exists bool
+	}
+
+	type get struct {
+		k  int
+		ok bool
+	}
+
+	tests := []struct {
+		name string
+		ops  []interface{}
+	}{
+		{
+			name: "insert less than limit",
+			ops: []interface{}{
+				put{
+					kv:     0,
+					exists: false,
+				},
+				get{
+					k:  0,
+					ok: true,
+				},
+			},
+		},
+		{
+			name: "insert limit",
+			ops: []interface{}{
+				put{
+					kv:     0,
+					exists: false,
+				},
+				put{
+					kv:     1,
+					exists: false,
+				},
+				get{
+					k:  0,
+					ok: true,
+				},
+				get{
+					k:  1,
+					ok: true,
+				},
+			},
+		},
+		{
+			name: "exceed limit",
+			ops: []interface{}{
+				put{
+					kv:     0,
+					exists: false,
+				},
+				put{
+					kv:     1,
+					exists: false,
+				},
+				put{
+					kv:     2,
+					exists: false,
+				},
+				get{
+					k:  0,
+					ok: false,
+				},
+				get{
+					k:  1,
+					ok: true,
+				},
+				get{
+					k:  2,
+					ok: true,
+				},
+			},
+		},
+		{
+			name: "exceed limit + get ops maintains FIFO removal order",
+			ops: []interface{}{
+				put{
+					kv:     0,
+					exists: false,
+				},
+				put{
+					kv:     1,
+					exists: false,
+				},
+				get{
+					k:  0,
+					ok: true,
+				},
+				put{
+					kv:     2,
+					exists: false,
+				},
+				get{
+					k:  0,
+					ok: false,
+				},
+				get{
+					k:  1,
+					ok: true,
+				},
+				get{
+					k:  2,
+					ok: true,
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require := require.New(t)
+
+			cache, err := NewFIFO[int, int](2)
+			require.NoError(err)
+
+			for _, opIntf := range tt.ops {
+				switch op := opIntf.(type) {
+				case put:
+					exists := cache.Put(op.kv, op.kv)
+					require.Equal(op.exists, exists)
+				case get:
+					val, ok := cache.Get(op.k)
+					require.Equal(op.ok, ok)
+					if ok {
+						require.Equal(op.k, val)
+					}
+				default:
+					require.Fail("op can only be a put or a get")
+				}
+			}
+		})
+	}
+}
+
+func TestEmptyCacheSizeInvalid(t *testing.T) {
+	require := require.New(t)
+	_, err := NewFIFO[int, int](0)
+	expectedErr := errors.New("maxSize must be greater than 0")
+	require.Equal(expectedErr, err)
+}

snow/engine/snowman/block/state_syncable_vm.go

@@ -43,3 +43,23 @@
 	// [summaryHeight].
 	GetStateSummary(ctx context.Context, summaryHeight uint64) (StateSummary, error)
 }
+
+type StateSyncableVMDisabled struct{}
+
+func (StateSyncableVMDisabled) StateSyncEnabled(context.Context) (bool, error) { return false, nil }
+
+func (StateSyncableVMDisabled) GetOngoingSyncStateSummary(context.Context) (StateSummary, error) {
+	return nil, ErrStateSyncableVMNotImplemented
+}
+
+func (StateSyncableVMDisabled) GetLastStateSummary(context.Context) (StateSummary, error) {
+	return nil, ErrStateSyncableVMNotImplemented
+}
+
+func (StateSyncableVMDisabled) ParseStateSummary(ctx context.Context, summaryBytes []byte) (StateSummary, error) {
+	return nil, ErrStateSyncableVMNotImplemented
+}
+
+func (StateSyncableVMDisabled) GetStateSummary(ctx context.Context, summaryHeight uint64) (StateSummary, error) {
+	return nil, ErrStateSyncableVMNotImplemented
+}