Upgrade trace to decrease GC pressure.

core/types/l2trace.go

@@ -1,6 +1,9 @@
 package types
 
 import (
+	"runtime"
+	"sync"
+
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/common/hexutil"
 )
@@ -30,17 +33,17 @@ type ExecutionResult struct {
 // StructLogRes stores a structured log emitted by the EVM while replaying a
 // transaction in debug mode
 type StructLogRes struct {
-	Pc            uint64             `json:"pc"`
-	Op            string             `json:"op"`
-	Gas           uint64             `json:"gas"`
-	GasCost       uint64             `json:"gasCost"`
-	Depth         int                `json:"depth"`
-	Error         string             `json:"error,omitempty"`
-	Stack         *[]string          `json:"stack,omitempty"`
-	Memory        *[]string          `json:"memory,omitempty"`
-	Storage       *map[string]string `json:"storage,omitempty"`
-	RefundCounter uint64             `json:"refund,omitempty"`
-	ExtraData     *ExtraData         `json:"extraData,omitempty"`
+	Pc            uint64            `json:"pc"`
+	Op            string            `json:"op"`
+	Gas           uint64            `json:"gas"`
+	GasCost       uint64            `json:"gasCost"`
+	Depth         int               `json:"depth"`
+	Error         string            `json:"error,omitempty"`
+	Stack         []string          `json:"stack,omitempty"`
+	Memory        []string          `json:"memory,omitempty"`
+	Storage       map[string]string `json:"storage,omitempty"`
+	RefundCounter uint64            `json:"refund,omitempty"`
+	ExtraData     *ExtraData        `json:"extraData,omitempty"`
 }
 
 type ExtraData struct {
@@ -55,6 +58,18 @@ type ExtraData struct {
 	ProofList []*AccountProofWrapper `json:"proofList,omitempty"`
 }
 
+var (
+	proofPool = sync.Pool{
+		New: func() interface{} {
+			return &AccountProofWrapper{
+				Storage: &StorageProofWrapper{
+					Proof: make([]string, 0),
+				},
+			}
+		},
+	}
+)
+
 type AccountProofWrapper struct {
 	Address  common.Address       `json:"address"`
 	Nonce    uint64               `json:"nonce"`
@@ -64,6 +79,26 @@ type AccountProofWrapper struct {
 	Storage  *StorageProofWrapper `json:"storage,omitempty"` // StorageProofWrapper can be empty if irrelated to storage operation
 }
 
+func NewAccountProofWrapper(addr common.Address, nonce uint64, balance *hexutil.Big, codeHash common.Hash) *AccountProofWrapper {
+	proof := proofPool.Get().(*AccountProofWrapper)
+	proof.Address, proof.Nonce, proof.Balance, proof.CodeHash = addr, nonce, balance, codeHash
+	runtime.SetFinalizer(proof, func(proof *AccountProofWrapper) {
+		proof.clean()
+	})
+	return proof
+}
+
+func (a *AccountProofWrapper) clean() {
+	a.Balance = nil
+	a.Nonce = 0
+	if a.Proof != nil {
+		a.Proof = a.Proof[:0]
+	}
+	if a.Storage != nil {
+		a.Storage.clean()
+	}
+}
+
 // while key & value can also be retrieved from StructLogRes.Storage,
 // we still stored in here for roller's processing convenience.
 type StorageProofWrapper struct {
@@ -72,6 +107,12 @@ type StorageProofWrapper struct {
 	Proof []string `json:"proof,omitempty"`
 }
 
+func (s *StorageProofWrapper) clean() {
+	if s.Proof != nil {
+		s.Proof = s.Proof[:0]
+	}
+}
+
 // NewExtraData create, init and return ExtraData
 func NewExtraData() *ExtraData {
 	return &ExtraData{

core/vm/logger.go

@@ -441,39 +441,59 @@ func (t *mdLogger) CaptureEnter(typ OpCode, from common.Address, to common.Addre
 
 func (t *mdLogger) CaptureExit(output []byte, gasUsed uint64, err error) {}
 
+var (
+	formatPool = sync.Pool{
+		New: func() interface{} {
+			return make([]types.StructLogRes, 0, 128)
+		},
+	}
+)
+
 // FormatLogs formats EVM returned structured logs for json output
 func FormatLogs(logs []StructLog) []types.StructLogRes {
-	formatted := make([]types.StructLogRes, len(logs))
+	formatted := formatPool.Get().([]types.StructLogRes)
+	runtime.SetFinalizer(&formatted, func(format *[]types.StructLogRes) {
+		for _, res := range *format {
+			res.ExtraData = nil
+			res.Storage = nil
+			res.Stack = res.Stack[:0]
+			res.Memory = res.Memory[:0]
+		}
+		formatPool.Put(*format)
+	})
+
 	for index, trace := range logs {
-		formatted[index] = types.StructLogRes{
+		formatted = append(formatted, types.StructLogRes{
 			Pc:            trace.Pc,
 			Op:            trace.Op.String(),
 			Gas:           trace.Gas,
 			GasCost:       trace.GasCost,
 			Depth:         trace.Depth,
 			RefundCounter: trace.RefundCounter,
 			Error:         trace.ErrorString(),
-		}
+		})
 		if len(trace.Stack) != 0 {
-			stack := make([]string, len(trace.Stack))
-			for i, stackValue := range trace.Stack {
-				stack[i] = stackValue.Hex()
+			if formatted[index].Stack == nil {
+				formatted[index].Stack = make([]string, 0, len(trace.Stack))
+			}
+			for _, stackValue := range trace.Stack {
+				formatted[index].Stack = append(formatted[index].Stack, stackValue.Hex())
 			}
-			formatted[index].Stack = &stack
 		}
 		if trace.Memory.Len() != 0 {
-			memory := make([]string, 0, (trace.Memory.Len()+31)/32)
+			if formatted[index].Memory == nil {
+				formatted[index].Memory = make([]string, 0, (trace.Memory.Len()+31)/32)
+			}
 			for i := 0; i+32 <= trace.Memory.Len(); i += 32 {
-				memory = append(memory, fmt.Sprintf("%x", trace.Memory.Bytes()[i:i+32]))
+				formatted[index].Memory = append(formatted[index].Memory, common.Bytes2Hex(trace.Memory.Bytes()[i:i+32]))
 			}
-			formatted[index].Memory = &memory
 		}
 		if len(trace.Storage) != 0 {
 			storage := make(map[string]string)
 			for i, storageValue := range trace.Storage {
-				storage[fmt.Sprintf("%x", i)] = fmt.Sprintf("%x", storageValue)
+				storage[i.Hex()] = storageValue.Hex()
 			}
-			formatted[index].Storage = &storage
+			formatted[index].Storage = storage
 		}
 		if trace.ExtraData != nil {
 			formatted[index].ExtraData = trace.ExtraData.SealExtraData()

core/vm/logger_trace.go

@@ -126,14 +126,15 @@ func getWrappedProofForAddr(l *StructLogger, address common.Address) (*types.Acc
 	if err != nil {
 		return nil, err
 	}
-
-	return &types.AccountProofWrapper{
-		Address:  address,
-		Nonce:    l.env.StateDB.GetNonce(address),
-		Balance:  (*hexutil.Big)(l.env.StateDB.GetBalance(address)),
-		CodeHash: l.env.StateDB.GetCodeHash(address),
-		Proof:    encodeProof(proof),
-	}, nil
+	accountProof := types.NewAccountProofWrapper(
+		address,
+		l.env.StateDB.GetNonce(address),
+		(*hexutil.Big)(l.env.StateDB.GetBalance(address)),
+		l.env.StateDB.GetCodeHash(address),
+	)
+	encodeProof(&accountProof.Proof, proof)
+
+	return accountProof, nil
 }
 
 func getWrappedProofForStorage(l *StructLogger, address common.Address, key common.Hash) (*types.AccountProofWrapper, error) {
@@ -147,26 +148,25 @@ func getWrappedProofForStorage(l *StructLogger, address common.Address, key comm
 		return nil, err
 	}
 
-	return &types.AccountProofWrapper{
-		Address:  address,
-		Nonce:    l.env.StateDB.GetNonce(address),
-		Balance:  (*hexutil.Big)(l.env.StateDB.GetBalance(address)),
-		CodeHash: l.env.StateDB.GetCodeHash(address),
-		Proof:    encodeProof(proof),
-		Storage: &types.StorageProofWrapper{
-			Key:   key.String(),
-			Value: l.env.StateDB.GetState(address, key).String(),
-			Proof: encodeProof(storageProof),
-		},
-	}, nil
+	accountProof := types.NewAccountProofWrapper(
+		address,
+		l.env.StateDB.GetNonce(address),
+		(*hexutil.Big)(l.env.StateDB.GetBalance(address)),
+		l.env.StateDB.GetCodeHash(address),
+	)
+	encodeProof(&accountProof.Proof, proof)
+	storage := accountProof.Storage
+	storage.Key, storage.Value = key.String(), l.env.StateDB.GetState(address, key).String()
+	encodeProof(&storage.Proof, storageProof)
+
+	return accountProof, nil
 }
 
-func encodeProof(proof [][]byte) (res []string) {
+func encodeProof(res *[]string, proof [][]byte) {
 	if len(proof) == 0 {
-		return nil
+		return
 	}
 	for _, node := range proof {
-		res = append(res, hexutil.Encode(node))
+		*res = append(*res, hexutil.Encode(node))
 	}
-	return
 }