Implement caching syscalls for import-bench

chain/vm/runtime.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/binary"
 	"fmt"
-	gruntime "runtime"
 	"time"
 
 	"github.com/filecoin-project/go-address"
@@ -460,8 +459,10 @@ func (rt *Runtime) stateCommit(oldh, newh cid.Cid) aerrors.ActorError {
 }
 
 func (rt *Runtime) finilizeGasTracing() {
-	if rt.lastGasCharge != nil {
-		rt.lastGasCharge.TimeTaken = time.Since(rt.lastGasChargeTime)
+	if enableTracing {
+		if rt.lastGasCharge != nil {
+			rt.lastGasCharge.TimeTaken = time.Since(rt.lastGasChargeTime)
+		}
 	}
 }
 
@@ -490,33 +491,38 @@ func (rt *Runtime) chargeGasFunc(skip int) func(GasCharge) {
 
 }
 
+var enableTracing = false
+
 func (rt *Runtime) chargeGasInternal(gas GasCharge, skip int) aerrors.ActorError {
 	toUse := gas.Total()
-	var callers [10]uintptr
-	cout := gruntime.Callers(2+skip, callers[:])
+	if enableTracing {
+		var callers [10]uintptr
 
-	now := build.Clock.Now()
-	if rt.lastGasCharge != nil {
-		rt.lastGasCharge.TimeTaken = now.Sub(rt.lastGasChargeTime)
-	}
+		cout := 0 //gruntime.Callers(2+skip, callers[:])
 
-	gasTrace := types.GasTrace{
-		Name:  gas.Name,
-		Extra: gas.Extra,
+		now := build.Clock.Now()
+		if rt.lastGasCharge != nil {
+			rt.lastGasCharge.TimeTaken = now.Sub(rt.lastGasChargeTime)
+		}
+
+		gasTrace := types.GasTrace{
+			Name:  gas.Name,
+			Extra: gas.Extra,
 
-		TotalGas:   toUse,
-		ComputeGas: gas.ComputeGas,
-		StorageGas: gas.StorageGas,
+			TotalGas:   toUse,
+			ComputeGas: gas.ComputeGas,
+			StorageGas: gas.StorageGas,
 
-		TotalVirtualGas:   gas.VirtualCompute*GasComputeMulti + gas.VirtualStorage*GasStorageMulti,
-		VirtualComputeGas: gas.VirtualCompute,
-		VirtualStorageGas: gas.VirtualStorage,
+			TotalVirtualGas:   gas.VirtualCompute*GasComputeMulti + gas.VirtualStorage*GasStorageMulti,
+			VirtualComputeGas: gas.VirtualCompute,
+			VirtualStorageGas: gas.VirtualStorage,
 
-		Callers: callers[:cout],
+			Callers: callers[:cout],
+		}
+		rt.executionTrace.GasCharges = append(rt.executionTrace.GasCharges, &gasTrace)
+		rt.lastGasChargeTime = now
+		rt.lastGasCharge = &gasTrace
 	}
-	rt.executionTrace.GasCharges = append(rt.executionTrace.GasCharges, &gasTrace)
-	rt.lastGasChargeTime = now
-	rt.lastGasCharge = &gasTrace
 
 	// overflow safe
 	if rt.gasUsed > rt.gasAvailable-toUse {

chain/vm/vm.go

@@ -227,14 +227,21 @@ func (vm *VM) send(ctx context.Context, msg *types.Message, parent *Runtime,
 	}
 
 	rt := vm.makeRuntime(ctx, msg, origin, on, gasUsed, nac)
-	rt.lastGasChargeTime = start
+	if enableTracing {
+		rt.lastGasChargeTime = start
+		if parent != nil {
+			rt.lastGasChargeTime = parent.lastGasChargeTime
+			rt.lastGasCharge = parent.lastGasCharge
+			defer func() {
+				parent.lastGasChargeTime = rt.lastGasChargeTime
+				parent.lastGasCharge = rt.lastGasCharge
+			}()
+		}
+	}
+
 	if parent != nil {
-		rt.lastGasChargeTime = parent.lastGasChargeTime
-		rt.lastGasCharge = parent.lastGasCharge
 		defer func() {
 			parent.gasUsed = rt.gasUsed
-			parent.lastGasChargeTime = rt.lastGasChargeTime
-			parent.lastGasCharge = rt.lastGasCharge
 		}()
 	}
 	if gasCharge != nil {

cmd/lotus-bench/caching_verifier.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"errors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+	"github.com/ipfs/go-datastore"
+	"github.com/minio/blake2b-simd"
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+type cachingVerifier struct {
+	ds      datastore.Datastore
+	backend ffiwrapper.Verifier
+}
+
+const bufsize = 128
+
+func (cv cachingVerifier) withCache(execute func() (bool, error), param cbg.CBORMarshaler) (bool, error) {
+	hasher := blake2b.New256()
+	wr := bufio.NewWriterSize(hasher, bufsize)
+	err := param.MarshalCBOR(wr)
+	if err != nil {
+		log.Errorf("could not marshal call info: %+v", err)
+		return execute()
+	}
+	err = wr.Flush()
+	if err != nil {
+		log.Errorf("could not flush: %+v", err)
+		return execute()
+	}
+	hash := hasher.Sum(nil)
+	key := datastore.NewKey(string(hash))
+	fromDs, err := cv.ds.Get(key)
+	if err == nil {
+		switch fromDs[0] {
+		case 's':
+			return true, nil
+		case 'f':
+			return false, nil
+		case 'e':
+			return false, errors.New(string(fromDs[1:]))
+		default:
+			log.Errorf("bad cached result in cache %s(%x)", fromDs[0], fromDs[0])
+			return execute()
+		}
+	} else if errors.Is(err, datastore.ErrNotFound) {
+		// recalc
+		ok, err := execute()
+		var save []byte
+		if err != nil {
+			if ok {
+				log.Errorf("success with an error: %+v", err)
+			} else {
+				save = append([]byte{'e'}, []byte(err.Error())...)
+			}
+		} else if ok {
+			save = []byte{'s'}
+		} else {
+			save = []byte{'f'}
+		}
+
+		if len(save) != 0 {
+			errSave := cv.ds.Put(key, save)
+			if errSave != nil {
+				log.Errorf("error saving result: %+v", errSave)
+			}
+		}
+
+		return ok, err
+	} else {
+		log.Errorf("could not get data from cache: %+v", err)
+		return execute()
+	}
+}
+
+func (cv *cachingVerifier) VerifySeal(svi proof.SealVerifyInfo) (bool, error) {
+	return cv.withCache(func() (bool, error) {
+		return cv.backend.VerifySeal(svi)
+	}, &svi)
+}
+func (cv *cachingVerifier) VerifyWinningPoSt(ctx context.Context, info proof.WinningPoStVerifyInfo) (bool, error) {
+	return cv.backend.VerifyWinningPoSt(ctx, info)
+}
+func (cv *cachingVerifier) VerifyWindowPoSt(ctx context.Context, info proof.WindowPoStVerifyInfo) (bool, error) {
+	return cv.withCache(func() (bool, error) {
+		return cv.backend.VerifyWindowPoSt(ctx, info)
+	}, &info)
+}
+func (cv *cachingVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proofType abi.RegisteredPoStProof, a abi.ActorID, rnd abi.PoStRandomness, u uint64) ([]uint64, error) {
+	return cv.backend.GenerateWinningPoStSectorChallenge(ctx, proofType, a, rnd, u)
+}
+
+var _ ffiwrapper.Verifier = (*cachingVerifier)(nil)