mirror of
https://github.com/nspcc-dev/neo-go.git
synced 2024-11-23 13:38:35 +00:00
8277b7a19a
It doesn't make any sense, in some situations it leads to a number of
goroutines created that will Persist one after another (as we can't Persist
concurrently). We can manage it better in a single thread.
This doesn't change performance in any way, but somewhat reduces resource
consumption. It was tested neo-bench (single node, 10 workers, LevelDB) on two
machines and block dump processing (RC4 testnet up to 62800 with VerifyBlocks
set to false) on i7-8565U.
Reference (b9be892bf9):
Ryzen 9 5950X:
RPS 27747.349 27407.726 27520.210 ≈ 27558 ± 0.63%
TPS 26992.010 26993.468 27010.966 ≈ 26999 ± 0.04%
CPU % 28.928 28.096 29.105 ≈ 28.7 ± 1.88%
Mem MB 760.385 726.320 756.118 ≈ 748 ± 2.48%
Core i7-8565U:
RPS 7783.229 7628.409 7542.340 ≈ 7651 ± 1.60%
TPS 7708.436 7607.397 7489.459 ≈ 7602 ± 1.44%
CPU % 74.899 71.020 72.697 ≈ 72.9 ± 2.67%
Mem MB 438.047 436.967 416.350 ≈ 430 ± 2.84%
DB restore:
real 0m20.838s 0m21.895s 0m21.794s ≈ 21.51 ± 2.71%
user 0m39.091s 0m40.565s 0m41.493s ≈ 40.38 ± 3.00%
sys 0m3.184s 0m2.923s 0m3.062s ≈ 3.06 ± 4.27%
Patched:
Ryzen 9 5950X:
RPS 27636.957 27246.911 27462.036 ≈ 27449 ± 0.71% ↓ 0.40%
TPS 27003.672 26993.468 27011.696 ≈ 27003 ± 0.03% ↑ 0.01%
CPU % 28.562 28.475 28.012 ≈ 28.3 ± 1.04% ↓ 1.39%
Mem MB 627.007 648.110 794.895 ≈ 690 ± 13.25% ↓ 7.75%
Core i7-8565U:
RPS 7497.210 7527.797 7897.532 ≈ 7641 ± 2.92% ↓ 0.13%
TPS 7461.128 7482.678 7841.723 ≈ 7595 ± 2.81% ↓ 0.09%
CPU % 71.559 73.423 69.005 ≈ 71.3 ± 3.11% ↓ 2.19%
Mem MB 393.090 395.899 482.264 ≈ 424 ± 11.96% ↓ 1.40%
DB restore:
real 0m20.773s 0m21.583s 0m20.522s ≈ 20.96 ± 2.65% ↓ 2.56%
user 0m39.322s 0m42.268s 0m38.626s ≈ 40.07 ± 4.82% ↓ 0.77%
sys 0m3.006s 0m3.597s 0m3.042s ≈ 3.22 ± 10.31% ↑ 5.23%
199 lines
6.7 KiB
Go
199 lines
6.7 KiB
Go
package core
|
|
|
|
import (
|
|
"math/big"
|
|
"testing"
|
|
|
|
"github.com/nspcc-dev/neo-go/internal/random"
|
|
"github.com/nspcc-dev/neo-go/internal/testchain"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/interop"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/native"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
|
|
"github.com/nspcc-dev/neo-go/pkg/wallet"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func transferFundsToCommittee(t *testing.T, chain *Blockchain) {
|
|
transferTokenFromMultisigAccount(t, chain, testchain.CommitteeScriptHash(),
|
|
chain.contracts.GAS.Hash, 1000_00000000)
|
|
}
|
|
|
|
func testGetSet(t *testing.T, chain *Blockchain, hash util.Uint160, name string, defaultValue, minValue, maxValue int64) {
|
|
getName := "get" + name
|
|
setName := "set" + name
|
|
|
|
transferFundsToCommittee(t, chain)
|
|
t.Run("set, not signed by committee", func(t *testing.T) {
|
|
signer, err := wallet.NewAccount()
|
|
require.NoError(t, err)
|
|
invokeRes, err := invokeContractMethodBy(t, chain, signer, hash, setName, minValue+1)
|
|
require.NoError(t, err)
|
|
checkFAULTState(t, invokeRes)
|
|
})
|
|
|
|
t.Run("get, defult value", func(t *testing.T) {
|
|
res, err := invokeContractMethod(chain, 100000000, hash, getName)
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.Make(defaultValue))
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("set, too small value", func(t *testing.T) {
|
|
res, err := invokeContractMethodGeneric(chain, 100000000, hash, setName, true, minValue-1)
|
|
require.NoError(t, err)
|
|
checkFAULTState(t, res)
|
|
})
|
|
|
|
if maxValue != 0 {
|
|
t.Run("set, too large value", func(t *testing.T) {
|
|
// use big.Int because max can be `math.MaxInt64`
|
|
max := big.NewInt(maxValue)
|
|
max.Add(max, big.NewInt(1))
|
|
res, err := invokeContractMethodGeneric(chain, 100000000, hash, setName, true, max)
|
|
require.NoError(t, err)
|
|
checkFAULTState(t, res)
|
|
})
|
|
}
|
|
|
|
t.Run("set, success", func(t *testing.T) {
|
|
// Set and get in the same block.
|
|
txSet, err := prepareContractMethodInvokeGeneric(chain, 100000000, hash, setName, true, defaultValue+1)
|
|
require.NoError(t, err)
|
|
txGet1, err := prepareContractMethodInvoke(chain, 100000000, hash, getName)
|
|
require.NoError(t, err)
|
|
aers, err := persistBlock(chain, txSet, txGet1)
|
|
require.NoError(t, err)
|
|
checkResult(t, aers[0], stackitem.Null{})
|
|
if name != "GasPerBlock" { // GasPerBlock is set on the next block
|
|
checkResult(t, aers[1], stackitem.Make(defaultValue+1))
|
|
}
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
|
|
// Get in the next block.
|
|
res, err := invokeContractMethod(chain, 100000000, hash, getName)
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.Make(defaultValue+1))
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
func TestFeePerByte(t *testing.T) {
|
|
chain := newTestChain(t)
|
|
|
|
t.Run("get, internal method", func(t *testing.T) {
|
|
n := chain.contracts.Policy.GetFeePerByteInternal(chain.dao)
|
|
require.Equal(t, 1000, int(n))
|
|
})
|
|
|
|
testGetSet(t, chain, chain.contracts.Policy.Hash, "FeePerByte", 1000, 0, 100_000_000)
|
|
}
|
|
|
|
func TestExecFeeFactor(t *testing.T) {
|
|
chain := newTestChain(t)
|
|
|
|
t.Run("get, internal method", func(t *testing.T) {
|
|
n := chain.contracts.Policy.GetExecFeeFactorInternal(chain.dao)
|
|
require.EqualValues(t, interop.DefaultBaseExecFee, n)
|
|
})
|
|
|
|
testGetSet(t, chain, chain.contracts.Policy.Hash, "ExecFeeFactor", interop.DefaultBaseExecFee, 1, 1000)
|
|
}
|
|
|
|
func TestStoragePrice(t *testing.T) {
|
|
chain := newTestChain(t)
|
|
|
|
t.Run("get, internal method", func(t *testing.T) {
|
|
n := chain.contracts.Policy.GetStoragePriceInternal(chain.dao)
|
|
require.Equal(t, int64(native.DefaultStoragePrice), n)
|
|
})
|
|
|
|
testGetSet(t, chain, chain.contracts.Policy.Hash, "StoragePrice", native.DefaultStoragePrice, 1, 10000000)
|
|
}
|
|
|
|
func TestBlockedAccounts(t *testing.T) {
|
|
chain := newTestChain(t)
|
|
account := util.Uint160{1, 2, 3}
|
|
policyHash := chain.contracts.Policy.Metadata().Hash
|
|
|
|
transferTokenFromMultisigAccount(t, chain, testchain.CommitteeScriptHash(),
|
|
chain.contracts.GAS.Hash, 100_00000000)
|
|
|
|
t.Run("isBlocked, internal method", func(t *testing.T) {
|
|
isBlocked := chain.contracts.Policy.IsBlockedInternal(chain.dao, random.Uint160())
|
|
require.Equal(t, false, isBlocked)
|
|
})
|
|
|
|
t.Run("isBlocked, contract method", func(t *testing.T) {
|
|
res, err := invokeContractMethod(chain, 100000000, policyHash, "isBlocked", random.Uint160())
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.NewBool(false))
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("block-unblock account", func(t *testing.T) {
|
|
res, err := invokeContractMethodGeneric(chain, 100000000, policyHash, "blockAccount", true, account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.NewBool(true))
|
|
|
|
isBlocked := chain.contracts.Policy.IsBlockedInternal(chain.dao, account)
|
|
require.Equal(t, isBlocked, true)
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
|
|
res, err = invokeContractMethodGeneric(chain, 100000000, policyHash, "unblockAccount", true, account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.NewBool(true))
|
|
|
|
isBlocked = chain.contracts.Policy.IsBlockedInternal(chain.dao, account)
|
|
require.Equal(t, false, isBlocked)
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("double-block", func(t *testing.T) {
|
|
// block
|
|
res, err := invokeContractMethodGeneric(chain, 100000000, policyHash, "blockAccount", true, account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.NewBool(true))
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
|
|
// double-block should fail
|
|
res, err = invokeContractMethodGeneric(chain, 100000000, policyHash, "blockAccount", true, account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.NewBool(false))
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
|
|
// unblock
|
|
res, err = invokeContractMethodGeneric(chain, 100000000, policyHash, "unblockAccount", true, account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.NewBool(true))
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
|
|
// unblock the same account should fail as we don't have it blocked
|
|
res, err = invokeContractMethodGeneric(chain, 100000000, policyHash, "unblockAccount", true, account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkResult(t, res, stackitem.NewBool(false))
|
|
_, err = chain.persist()
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("not signed by committee", func(t *testing.T) {
|
|
signer, err := wallet.NewAccount()
|
|
require.NoError(t, err)
|
|
invokeRes, err := invokeContractMethodBy(t, chain, signer, policyHash, "blockAccount", account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkFAULTState(t, invokeRes)
|
|
|
|
invokeRes, err = invokeContractMethodBy(t, chain, signer, policyHash, "unblockAccount", account.BytesBE())
|
|
require.NoError(t, err)
|
|
checkFAULTState(t, invokeRes)
|
|
})
|
|
}
|