Mining Analysis

cmd/evm/internal/t8ntool/block.go

@@ -17,6 +17,7 @@
 package t8ntool
 
 import (
+	"context"
 	"crypto/ecdsa"
 	"encoding/json"
 	"errors"
@@ -188,7 +189,7 @@ func (i *bbInput) sealEthash(block *types.Block) (*types.Block, error) {
 	// If the testmode is used, the sealer will return quickly, and complain
 	// "Sealing result is not read by miner" if it cannot write the result.
 	results := make(chan *types.Block, 1)
-	if err := engine.Seal(nil, block, results, nil); err != nil {
+	if err := engine.Seal(context.Background(), nil, block, results, nil); err != nil {
 		panic(fmt.Sprintf("failed to seal block: %v", err))
 	}
 	found := <-results

cmd/evm/internal/t8ntool/execution.go

@@ -17,6 +17,7 @@
 package t8ntool
 
 import (
+	"context"
 	"fmt"
 	"math/big"
 	"os"
@@ -192,7 +193,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 			if chainConfig.IsByzantium(vmContext.BlockNumber) {
 				statedb.Finalise(true)
 			} else {
-				root = statedb.IntermediateRoot(chainConfig.IsEIP158(vmContext.BlockNumber)).Bytes()
+				root = statedb.IntermediateRoot(context.Background(), chainConfig.IsEIP158(vmContext.BlockNumber)).Bytes()
 			}
 
 			// Create a new receipt for the transaction, storing the intermediate root and
@@ -223,7 +224,8 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 
 		txIndex++
 	}
-	statedb.IntermediateRoot(chainConfig.IsEIP158(vmContext.BlockNumber))
+
+	statedb.IntermediateRoot(context.Background(), chainConfig.IsEIP158(vmContext.BlockNumber))
 	// Add mining reward?
 	if miningReward > 0 {
 		// Add mining reward. The mining reward may be `0`, which only makes a difference in the cases

cmd/evm/runner.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@@ -269,7 +270,7 @@ func runCmd(ctx *cli.Context) error {
 
 	if ctx.GlobalBool(DumpFlag.Name) {
 		statedb.Commit(true)
-		statedb.IntermediateRoot(true)
+		statedb.IntermediateRoot(context.Background(), true)
 		fmt.Println(string(statedb.Dump(nil)))
 	}
 

cmd/evm/staterunner.go

@@ -17,6 +17,7 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -95,14 +96,15 @@ func stateTestCmd(ctx *cli.Context) error {
 		Debug:  ctx.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name),
 	}
 	results := make([]StatetestResult, 0, len(tests))
+	ctxGo := context.Background()
 	for key, test := range tests {
 		for _, st := range test.Subtests() {
 			// Run the test and aggregate the result
 			result := &StatetestResult{Name: key, Fork: st.Fork, Pass: true}
 			_, s, err := test.Run(st, cfg, false)
 			// print state root for evmlab tracing
 			if ctx.GlobalBool(MachineFlag.Name) && s != nil {
-				fmt.Fprintf(os.Stderr, "{\"stateRoot\": \"%x\"}\n", s.IntermediateRoot(false))
+				fmt.Fprintf(os.Stderr, "{\"stateRoot\": \"%x\"}\n", s.IntermediateRoot(ctxGo, false))
 			}
 			if err != nil {
 				// Test failed, mark as so and dump any state to aid debugging

common/tracing/context.go

@@ -0,0 +1,81 @@
+package tracing
+
+import (
+	"context"
+	"time"
+
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
+)
+
+type tracerKey struct{}
+
+type Option func(context.Context, trace.Span)
+
+func WithTracer(ctx context.Context, tr trace.Tracer) context.Context {
+	return context.WithValue(ctx, tracerKey{}, tr)
+}
+
+func FromContext(ctx context.Context) trace.Tracer {
+	tr, _ := ctx.Value(tracerKey{}).(trace.Tracer)
+
+	return tr
+}
+
+func StartSpan(ctx context.Context, snapName string) (context.Context, trace.Span) {
+	tr := FromContext(ctx)
+	ctx, span := tr.Start(ctx, snapName)
+	ctx = WithTracer(ctx, tr)
+
+	return ctx, span
+}
+
+func Trace(ctx context.Context, spanName string) (context.Context, trace.Span) {
+	tr := FromContext(ctx)
+
+	if tr == nil {
+		return ctx, nil
+	}
+
+	return tr.Start(ctx, spanName)
+}
+
+func Exec(ctx context.Context, spanName string, opts ...Option) {
+	var span trace.Span
+
+	tr := FromContext(ctx)
+
+	if tr != nil {
+		ctx, span = tr.Start(ctx, spanName)
+	}
+
+	for _, optFn := range opts {
+		optFn(ctx, span)
+	}
+
+	if tr != nil {
+		span.End()
+	}
+
+	return
+}
+
+func WithTime(fn func(context.Context, trace.Span)) Option {
+	return func(ctx context.Context, span trace.Span) {
+		ElapsedTime(ctx, span, "elapsed", fn)
+	}
+}
+
+func ElapsedTime(ctx context.Context, span trace.Span, msg string, fn func(context.Context, trace.Span)) {
+	var now time.Time
+
+	if span != nil {
+		now = time.Now()
+	}
+
+	fn(ctx, span)
+
+	if span != nil {
+		span.SetAttributes(attribute.Int(msg, int(time.Since(now).Milliseconds())))
+	}
+}

consensus/beacon/consensus.go

@@ -17,6 +17,7 @@
 package beacon
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"math/big"
@@ -273,16 +274,16 @@ func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.
 	}
 	// The block reward is no longer handled here. It's done by the
 	// external consensus engine.
-	header.Root = state.IntermediateRoot(true)
+	header.Root = state.IntermediateRoot(context.Background(), true)
 }
 
 // FinalizeAndAssemble implements consensus.Engine, setting the final state and
 // assembling the block.
-func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
+func (beacon *Beacon) FinalizeAndAssemble(ctx context.Context, chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
 	// FinalizeAndAssemble is different with Prepare, it can be used in both block
 	// generation and verification. So determine the consensus rules by header type.
 	if !beacon.IsPoSHeader(header) {
-		return beacon.ethone.FinalizeAndAssemble(chain, header, state, txs, uncles, receipts)
+		return beacon.ethone.FinalizeAndAssemble(ctx, chain, header, state, txs, uncles, receipts)
 	}
 	// Finalize and assemble the block
 	beacon.Finalize(chain, header, state, txs, uncles)
@@ -294,9 +295,9 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 //
 // Note, the method returns immediately and will send the result async. More
 // than one result may also be returned depending on the consensus algorithm.
-func (beacon *Beacon) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
+func (beacon *Beacon) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
 	if !beacon.IsPoSHeader(block.Header()) {
-		return beacon.ethone.Seal(chain, block, results, stop)
+		return beacon.ethone.Seal(ctx, chain, block, results, stop)
 	}
 	// The seal verification is done by the external consensus engine,
 	// return directly without pushing any block back. In another word