diff --git a/slasher/detection/BUILD.bazel b/slasher/detection/BUILD.bazel new file mode 100644 index 0000000000..d25cf0da19 --- /dev/null +++ b/slasher/detection/BUILD.bazel @@ -0,0 +1,33 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") + +go_library( + name = "go_default_library", + srcs = ["attestations.go"], + importpath = "github.com/prysmaticlabs/prysm/slasher/detection", + visibility = ["//visibility:public"], + deps = [ + "//proto/slashing:go_default_library", + "//shared/params:go_default_library", + "@com_github_pkg_errors//:go_default_library", + "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library", + "@io_opencensus_go//trace:go_default_library", + ], +) + +go_test( + name = "go_default_test", + testonly = True, + srcs = [ + "attestation_test.go", + "attestations_bench_test.go", + ], + embed = [":go_default_library"], + deps = [ + "//proto/slashing:go_default_library", + "//shared/params:go_default_library", + "//slasher/db/testing:go_default_library", + "//slasher/flags:go_default_library", + "@com_github_gogo_protobuf//proto:go_default_library", + "@com_github_urfave_cli//:go_default_library", + ], +) diff --git a/slasher/rpc/detect_update_min_max_span_test.go b/slasher/detection/attestation_test.go similarity index 86% rename from slasher/rpc/detect_update_min_max_span_test.go rename to slasher/detection/attestation_test.go index 9ab5a1ec48..2805f336b6 100644 --- a/slasher/rpc/detect_update_min_max_span_test.go +++ b/slasher/detection/attestation_test.go @@ -1,4 +1,4 @@ -package rpc +package detection import ( "context" @@ -201,25 +201,22 @@ func TestServer_UpdateMaxEpochSpan(t *testing.T) { defer testDB.TeardownSlasherDB(t, db) ctx := context.Background() - slasherServer := &Server{ - SlasherDB: db, - } for _, tt := range spanTestsMax { - spanMap, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, tt.validatorIdx) + spanMap, err := db.ValidatorSpansMap(ctx, tt.validatorIdx) if err != nil { t.Fatal(err) } - st, spanMap, err := slasherServer.DetectAndUpdateMaxEpochSpan(ctx, tt.sourceEpoch, tt.targetEpoch, tt.validatorIdx, spanMap) + st, spanMap, err := detectAndUpdateMaxEpochSpan(ctx, tt.sourceEpoch, tt.targetEpoch, spanMap) if err != nil { t.Fatalf("Failed to update span: %v", err) } - if err := slasherServer.SlasherDB.SaveValidatorSpansMap(ctx, tt.validatorIdx, spanMap); err != nil { + if err := db.SaveValidatorSpansMap(ctx, tt.validatorIdx, spanMap); err != nil { t.Fatalf("Couldnt save span map for validator id: %d", tt.validatorIdx) } if st != tt.slashingTargetEpoch { t.Fatalf("Expected slashing target: %d got: %d", tt.slashingTargetEpoch, st) } - sm, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, tt.validatorIdx) + sm, err := db.ValidatorSpansMap(ctx, tt.validatorIdx) if err != nil { t.Fatalf("Failed to retrieve span: %v", err) } @@ -236,25 +233,23 @@ func TestServer_UpdateMinEpochSpan(t *testing.T) { db := testDB.SetupSlasherDB(t, c) defer testDB.TeardownSlasherDB(t, db) ctx := context.Background() - slasherServer := &Server{ - SlasherDB: db, - } + for _, tt := range spanTestsMin { - spanMap, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, tt.validatorIdx) + spanMap, err := db.ValidatorSpansMap(ctx, tt.validatorIdx) if err != nil { t.Fatal(err) } - st, spanMap, err := slasherServer.DetectAndUpdateMinEpochSpan(ctx, tt.sourceEpoch, tt.targetEpoch, tt.validatorIdx, spanMap) + st, spanMap, err := detectAndUpdateMinEpochSpan(ctx, tt.sourceEpoch, tt.targetEpoch, spanMap) if err != nil { t.Fatalf("Failed to update span: %v", err) } - if err := slasherServer.SlasherDB.SaveValidatorSpansMap(ctx, tt.validatorIdx, spanMap); err != nil { + if err := db.SaveValidatorSpansMap(ctx, tt.validatorIdx, spanMap); err != nil { t.Fatalf("Couldnt save span map for validator id: %d", tt.validatorIdx) } if st != tt.slashingTargetEpoch { t.Fatalf("Expected slashing target: %d got: %d", tt.slashingTargetEpoch, st) } - sm, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, tt.validatorIdx) + sm, err := db.ValidatorSpansMap(ctx, tt.validatorIdx) if err != nil { t.Fatalf("Failed to retrieve span: %v", err) } @@ -271,11 +266,8 @@ func TestServer_FailToUpdate(t *testing.T) { db := testDB.SetupSlasherDB(t, c) defer testDB.TeardownSlasherDB(t, db) ctx := context.Background() - slasherServer := &Server{ - SlasherDB: db, - } + spanTestsFail := spanMapTestStruct{ - validatorIdx: 0, sourceEpoch: 0, slashingTargetEpoch: 0, targetEpoch: params.BeaconConfig().WeakSubjectivityPeriod + 1, @@ -286,14 +278,14 @@ func TestServer_FailToUpdate(t *testing.T) { }, }, } - spanMap, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, spanTestsFail.validatorIdx) + spanMap, err := db.ValidatorSpansMap(ctx, spanTestsFail.validatorIdx) if err != nil { t.Fatal(err) } - if _, _, err := slasherServer.DetectAndUpdateMinEpochSpan(ctx, spanTestsFail.sourceEpoch, spanTestsFail.targetEpoch, spanTestsFail.validatorIdx, spanMap); err == nil { + if _, _, err := detectAndUpdateMinEpochSpan(ctx, spanTestsFail.sourceEpoch, spanTestsFail.targetEpoch, spanMap); err == nil { t.Fatalf("Update should not support diff greater then weak subjectivity period: %v ", params.BeaconConfig().WeakSubjectivityPeriod) } - if _, _, err := slasherServer.DetectAndUpdateMaxEpochSpan(ctx, spanTestsFail.sourceEpoch, spanTestsFail.targetEpoch, spanTestsFail.validatorIdx, spanMap); err == nil { + if _, _, err := detectAndUpdateMaxEpochSpan(ctx, spanTestsFail.sourceEpoch, spanTestsFail.targetEpoch, spanMap); err == nil { t.Fatalf("Update should not support diff greater then weak subjectivity period: %v ", params.BeaconConfig().WeakSubjectivityPeriod) } diff --git a/slasher/rpc/detect_update_min_max_span.go b/slasher/detection/attestations.go similarity index 54% rename from slasher/rpc/detect_update_min_max_span.go rename to slasher/detection/attestations.go index 4625e0d197..a0fa55d29d 100644 --- a/slasher/rpc/detect_update_min_max_span.go +++ b/slasher/detection/attestations.go @@ -1,11 +1,14 @@ -package rpc +package detection import ( "context" "fmt" + "github.com/pkg/errors" + ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" slashpb "github.com/prysmaticlabs/prysm/proto/slashing" "github.com/prysmaticlabs/prysm/shared/params" + "go.opencensus.io/trace" ) // Detector is a function type used to implement the slashable surrounding/surrounded @@ -13,52 +16,62 @@ import ( type detectFn = func(attestationEpochSpan uint64, recorderEpochSpan *slashpb.MinMaxEpochSpan, sourceEpoch uint64) uint64 // detectMax is a function for maxDetector used to detect surrounding attestations. -func detectMax( - attestationEpochSpan uint64, - recorderEpochSpan *slashpb.MinMaxEpochSpan, - attestationSourceEpoch uint64, -) uint64 { +func detectMax(attEpochSpan uint64, recorderEpochSpan *slashpb.MinMaxEpochSpan, attSourceEpoch uint64) uint64 { maxSpan := uint64(recorderEpochSpan.MaxEpochSpan) - if maxSpan > attestationEpochSpan { - return maxSpan + attestationSourceEpoch + if maxSpan > attEpochSpan { + return maxSpan + attSourceEpoch } return 0 } -// detectMin is a function for minDetecter used to detect surrounded attestations. -func detectMin( - attestationEpochSpan uint64, - recorderEpochSpan *slashpb.MinMaxEpochSpan, - attestationSourceEpoch uint64, -) uint64 { +// detectMin is a function for minDetector used to detect surrounded attestations. +func detectMin(attEpochSpan uint64, recorderEpochSpan *slashpb.MinMaxEpochSpan, attSourceEpoch uint64) uint64 { minSpan := uint64(recorderEpochSpan.MinEpochSpan) - if minSpan > 0 && minSpan < attestationEpochSpan { - return minSpan + attestationSourceEpoch + if minSpan > 0 && minSpan < attEpochSpan { + return minSpan + attSourceEpoch } return 0 } -// DetectAndUpdateMaxEpochSpan is used to detect and update the max span of an incoming attestation. +// DetectAndUpdateSpans runs detection and updating for both min and max epoch spans, this is used for +// attestation slashing detection. +// Detailed here: https://github.com/protolambda/eth2-surround/blob/master/README.md#min-max-surround +func DetectAndUpdateSpans( + ctx context.Context, + att *ethpb.IndexedAttestation, + spanMap *slashpb.EpochSpanMap, +) (*slashpb.EpochSpanMap, uint64, uint64, error) { + ctx, span := trace.StartSpan(ctx, "Detection.DetectAndUpdateSpans") + defer span.End() + minTargetEpoch, spanMap, err := detectAndUpdateMinEpochSpan(ctx, att.Data.Source.Epoch, att.Data.Target.Epoch, spanMap) + if err != nil { + return nil, 0, 0, errors.Wrap(err, "failed to update min spans") + } + maxTargetEpoch, spanMap, err := detectAndUpdateMaxEpochSpan(ctx, att.Data.Source.Epoch, att.Data.Target.Epoch, spanMap) + if err != nil { + return nil, 0, 0, errors.Wrap(err, "failed to update max spans") + } + return spanMap, minTargetEpoch, maxTargetEpoch, nil +} + +// detectAndUpdateMaxEpochSpan is used to detect and update the max span of an incoming attestation. // This is used for detecting surrounding votes. // The max span is the span between the current attestation's source epoch and the furthest attestation's // target epoch that has a lower (earlier) source epoch. // Logic for this detection method was designed by https://github.com/protolambda // Detailed here: https://github.com/protolambda/eth2-surround/blob/master/README.md#min-max-surround -func (ss *Server) DetectAndUpdateMaxEpochSpan( +func detectAndUpdateMaxEpochSpan( ctx context.Context, source uint64, target uint64, - validatorIdx uint64, spanMap *slashpb.EpochSpanMap, ) (uint64, *slashpb.EpochSpanMap, error) { + ctx, span := trace.StartSpan(ctx, "Detection.detectAndUpdateMaxEpochSpan") + defer span.End() if target < source { - return 0, nil, fmt.Errorf( - "target: %d < source: %d ", - target, - source, - ) + return 0, nil, fmt.Errorf("target: %d < source: %d ", target, source) } - targetEpoch, span, spanMap, err := ss.detectSlashingByEpochSpan(source, target, spanMap, detectMax) + targetEpoch, minMaxSpan, spanMap, err := detectSlashingByEpochSpan(ctx, source, target, spanMap, detectMax) if err != nil { return 0, nil, err } @@ -67,7 +80,7 @@ func (ss *Server) DetectAndUpdateMaxEpochSpan( } for i := uint64(1); i < target-source; i++ { - val := uint32(span - i) + val := uint32(minMaxSpan - i) if _, ok := spanMap.EpochSpanMap[source+i]; !ok { spanMap.EpochSpanMap[source+i] = &slashpb.MinMaxEpochSpan{} } @@ -77,26 +90,24 @@ func (ss *Server) DetectAndUpdateMaxEpochSpan( break } } - if err := ss.SlasherDB.SaveValidatorSpansMap(ctx, validatorIdx, spanMap); err != nil { - return 0, nil, err - } return 0, spanMap, nil } -// DetectAndUpdateMinEpochSpan is used to detect surrounded votes and update the min epoch span +// detectAndUpdateMinEpochSpan is used to detect surrounded votes and update the min epoch span // of an incoming attestation. // The min span is the span between the current attestations target epoch and the // closest attestation's target distance. // // Logic is following the detection method designed by https://github.com/protolambda // Detailed here: https://github.com/protolambda/eth2-surround/blob/master/README.md#min-max-surround -func (ss *Server) DetectAndUpdateMinEpochSpan( +func detectAndUpdateMinEpochSpan( ctx context.Context, source uint64, target uint64, - validatorIdx uint64, spanMap *slashpb.EpochSpanMap, ) (uint64, *slashpb.EpochSpanMap, error) { + ctx, span := trace.StartSpan(ctx, "Detection.detectAndUpdateMinEpochSpan") + defer span.End() if target < source { return 0, nil, fmt.Errorf( "target: %d < source: %d ", @@ -104,7 +115,7 @@ func (ss *Server) DetectAndUpdateMinEpochSpan( source, ) } - targetEpoch, _, spanMap, err := ss.detectSlashingByEpochSpan(source, target, spanMap, detectMin) + targetEpoch, _, spanMap, err := detectSlashingByEpochSpan(ctx, source, target, spanMap, detectMin) if err != nil { return 0, nil, err } @@ -133,21 +144,25 @@ func (ss *Server) DetectAndUpdateMinEpochSpan( // in the db by checking either the closest attestation target or the furthest // attestation target. This method receives a detector function in order to be used // for both surrounding and surrounded vote cases. -func (ss *Server) detectSlashingByEpochSpan( - source, +func detectSlashingByEpochSpan( + ctx context.Context, + source uint64, target uint64, spanMap *slashpb.EpochSpanMap, detector detectFn, ) (uint64, uint64, *slashpb.EpochSpanMap, error) { - span := target - source - if span > params.BeaconConfig().WeakSubjectivityPeriod { - return 0, span, nil, fmt.Errorf("target: %d - source: %d > weakSubjectivityPeriod", + ctx, span := trace.StartSpan(ctx, "Detection.detectSlashingByEpochSpan") + defer span.End() + minMaxSpan := target - source + if minMaxSpan > params.BeaconConfig().WeakSubjectivityPeriod { + return 0, minMaxSpan, nil, fmt.Errorf( + "target: %d - source: %d > weakSubjectivityPeriod", params.BeaconConfig().WeakSubjectivityPeriod, - span, + minMaxSpan, ) } if _, ok := spanMap.EpochSpanMap[source]; ok { - return detector(span, spanMap.EpochSpanMap[source], source), span, spanMap, nil + return detector(minMaxSpan, spanMap.EpochSpanMap[source], source), minMaxSpan, spanMap, nil } - return 0, span, spanMap, nil + return 0, minMaxSpan, spanMap, nil } diff --git a/slasher/detection/attestations_bench_test.go b/slasher/detection/attestations_bench_test.go new file mode 100644 index 0000000000..0da4e20c23 --- /dev/null +++ b/slasher/detection/attestations_bench_test.go @@ -0,0 +1,101 @@ +package detection + +import ( + "context" + "flag" + "fmt" + "testing" + + testDB "github.com/prysmaticlabs/prysm/slasher/db/testing" + "github.com/prysmaticlabs/prysm/slasher/flags" + "github.com/urfave/cli" +) + +func BenchmarkMinSpan(b *testing.B) { + diffs := []uint64{2, 10, 100, 1000, 10000, 53999} + app := cli.NewApp() + set := flag.NewFlagSet("test", 0) + set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") + db := testDB.SetupSlasherDB(b, cli.NewContext(app, set, nil)) + defer testDB.TeardownSlasherDB(b, db) + ctx := context.Background() + + for _, diff := range diffs { + b.Run(fmt.Sprintf("MinSpan_diff_%d", diff), func(ib *testing.B) { + for i := uint64(0); i < uint64(ib.N); i++ { + spanMap, err := db.ValidatorSpansMap(ctx, i%10) + if err != nil { + b.Fatal(err) + } + _, _, err = detectAndUpdateMinEpochSpan(ctx, i, i+diff, spanMap) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkMaxSpan(b *testing.B) { + diffs := []uint64{2, 10, 100, 1000, 10000, 53999} + app := cli.NewApp() + set := flag.NewFlagSet("test", 0) + set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") + db := testDB.SetupSlasherDB(b, cli.NewContext(app, set, nil)) + defer testDB.TeardownSlasherDB(b, db) + ctx := context.Background() + + for _, diff := range diffs { + b.Run(fmt.Sprintf("MaxSpan_diff_%d", diff), func(ib *testing.B) { + for i := uint64(0); i < uint64(ib.N); i++ { + spanMap, err := db.ValidatorSpansMap(ctx, i%10) + if err != nil { + b.Fatal(err) + } + _, _, err = detectAndUpdateMaxEpochSpan(ctx, diff, diff+i, spanMap) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkDetectSpan(b *testing.B) { + diffs := []uint64{2, 10, 100, 1000, 10000, 53999} + app := cli.NewApp() + set := flag.NewFlagSet("test", 0) + set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") + db := testDB.SetupSlasherDB(b, cli.NewContext(app, set, nil)) + defer testDB.TeardownSlasherDB(b, db) + ctx := context.Background() + + for _, diff := range diffs { + b.Run(fmt.Sprintf("Detect_MaxSpan_diff_%d", diff), func(ib *testing.B) { + for i := uint64(0); i < uint64(ib.N); i++ { + spanMap, err := db.ValidatorSpansMap(ctx, i%10) + if err != nil { + b.Fatal(err) + } + _, _, _, err = detectSlashingByEpochSpan(ctx, i, i+diff, spanMap, detectMax) + if err != nil { + b.Fatal(err) + } + } + }) + } + for _, diff := range diffs { + b.Run(fmt.Sprintf("Detect_MinSpan_diff_%d", diff), func(ib *testing.B) { + for i := uint64(0); i < uint64(ib.N); i++ { + spanMap, err := db.ValidatorSpansMap(ctx, i%10) + if err != nil { + b.Fatal(err) + } + _, _, _, err = detectSlashingByEpochSpan(ctx, i, i+diff, spanMap, detectMin) + if err != nil { + b.Fatal(err) + } + } + }) + } +} diff --git a/slasher/rpc/BUILD.bazel b/slasher/rpc/BUILD.bazel index 1897922d4b..e71fcafd49 100644 --- a/slasher/rpc/BUILD.bazel +++ b/slasher/rpc/BUILD.bazel @@ -2,19 +2,16 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") go_library( name = "go_default_library", - srcs = [ - "detect_update_min_max_span.go", - "server.go", - ], + srcs = ["server.go"], importpath = "github.com/prysmaticlabs/prysm/slasher/rpc", visibility = ["//visibility:public"], deps = [ "//beacon-chain/core/helpers:go_default_library", "//proto/slashing:go_default_library", "//shared/hashutil:go_default_library", - "//shared/params:go_default_library", "//slasher/db/kv:go_default_library", "//slasher/db/types:go_default_library", + "//slasher/detection:go_default_library", "@com_github_gogo_protobuf//proto:go_default_library", "@com_github_pkg_errors//:go_default_library", "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library", @@ -24,11 +21,7 @@ go_library( go_test( name = "go_default_test", - srcs = [ - "detect_update_min_max_span_test.go", - "server_test.go", - "slashing_bench_test.go", - ], + srcs = ["server_test.go"], embed = [":go_default_library"], deps = [ "//proto/slashing:go_default_library", diff --git a/slasher/rpc/server.go b/slasher/rpc/server.go index 1e0175babe..24c906c61f 100644 --- a/slasher/rpc/server.go +++ b/slasher/rpc/server.go @@ -13,6 +13,7 @@ import ( "github.com/prysmaticlabs/prysm/shared/hashutil" "github.com/prysmaticlabs/prysm/slasher/db/kv" "github.com/prysmaticlabs/prysm/slasher/db/types" + "github.com/prysmaticlabs/prysm/slasher/detection" log "github.com/sirupsen/logrus" ) @@ -110,13 +111,7 @@ func (ss *Server) UpdateSpanMaps(ctx context.Context, req *ethpb.IndexedAttestat wg.Done() return } - _, spanMap, err = ss.DetectAndUpdateMinEpochSpan(ctx, req.Data.Source.Epoch, req.Data.Target.Epoch, i, spanMap) - if err != nil { - er <- err - wg.Done() - return - } - _, spanMap, err = ss.DetectAndUpdateMaxEpochSpan(ctx, req.Data.Source.Epoch, req.Data.Target.Epoch, i, spanMap) + spanMap, _, _, err = detection.DetectAndUpdateSpans(ctx, req, spanMap) if err != nil { er <- err wg.Done() @@ -193,13 +188,9 @@ func (ss *Server) DetectSurroundVotes(ctx context.Context, validatorIdx uint64, if err != nil { return nil, errors.Wrap(err, "failed to get validator spans map") } - minTargetEpoch, spanMap, err := ss.DetectAndUpdateMinEpochSpan(ctx, req.Data.Source.Epoch, req.Data.Target.Epoch, validatorIdx, spanMap) + spanMap, minTargetEpoch, maxTargetEpoch, err := detection.DetectAndUpdateSpans(ctx, req, spanMap) if err != nil { - return nil, errors.Wrap(err, "failed to update min spans") - } - maxTargetEpoch, spanMap, err := ss.DetectAndUpdateMaxEpochSpan(ctx, req.Data.Source.Epoch, req.Data.Target.Epoch, validatorIdx, spanMap) - if err != nil { - return nil, errors.Wrap(err, "failed to update max spans") + return nil, errors.Wrap(err, "failed to update spans") } if err := ss.SlasherDB.SaveValidatorSpansMap(ctx, validatorIdx, spanMap); err != nil { return nil, errors.Wrap(err, "failed to save validator spans map") diff --git a/slasher/rpc/server_test.go b/slasher/rpc/server_test.go index 79e5930ebe..023f36253e 100644 --- a/slasher/rpc/server_test.go +++ b/slasher/rpc/server_test.go @@ -12,6 +12,7 @@ import ( "github.com/prysmaticlabs/prysm/shared/params" testDB "github.com/prysmaticlabs/prysm/slasher/db/testing" "github.com/prysmaticlabs/prysm/slasher/db/types" + "github.com/prysmaticlabs/prysm/slasher/flags" "github.com/urfave/cli" ) @@ -698,5 +699,44 @@ func TestServer_Store_100_Attestations(t *testing.T) { t.Error(err) } t.Logf("DB size is: %d", s) - +} + +func BenchmarkCheckAttestations(b *testing.B) { + app := cli.NewApp() + set := flag.NewFlagSet("test", 0) + set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") + ctx := cli.NewContext(app, set, nil) + db := testDB.SetupSlasherDB(b, ctx) + defer testDB.TeardownSlasherDB(b, db) + context := context.Background() + + slasherServer := &Server{ + ctx: context, + SlasherDB: db, + } + var cb []uint64 + for i := uint64(0); i < 100; i++ { + cb = append(cb, i) + } + ia1 := ðpb.IndexedAttestation{ + AttestingIndices: cb, + Signature: make([]byte, 96), + Data: ðpb.AttestationData{ + CommitteeIndex: 0, + BeaconBlockRoot: make([]byte, 32), + Source: ðpb.Checkpoint{Epoch: 2}, + Target: ðpb.Checkpoint{Epoch: 4}, + }, + } + b.ResetTimer() + for i := uint64(0); i < uint64(b.N); i++ { + ia1.Data.Target.Epoch = i + 1 + ia1.Data.Source.Epoch = i + ia1.Data.Slot = (i + 1) * params.BeaconConfig().SlotsPerEpoch + root := []byte(strconv.Itoa(int(i))) + ia1.Data.BeaconBlockRoot = append(root, ia1.Data.BeaconBlockRoot[len(root):]...) + if _, err := slasherServer.IsSlashableAttestation(context, ia1); err != nil { + b.Errorf("Could not call RPC method: %v", err) + } + } } diff --git a/slasher/rpc/slashing_bench_test.go b/slasher/rpc/slashing_bench_test.go deleted file mode 100644 index aa4033ac2f..0000000000 --- a/slasher/rpc/slashing_bench_test.go +++ /dev/null @@ -1,160 +0,0 @@ -package rpc - -import ( - "context" - "flag" - "fmt" - "strconv" - "testing" - - ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/params" - testDB "github.com/prysmaticlabs/prysm/slasher/db/testing" - "github.com/prysmaticlabs/prysm/slasher/flags" - "github.com/urfave/cli" -) - -var appFlags = []cli.Flag{ - flags.CertFlag, - flags.RPCPort, - flags.KeyFlag, - flags.UseSpanCacheFlag, -} - -func BenchmarkMinSpan(b *testing.B) { - diffs := []uint64{2, 10, 100, 1000, 10000, 53999} - app := cli.NewApp() - set := flag.NewFlagSet("test", 0) - set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") - db := testDB.SetupSlasherDB(b, cli.NewContext(app, set, nil)) - defer testDB.TeardownSlasherDB(b, db) - ctx := context.Background() - - slasherServer := &Server{ - SlasherDB: db, - } - for _, diff := range diffs { - b.Run(fmt.Sprintf("MinSpan_diff_%d", diff), func(ib *testing.B) { - for i := uint64(0); i < uint64(ib.N); i++ { - spanMap, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, i%10) - if err != nil { - b.Fatal(err) - } - _, _, err = slasherServer.DetectAndUpdateMinEpochSpan(ctx, i, i+diff, i%10, spanMap) - if err != nil { - b.Fatal(err) - } - } - }) - } -} - -func BenchmarkMaxSpan(b *testing.B) { - diffs := []uint64{2, 10, 100, 1000, 10000, 53999} - app := cli.NewApp() - set := flag.NewFlagSet("test", 0) - set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") - db := testDB.SetupSlasherDB(b, cli.NewContext(app, set, nil)) - defer testDB.TeardownSlasherDB(b, db) - ctx := context.Background() - - slasherServer := &Server{ - SlasherDB: db, - } - for _, diff := range diffs { - b.Run(fmt.Sprintf("MaxSpan_diff_%d", diff), func(ib *testing.B) { - for i := uint64(0); i < uint64(ib.N); i++ { - spanMap, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, i%10) - if err != nil { - b.Fatal(err) - } - _, _, err = slasherServer.DetectAndUpdateMaxEpochSpan(ctx, diff, diff+i, i%10, spanMap) - if err != nil { - b.Fatal(err) - } - } - }) - } -} - -func BenchmarkDetectSpan(b *testing.B) { - diffs := []uint64{2, 10, 100, 1000, 10000, 53999} - app := cli.NewApp() - set := flag.NewFlagSet("test", 0) - set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") - db := testDB.SetupSlasherDB(b, cli.NewContext(app, set, nil)) - defer testDB.TeardownSlasherDB(b, db) - ctx := context.Background() - - slasherServer := &Server{ - SlasherDB: db, - } - for _, diff := range diffs { - b.Run(fmt.Sprintf("Detect_MaxSpan_diff_%d", diff), func(ib *testing.B) { - for i := uint64(0); i < uint64(ib.N); i++ { - spanMap, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, i%10) - if err != nil { - b.Fatal(err) - } - _, _, _, err = slasherServer.detectSlashingByEpochSpan(i, i+diff, spanMap, detectMax) - if err != nil { - b.Fatal(err) - } - } - }) - } - for _, diff := range diffs { - b.Run(fmt.Sprintf("Detect_MinSpan_diff_%d", diff), func(ib *testing.B) { - for i := uint64(0); i < uint64(ib.N); i++ { - spanMap, err := slasherServer.SlasherDB.ValidatorSpansMap(ctx, i%10) - if err != nil { - b.Fatal(err) - } - _, _, _, err = slasherServer.detectSlashingByEpochSpan(i, i+diff, spanMap, detectMin) - if err != nil { - b.Fatal(err) - } - } - }) - } -} - -func BenchmarkCheckAttestations(b *testing.B) { - app := cli.NewApp() - set := flag.NewFlagSet("test", 0) - set.Bool(flags.UseSpanCacheFlag.Name, true, "enable span map cache") - ctx := cli.NewContext(app, set, nil) - db := testDB.SetupSlasherDB(b, ctx) - defer testDB.TeardownSlasherDB(b, db) - context := context.Background() - slasherServer := &Server{ - ctx: context, - SlasherDB: db, - } - var cb []uint64 - for i := uint64(0); i < 100; i++ { - cb = append(cb, i) - } - ia1 := ðpb.IndexedAttestation{ - AttestingIndices: cb, - Signature: make([]byte, 96), - Data: ðpb.AttestationData{ - CommitteeIndex: 0, - BeaconBlockRoot: make([]byte, 32), - Source: ðpb.Checkpoint{Epoch: 2}, - Target: ðpb.Checkpoint{Epoch: 4}, - }, - } - b.ResetTimer() - for i := uint64(0); i < uint64(b.N); i++ { - ia1.Data.Target.Epoch = i + 1 - ia1.Data.Source.Epoch = i - ia1.Data.Slot = (i + 1) * params.BeaconConfig().SlotsPerEpoch - root := []byte(strconv.Itoa(int(i))) - ia1.Data.BeaconBlockRoot = append(root, ia1.Data.BeaconBlockRoot[len(root):]...) - if _, err := slasherServer.IsSlashableAttestation(context, ia1); err != nil { - b.Errorf("Could not call RPC method: %v", err) - } - } - -} diff --git a/validator/client/service_test.go b/validator/client/service_test.go index 9a9e75eb90..63a596ea47 100644 --- a/validator/client/service_test.go +++ b/validator/client/service_test.go @@ -68,7 +68,7 @@ func TestStop_CancelsContext(t *testing.T) { select { case <-time.After(1 * time.Second): - t.Error("ctx not canceled within 1s") + t.Error("Context not canceled within 1s") case <-vs.ctx.Done(): } }