[Feeds] Add benchmark endblock (#148)

* add max signal id characters

* deactivate using block height

* add benchmark test for endblock of feeds module

* add benchmark for MsgSubmitPrices

* calculate supported feeds every n blocks

* change default block update param

* fix benchmark

* using type Signal for signal-total-power

* add check err in init genesis

* fix test

* handle error in test

---------

Co-authored-by: colmazia <[email protected]>

Author: RogerKSI

benchmark/feeds_bench_test.go

@@ -0,0 +1,215 @@
+package benchmark
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/stretchr/testify/require"
+
+	bandtesting "github.com/bandprotocol/chain/v2/testing"
+	"github.com/bandprotocol/chain/v2/x/feeds/types"
+	oracletypes "github.com/bandprotocol/chain/v2/x/oracle/types"
+)
+
+// benchmark test for delivering MsgSubmitPrices
+func BenchmarkSubmitPricesDeliver(b *testing.B) {
+	b.ResetTimer()
+	b.StopTimer()
+
+	for i := 0; i < b.N; i++ {
+		ba := InitializeBenchmarkApp(b, -1)
+
+		numVals := ba.StakingKeeper.GetParams(ba.Ctx).MaxValidators
+
+		vals, err := generateValidators(ba, int(numVals))
+		require.NoError(b, err)
+
+		err = setupFeeds(ba)
+		require.NoError(b, err)
+
+		ba.CallBeginBlock()
+
+		txs := []sdk.Tx{}
+		for _, val := range vals {
+			tx := GenSequenceOfTxs(
+				ba.TxConfig,
+				GenMsgSubmitPrices(
+					val,
+					ba.FeedsKeeper.GetSupportedFeeds(ba.Ctx).Feeds,
+					ba.Ctx.BlockTime().Unix(),
+				),
+				val,
+				1,
+			)[0]
+
+			txs = append(txs, tx)
+		}
+
+		for txIdx, tx := range txs {
+			b.StartTimer()
+			gasInfo, _, err := ba.CallDeliver(tx)
+			b.StopTimer()
+			if err != nil {
+				require.NoError(b, err)
+			}
+			if i == 0 && txIdx == 0 {
+				fmt.Println("\tCosmos Gas used:", gasInfo.GasUsed)
+			}
+		}
+
+		ba.CallEndBlock()
+		ba.Commit()
+	}
+}
+
+// benchmark test for endblock of feeds module
+func BenchmarkFeedsEndBlock(b *testing.B) {
+	ba := InitializeBenchmarkApp(b, -1)
+
+	numVals := ba.StakingKeeper.GetParams(ba.Ctx).MaxValidators
+
+	vals, err := generateValidators(ba, int(numVals))
+	require.NoError(b, err)
+
+	err = setupFeeds(ba)
+	require.NoError(b, err)
+
+	err = setupValidatorPrices(ba, vals)
+	require.NoError(b, err)
+
+	b.ResetTimer()
+	b.StopTimer()
+
+	// benchmark endblock
+	for i := 0; i < b.N; i++ {
+		ba.CallBeginBlock()
+
+		// process endblock
+		b.StartTimer()
+		ba.CallEndBlock()
+		b.StopTimer()
+
+		ba.Commit()
+	}
+}
+
+func setupFeeds(ba *BenchmarkApp) error {
+	numFeeds := ba.FeedsKeeper.GetParams(ba.Ctx).MaxSupportedFeeds
+
+	ba.CallBeginBlock()
+
+	feeds := []types.Feed{}
+	for i := int64(0); i < numFeeds; i++ {
+		feeds = append(feeds, types.Feed{
+			SignalID:              fmt.Sprintf("signal.%d", i),
+			Interval:              60,
+			DeviationInThousandth: 5,
+		})
+	}
+	ba.FeedsKeeper.SetSupportedFeeds(ba.Ctx, feeds)
+
+	ba.CallEndBlock()
+	ba.Commit()
+
+	return nil
+}
+
+func setupValidatorPrices(ba *BenchmarkApp, vals []*Account) error {
+	sfs := ba.FeedsKeeper.GetSupportedFeeds(ba.Ctx)
+
+	ba.CallBeginBlock()
+	for _, feed := range sfs.Feeds {
+		for valIdx, val := range vals {
+			err := ba.FeedsKeeper.SetValidatorPrice(ba.Ctx, types.ValidatorPrice{
+				PriceStatus: types.PriceStatusAvailable,
+				Validator:   val.ValAddress.String(),
+				SignalID:    feed.SignalID,
+				Price:       (10000 + uint64(valIdx)) * 10e9,
+				Timestamp:   ba.Ctx.BlockTime().Unix(),
+			})
+			if err != nil {
+				return err
+			}
+		}
+	}
+	ba.CallEndBlock()
+	ba.Commit()
+
+	return nil
+}
+
+func generateValidators(ba *BenchmarkApp, num int) ([]*Account, error) {
+	// transfer money
+	ba.CallBeginBlock()
+
+	vals := []bandtesting.Account{}
+	for i := 0; i < num; i++ {
+		r := rand.New(rand.NewSource(int64(i)))
+		acc := bandtesting.CreateArbitraryAccount(r)
+		vals = append(vals, acc)
+
+		tx := GenSequenceOfTxs(
+			ba.TxConfig,
+			[]sdk.Msg{banktypes.NewMsgSend(ba.Sender.Address, acc.Address, sdk.NewCoins(sdk.NewCoin("uband", sdk.NewInt(200000000))))},
+			ba.Sender,
+			1,
+		)[0]
+
+		_, _, err := ba.CallDeliver(tx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	ba.CallEndBlock()
+	ba.Commit()
+
+	// apply to be a validator
+	ba.CallBeginBlock()
+
+	accs := []*Account{}
+	for _, val := range vals {
+		info := ba.AccountKeeper.GetAccount(ba.Ctx, val.Address)
+		acc := &Account{
+			Account: val,
+			Num:     info.GetAccountNumber(),
+			Seq:     info.GetSequence(),
+		}
+		accs = append(accs, acc)
+
+		msgCreateVal, err := stakingtypes.NewMsgCreateValidator(
+			val.ValAddress,
+			val.PubKey,
+			sdk.NewCoin("uband", sdk.NewInt(150000000)),
+			stakingtypes.NewDescription(val.Address.String(), val.Address.String(), "", "", ""),
+			stakingtypes.NewCommissionRates(sdk.NewDec(1), sdk.NewDec(1), sdk.NewDec(1)),
+			sdk.NewInt(1),
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		msgActivate := oracletypes.NewMsgActivate(val.ValAddress)
+
+		tx := GenSequenceOfTxs(
+			ba.TxConfig,
+			[]sdk.Msg{msgCreateVal, msgActivate},
+			acc,
+			1,
+		)[0]
+
+		_, _, err = ba.CallDeliver(tx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	ba.CallEndBlock()
+	ba.Commit()
+
+	return accs, nil
+}

benchmark/helper_test.go

@@ -19,6 +19,7 @@ import (
 
 	"github.com/bandprotocol/chain/v2/pkg/obi"
 	bandtesting "github.com/bandprotocol/chain/v2/testing"
+	feedstypes "github.com/bandprotocol/chain/v2/x/feeds/types"
 	oracletypes "github.com/bandprotocol/chain/v2/x/oracle/types"
 )
 
@@ -70,6 +71,25 @@ func GenMsgRequestData(
 	return []sdk.Msg{&msg}
 }
 
+func GenMsgSubmitPrices(
+	sender *Account,
+	feeds []feedstypes.Feed,
+	timestamp int64,
+) []sdk.Msg {
+	prices := []feedstypes.SubmitPrice{}
+	for _, feed := range feeds {
+		prices = append(prices, feedstypes.SubmitPrice{
+			PriceStatus: feedstypes.PriceStatusAvailable,
+			SignalID:    feed.SignalID,
+			Price:       60000,
+		})
+	}
+
+	msg := feedstypes.NewMsgSubmitPrices(sender.ValAddress.String(), timestamp, prices)
+
+	return []sdk.Msg{msg}
+}
+
 func GenMsgSend(
 	sender *Account,
 	receiver *Account,

testing/test_helpers.go

@@ -69,14 +69,15 @@ var (
 )
 
 var (
-	EmptyCoins          = sdk.Coins(nil)
-	Coins1uband         = sdk.NewCoins(sdk.NewInt64Coin("uband", 1))
-	Coins10uband        = sdk.NewCoins(sdk.NewInt64Coin("uband", 10))
-	Coins11uband        = sdk.NewCoins(sdk.NewInt64Coin("uband", 11))
-	Coins1000000uband   = sdk.NewCoins(sdk.NewInt64Coin("uband", 1000000))
-	Coins99999999uband  = sdk.NewCoins(sdk.NewInt64Coin("uband", 99999999))
-	Coins100000000uband = sdk.NewCoins(sdk.NewInt64Coin("uband", 100000000))
-	BadCoins            = []sdk.Coin{{Denom: "uband", Amount: sdk.NewInt(-1)}}
+	EmptyCoins              = sdk.Coins(nil)
+	Coins1uband             = sdk.NewCoins(sdk.NewInt64Coin("uband", 1))
+	Coins10uband            = sdk.NewCoins(sdk.NewInt64Coin("uband", 10))
+	Coins11uband            = sdk.NewCoins(sdk.NewInt64Coin("uband", 11))
+	Coins1000000uband       = sdk.NewCoins(sdk.NewInt64Coin("uband", 1000000))
+	Coins99999999uband      = sdk.NewCoins(sdk.NewInt64Coin("uband", 99999999))
+	Coins100000000uband     = sdk.NewCoins(sdk.NewInt64Coin("uband", 100000000))
+	Coins1000000000000uband = sdk.NewCoins(sdk.NewInt64Coin("uband", 1000000000000))
+	BadCoins                = []sdk.Coin{{Denom: "uband", Amount: sdk.NewInt(-1)}}
 )
 
 const (
@@ -139,14 +140,14 @@ func (app *TestingApp) GetTxConfig() client.TxConfig {
 func init() {
 	bandapp.SetBech32AddressPrefixesAndBip44CoinTypeAndSeal(sdk.GetConfig())
 	r := rand.New(rand.NewSource(time.Now().Unix()))
-	Owner = createArbitraryAccount(r)
-	Treasury = createArbitraryAccount(r)
-	FeePayer = createArbitraryAccount(r)
-	Alice = createArbitraryAccount(r)
-	Bob = createArbitraryAccount(r)
-	Carol = createArbitraryAccount(r)
+	Owner = CreateArbitraryAccount(r)
+	Treasury = CreateArbitraryAccount(r)
+	FeePayer = CreateArbitraryAccount(r)
+	Alice = CreateArbitraryAccount(r)
+	Bob = CreateArbitraryAccount(r)
+	Carol = CreateArbitraryAccount(r)
 	for i := 0; i < 3; i++ {
-		Validators = append(Validators, createArbitraryAccount(r))
+		Validators = append(Validators, CreateArbitraryAccount(r))
 	}
 
 	// Sorted list of validators is needed for ibctest when signing a commit block
@@ -180,7 +181,7 @@ func CreateTestApp(t *testing.T, autoActivate bool) (*TestingApp, sdk.Context) {
 	balances := []banktypes.Balance{
 		{
 			Address: Owner.Address.String(),
-			Coins:   Coins1000000uband,
+			Coins:   Coins1000000000000uband,
 		},
 		{Address: FeePayer.Address.String(), Coins: Coins100000000uband},
 		{Address: Alice.Address.String(), Coins: Coins1000000uband},
@@ -399,8 +400,8 @@ func SetupWithGenesisValSet(
 	return &TestingApp{app}
 }
 
-// createArbitraryAccount generates a random Account using a provided random number generator.
-func createArbitraryAccount(r *rand.Rand) Account {
+// CreateArbitraryAccount generates a random Account using a provided random number generator.
+func CreateArbitraryAccount(r *rand.Rand) Account {
 	privkeySeed := make([]byte, 12)
 	r.Read(privkeySeed)
 	privKey := secp256k1.GenPrivKeyFromSecret(privkeySeed)

x/feeds/keeper/keeper_feed_test.go

@@ -10,12 +10,12 @@ func (suite *KeeperTestSuite) TestGetSetSupportedFeeds() {
 		{
 			SignalID:              "crypto_price.bandusd",
 			Interval:              60,
-			DeviationInThousandth: 1000,
+			DeviationInThousandth: 5,
 		},
 		{
 			SignalID:              "crypto_price.atomusd",
 			Interval:              60,
-			DeviationInThousandth: 1000,
+			DeviationInThousandth: 5,
 		},
 	}
 	suite.feedsKeeper.SetSupportedFeeds(ctx, expFeed)