fix(trie): no in-memory caching of node encoding (#2919)

internal/trie/node/copy.go

@@ -99,11 +99,6 @@ func (n *Node) Copy(settings CopySettings) *Node {
 			cpy.MerkleValue = make([]byte, len(n.MerkleValue))
 			copy(cpy.MerkleValue, n.MerkleValue)
 		}
-
-		if n.Encoding != nil {
-			cpy.Encoding = make([]byte, len(n.Encoding))
-			copy(cpy.Encoding, n.Encoding)
-		}
 	}
 
 	return cpy

internal/trie/node/copy_test.go

@@ -48,7 +48,6 @@ func Test_Node_Copy(t *testing.T) {
 				}),
 				Dirty:       true,
 				MerkleValue: []byte{5},
-				Encoding:    []byte{6},
 			},
 			settings: DefaultCopySettings,
 			expectedNode: &Node{
@@ -96,7 +95,6 @@ func Test_Node_Copy(t *testing.T) {
 				}),
 				Dirty:       true,
 				MerkleValue: []byte{5},
-				Encoding:    []byte{6},
 			},
 			settings: DeepCopySettings,
 			expectedNode: &Node{
@@ -110,7 +108,6 @@ func Test_Node_Copy(t *testing.T) {
 				}),
 				Dirty:       true,
 				MerkleValue: []byte{5},
-				Encoding:    []byte{6},
 			},
 		},
 		"non empty leaf": {
@@ -119,7 +116,6 @@ func Test_Node_Copy(t *testing.T) {
 				SubValue:    []byte{3, 4},
 				Dirty:       true,
 				MerkleValue: []byte{5},
-				Encoding:    []byte{6},
 			},
 			settings: DefaultCopySettings,
 			expectedNode: &Node{
@@ -134,15 +130,13 @@ func Test_Node_Copy(t *testing.T) {
 				SubValue:    []byte{3, 4},
 				Dirty:       true,
 				MerkleValue: []byte{5},
-				Encoding:    []byte{6},
 			},
 			settings: DeepCopySettings,
 			expectedNode: &Node{
 				Key:         []byte{1, 2},
 				SubValue:    []byte{3, 4},
 				Dirty:       true,
 				MerkleValue: []byte{5},
-				Encoding:    []byte{6},
 			},
 		},
 	}
@@ -158,7 +152,6 @@ func Test_Node_Copy(t *testing.T) {
 			testForSliceModif(t, testCase.node.Key, nodeCopy.Key)
 			testForSliceModif(t, testCase.node.SubValue, nodeCopy.SubValue)
 			testForSliceModif(t, testCase.node.MerkleValue, nodeCopy.MerkleValue)
-			testForSliceModif(t, testCase.node.Encoding, nodeCopy.Encoding)
 
 			if testCase.node.Kind() == Branch {
 				testCase.node.Children[15] = &Node{Key: []byte("modified")}

internal/trie/node/dirty.go

@@ -7,9 +7,7 @@ package node
 func (n *Node) SetDirty() {
 	n.Dirty = true
 	// A node is marked dirty if its key or value is modified.
-	// This means its cached encoding and hash fields are no longer
-	// valid. To improve memory usage, we clear these fields.
-	n.Encoding = nil
+	// This means its Merkle value field is no longer valid.
 	n.MerkleValue = nil
 }
 

internal/trie/node/dirty_test.go

@@ -18,14 +18,12 @@ func Test_Node_SetDirty(t *testing.T) {
 	}{
 		"not dirty to dirty": {
 			node: Node{
-				Encoding:    []byte{1},
 				MerkleValue: []byte{1},
 			},
 			expected: Node{Dirty: true},
 		},
 		"dirty to dirty": {
 			node: Node{
-				Encoding:    []byte{1},
 				MerkleValue: []byte{1},
 				Dirty:       true,
 			},
@@ -54,22 +52,18 @@ func Test_Node_SetClean(t *testing.T) {
 	}{
 		"not dirty to not dirty": {
 			node: Node{
-				Encoding:    []byte{1},
 				MerkleValue: []byte{1},
 			},
 			expected: Node{
-				Encoding:    []byte{1},
 				MerkleValue: []byte{1},
 			},
 		},
 		"dirty to not dirty": {
 			node: Node{
-				Encoding:    []byte{1},
 				MerkleValue: []byte{1},
 				Dirty:       true,
 			},
 			expected: Node{
-				Encoding:    []byte{1},
 				MerkleValue: []byte{1},
 			},
 		},

internal/trie/node/encode.go

@@ -16,14 +16,6 @@ import (
 // of this package, and specified in the Polkadot spec at
 // https://spec.polkadot.network/#sect-state-storage
 func (n *Node) Encode(buffer Buffer) (err error) {
-	if !n.Dirty && n.Encoding != nil {
-		_, err = buffer.Write(n.Encoding)
-		if err != nil {
-			return fmt.Errorf("cannot write stored encoding to buffer: %w", err)
-		}
-		return nil
-	}
-
 	err = encodeHeader(n, buffer)
 	if err != nil {
 		return fmt.Errorf("cannot encode header: %w", err)
@@ -66,13 +58,5 @@ func (n *Node) Encode(buffer Buffer) (err error) {
 		}
 	}
 
-	if kind == Leaf {
-		// TODO cache this for branches too and update test cases.
-		// TODO remove this copying since it defeats the purpose of `buffer`
-		// and the sync.Pool.
-		n.Encoding = make([]byte, buffer.Len())
-		copy(n.Encoding, buffer.Bytes())
-	}
-
 	return nil
 }

internal/trie/node/encode_test.go

@@ -26,37 +26,10 @@ func Test_Node_Encode(t *testing.T) {
 	testCases := map[string]struct {
 		node             *Node
 		writes           []writeCall
-		bufferLenCall    bool
-		bufferBytesCall  bool
 		expectedEncoding []byte
 		wrappedErr       error
 		errMessage       string
 	}{
-		"clean leaf with encoding": {
-			node: &Node{
-				Encoding: []byte{1, 2, 3},
-			},
-			writes: []writeCall{
-				{
-					written: []byte{1, 2, 3},
-				},
-			},
-			expectedEncoding: []byte{1, 2, 3},
-		},
-		"write error for clean leaf with encoding": {
-			node: &Node{
-				Encoding: []byte{1, 2, 3},
-			},
-			writes: []writeCall{
-				{
-					written: []byte{1, 2, 3},
-					err:     errTest,
-				},
-			},
-			expectedEncoding: []byte{1, 2, 3},
-			wrappedErr:       errTest,
-			errMessage:       "cannot write stored encoding to buffer: test error",
-		},
 		"leaf header encoding error": {
 			node: &Node{
 				Key: make([]byte, 1),
@@ -123,8 +96,6 @@ func Test_Node_Encode(t *testing.T) {
 					written: []byte{12, 4, 5, 6},
 				},
 			},
-			bufferLenCall:    true,
-			bufferBytesCall:  true,
 			expectedEncoding: []byte{1, 2, 3},
 		},
 		"leaf with empty value success": {
@@ -142,35 +113,8 @@ func Test_Node_Encode(t *testing.T) {
 					written: []byte{0},
 				},
 			},
-			bufferLenCall:    true,
-			bufferBytesCall:  true,
 			expectedEncoding: []byte{1, 2, 3},
 		},
-		"clean branch with encoding": {
-			node: &Node{
-				Children: make([]*Node, ChildrenCapacity),
-				Encoding: []byte{1, 2, 3},
-			},
-			writes: []writeCall{
-				{ // stored encoding
-					written: []byte{1, 2, 3},
-				},
-			},
-		},
-		"write error for clean branch with encoding": {
-			node: &Node{
-				Children: make([]*Node, ChildrenCapacity),
-				Encoding: []byte{1, 2, 3},
-			},
-			writes: []writeCall{
-				{ // stored encoding
-					written: []byte{1, 2, 3},
-					err:     errTest,
-				},
-			},
-			wrappedErr: errTest,
-			errMessage: "cannot write stored encoding to buffer: test error",
-		},
 		"branch header encoding error": {
 			node: &Node{
 				Children: make([]*Node, ChildrenCapacity),
@@ -362,12 +306,6 @@ func Test_Node_Encode(t *testing.T) {
 				}
 				previousCall = call
 			}
-			if testCase.bufferLenCall {
-				buffer.EXPECT().Len().Return(len(testCase.expectedEncoding))
-			}
-			if testCase.bufferBytesCall {
-				buffer.EXPECT().Bytes().Return(testCase.expectedEncoding)
-			}
 
 			err := testCase.node.Encode(buffer)
 

internal/trie/node/hash.go

@@ -90,14 +90,12 @@ func (n *Node) CalculateRootMerkleValue() (merkleValue []byte, err error) {
 // and a merkle value writer, such that buffer sync pools can be used
 // by the caller.
 func (n *Node) EncodeAndHash() (encoding, merkleValue []byte, err error) {
-	if !n.Dirty && n.Encoding != nil && n.MerkleValue != nil {
-		return n.Encoding, n.MerkleValue, nil
-	}
-
-	encoding, err = n.encodeIfNeeded()
+	encodingBuffer := bytes.NewBuffer(nil)
+	err = n.Encode(encodingBuffer)
 	if err != nil {
 		return nil, nil, fmt.Errorf("encoding node: %w", err)
 	}
+	encoding = encodingBuffer.Bytes()
 
 	const maxMerkleValueSize = 32
 	merkleValueBuffer := bytes.NewBuffer(make([]byte, 0, maxMerkleValueSize))
@@ -118,15 +116,12 @@ func (n *Node) EncodeAndHash() (encoding, merkleValue []byte, err error) {
 // and a merkle value writer, such that buffer sync pools can be used
 // by the caller.
 func (n *Node) EncodeAndHashRoot() (encoding, merkleValue []byte, err error) {
-	const rootMerkleValueLength = 32
-	if !n.Dirty && n.Encoding != nil && len(n.MerkleValue) == rootMerkleValueLength {
-		return n.Encoding, n.MerkleValue, nil
-	}
-
-	encoding, err = n.encodeIfNeeded()
+	encodingBuffer := bytes.NewBuffer(nil)
+	err = n.Encode(encodingBuffer)
 	if err != nil {
 		return nil, nil, fmt.Errorf("encoding node: %w", err)
 	}
+	encoding = encodingBuffer.Bytes()
 
 	const merkleValueSize = 32
 	merkleValueBuffer := bytes.NewBuffer(make([]byte, 0, merkleValueSize))
@@ -139,19 +134,3 @@ func (n *Node) EncodeAndHashRoot() (encoding, merkleValue []byte, err error) {
 
 	return encoding, merkleValue, nil
 }
-
-func (n *Node) encodeIfNeeded() (encoding []byte, err error) {
-	if !n.Dirty && n.Encoding != nil {
-		return n.Encoding, nil // no need to copy
-	}
-
-	buffer := bytes.NewBuffer(nil)
-	err = n.Encode(buffer)
-	if err != nil {
-		return nil, fmt.Errorf("encoding: %w", err)
-	}
-
-	n.Encoding = buffer.Bytes()
-
-	return n.Encoding, nil // no need to copy
-}