Verified feat: add on pebble state backend and using sync Pool to reuse buffer []byte

2 files changed, 54 insertions, 2 deletions

diff --git a/core/pool.go b/core/pool.go
new file mode 100644
index 0000000..484b342
--- /dev/null
+++ b/core/pool.go
@@ -0,0 +1,38 @@
+package core
+
+import "sync"
+
+
+const (
+        DefaultBufferSize = 1024
+        MaxBufferSize = 64 * 1024
+)
+
+var bytesPool = sync.Pool{
+        New: func () any {
+                b := make([]byte, DefaultBufferSize)
+                return &b
+        },
+}
+
+func GetBuffer(size int) []byte {
+        bufPtr := bytesPool.Get().(*[]byte)
+
+        buf := *bufPtr
+
+
+        if size > cap(buf) {
+                buf = make([]byte, size)
+        }
+
+        return buf[:size]
+}
+
+
+func PutBuffer(buf []byte) {
+        if cap(buf) < MaxBufferSize{
+                // reset
+                buf = buf[:0]
+                bytesPool.Put(&buf)
+        }
+}
diff --git a/core/state_backend.go b/core/state_backend.go
index 5870739..ae9fe1d 100644
--- a/core/state_backend.go
+++ b/core/state_backend.go
@@ -2,6 +2,9 @@ package core
 
 import (
         "context"
+        "encoding/json"
+        "fmt"
+
 )
 
 type StateBackend interface {
@@ -22,6 +25,7 @@ type stateBackendKeyType struct{}
 
 var stateBackendKey stateBackendKeyType
 
+// type adapter
 type typedValueState[T any] struct {
         inner ValueState[any]
 }
@@ -32,14 +36,24 @@ func CastValueType[T any](inner ValueState[any]) ValueState[T] {
 
 func (s *typedValueState[T]) Value(ctx context.Context) (T, error) {
         val, err := s.inner.Value(ctx)
+        var zero T
         if err != nil {
-                var zero T
                 return zero, err
         }
         if val == nil {
-                var zero T
                 return zero, nil
         }
+
+        if rawBytes, ok := val.([]byte); ok {
+                defer PutBuffer(rawBytes)
+
+                var result T
+                if err := json.Unmarshal(rawBytes, &result); err != nil {
+                        return zero, fmt.Errorf("failed to unmarshal state: %w", err)
+                }
+                return result, nil
+        }
+
         return val.(T), nil
 }