Merge pull request #768 from ava-labs/improve-cchain-snowman

Improve cchain snowman

Author: StephenButtolph

.ci/run_e2e_tests.sh

@@ -17,7 +17,7 @@ echo "Using Avalanche Image: $AVALANCHE_IMAGE"
 
 DOCKER_REPO="avaplatform"
 BYZANTINE_IMAGE="$DOCKER_REPO/avalanche-byzantine:v0.1.5-rc.1"
-TEST_SUITE_IMAGE="$DOCKER_REPO/avalanche-testing:v0.10.5-rc.2"
+TEST_SUITE_IMAGE="$DOCKER_REPO/avalanche-testing:v0.10.5-rc.3"
 
 # If Docker Credentials are not available skip the Byzantine Tests
 if [[ -z ${DOCKER_USERNAME} ]]; then

chains/atomic/shared_memory.go

@@ -276,6 +276,11 @@ func (s *state) RemoveValue(key []byte) error {
 		return s.valueDB.Put(key, valueBytes)
 	}
 
+	// Don't allow the removal of something that was already removed.
+	if !value.Present {
+		return errDuplicatedOperation
+	}
+
 	for _, trait := range value.Traits {
 		traitDB := prefixdb.New(trait, s.indexDB)
 		if err := traitDB.Delete(key); err != nil {

chains/atomic/shared_memory_test.go

@@ -14,11 +14,11 @@ import (
 )
 
 func TestSharedMemory(t *testing.T) {
+	assert := assert.New(t)
+
 	m := Memory{}
 	err := m.Initialize(logging.NoLog{}, memdb.New())
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(err)
 
 	chainID0 := ids.GenerateTestID()
 	chainID1 := ids.GenerateTestID()
@@ -34,7 +34,7 @@ func TestSharedMemory(t *testing.T) {
 			{3},
 		},
 	}})
-	assert.NoError(t, err)
+	assert.NoError(err)
 
 	err = sm0.Put(chainID1, []*Element{{
 		Key:   []byte{4},
@@ -44,33 +44,89 @@ func TestSharedMemory(t *testing.T) {
 			{3},
 		},
 	}})
-	assert.NoError(t, err)
+	assert.NoError(err)
 
 	values, _, _, err := sm0.Indexed(chainID1, [][]byte{{2}}, nil, nil, 1)
-	assert.NoError(t, err)
-	assert.Empty(t, values, "wrong indexed values returned")
+	assert.NoError(err)
+	assert.Empty(values, "wrong indexed values returned")
 
 	values, _, _, err = sm1.Indexed(chainID0, [][]byte{{2}}, nil, nil, 0)
-	assert.NoError(t, err)
-	assert.Empty(t, values, "wrong indexed values returned")
+	assert.NoError(err)
+	assert.Empty(values, "wrong indexed values returned")
 
 	values, _, _, err = sm1.Indexed(chainID0, [][]byte{{2}}, nil, nil, 1)
-	assert.NoError(t, err)
-	assert.Equal(t, [][]byte{{1}}, values, "wrong indexed values returned")
+	assert.NoError(err)
+	assert.Equal([][]byte{{1}}, values, "wrong indexed values returned")
 
 	values, _, _, err = sm1.Indexed(chainID0, [][]byte{{2}}, nil, nil, 2)
-	assert.NoError(t, err)
-	assert.Equal(t, [][]byte{{1}, {5}}, values, "wrong indexed values returned")
+	assert.NoError(err)
+	assert.Equal([][]byte{{1}, {5}}, values, "wrong indexed values returned")
 
 	values, _, _, err = sm1.Indexed(chainID0, [][]byte{{2}}, nil, nil, 3)
-	assert.NoError(t, err)
-	assert.Equal(t, [][]byte{{1}, {5}}, values, "wrong indexed values returned")
+	assert.NoError(err)
+	assert.Equal([][]byte{{1}, {5}}, values, "wrong indexed values returned")
 
 	values, _, _, err = sm1.Indexed(chainID0, [][]byte{{3}}, nil, nil, 3)
-	assert.NoError(t, err)
-	assert.Equal(t, [][]byte{{1}, {5}}, values, "wrong indexed values returned")
+	assert.NoError(err)
+	assert.Equal([][]byte{{1}, {5}}, values, "wrong indexed values returned")
 
 	values, _, _, err = sm1.Indexed(chainID0, [][]byte{{2}, {3}}, nil, nil, 3)
-	assert.NoError(t, err)
-	assert.Equal(t, [][]byte{{1}, {5}}, values, "wrong indexed values returned")
+	assert.NoError(err)
+	assert.Equal([][]byte{{1}, {5}}, values, "wrong indexed values returned")
+}
+
+func TestSharedMemoryCantDuplicatePut(t *testing.T) {
+	assert := assert.New(t)
+
+	m := Memory{}
+	err := m.Initialize(logging.NoLog{}, memdb.New())
+	assert.NoError(err)
+
+	chainID0 := ids.GenerateTestID()
+	chainID1 := ids.GenerateTestID()
+
+	sm := m.NewSharedMemory(chainID0)
+
+	err = sm.Put(chainID1, []*Element{
+		{
+			Key:   []byte{0},
+			Value: []byte{1},
+		},
+		{
+			Key:   []byte{0},
+			Value: []byte{2},
+		},
+	})
+	assert.Error(err, "shouldn't be able to write duplicated keys")
+
+	err = sm.Put(chainID1, []*Element{{
+		Key:   []byte{0},
+		Value: []byte{1},
+	}})
+	assert.NoError(err)
+
+	err = sm.Put(chainID1, []*Element{{
+		Key:   []byte{0},
+		Value: []byte{1},
+	}})
+	assert.Error(err, "shouldn't be able to write duplicated keys")
+}
+
+func TestSharedMemoryCantDuplicateRemove(t *testing.T) {
+	assert := assert.New(t)
+
+	m := Memory{}
+	err := m.Initialize(logging.NoLog{}, memdb.New())
+	assert.NoError(err)
+
+	chainID0 := ids.GenerateTestID()
+	chainID1 := ids.GenerateTestID()
+
+	sm := m.NewSharedMemory(chainID0)
+
+	err = sm.Remove(chainID1, [][]byte{{0}})
+	assert.NoError(err)
+
+	err = sm.Remove(chainID1, [][]byte{{0}})
+	assert.Error(err, "shouldn't be able to remove duplicated keys")
 }

main/keys.go

@@ -69,6 +69,7 @@ const (
 	snowAvalancheNumParentsKey      = "snow-avalanche-num-parents"
 	snowAvalancheBatchSizeKey       = "snow-avalanche-batch-size"
 	snowConcurrentRepollsKey        = "snow-concurrent-repolls"
+	snowOptimalProcessingKey        = "snow-optimal-processing"
 	snowEpochFirstTransition        = "snow-epoch-first-transition"
 	snowEpochDuration               = "snow-epoch-duration"
 	whitelistedSubnetsKey           = "whitelisted-subnets"

main/params.go

@@ -175,20 +175,20 @@ func avalancheFlagSet() *flag.FlagSet {
 	fs.Uint(maxNonStakerPendingMsgsKey, uint(router.DefaultMaxNonStakerPendingMsgs), "Maximum number of messages a non-staker is allowed to have pending.")
 	fs.Float64(stakerMsgReservedKey, router.DefaultStakerPortion, "Reserve a portion of the chain message queue's space for stakers.")
 	fs.Float64(stakerCPUReservedKey, router.DefaultStakerPortion, "Reserve a portion of the chain's CPU time for stakers.")
-	fs.Uint(maxPendingMsgsKey, 1024, "Maximum number of pending messages. Messages after this will be dropped.")
+	fs.Uint(maxPendingMsgsKey, 4096, "Maximum number of pending messages. Messages after this will be dropped.")
 
 	// Network Timeouts:
-	fs.Duration(networkInitialTimeoutKey, 5*time.Second, "Initial timeout value of the adaptive timeout manager, in nanoseconds.")
-	fs.Duration(networkMinimumTimeoutKey, 500*time.Millisecond, "Minimum timeout value of the adaptive timeout manager, in nanoseconds.")
-	fs.Duration(networkMaximumTimeoutKey, 10*time.Second, "Maximum timeout value of the adaptive timeout manager, in nanoseconds.")
-	fs.Duration(networkTimeoutIncreaseKey, 60*time.Millisecond, "Increase of network timeout after a failed request, in nanoseconds.")
-	fs.Duration(networkTimeoutReductionKey, 12*time.Millisecond, "Decrease of network timeout after a successful request, in nanoseconds.")
-	fs.Uint(sendQueueSizeKey, 1<<10, "Max number of messages waiting to be sent to peers.")
+	fs.Duration(networkInitialTimeoutKey, 5*time.Second, "Initial timeout value of the adaptive timeout manager.")
+	fs.Duration(networkMinimumTimeoutKey, 3*time.Second, "Minimum timeout value of the adaptive timeout manager.")
+	fs.Duration(networkMaximumTimeoutKey, 10*time.Second, "Maximum timeout value of the adaptive timeout manager.")
+	fs.Duration(networkTimeoutIncreaseKey, 100*time.Millisecond, "Increase of network timeout after a failed request.")
+	fs.Duration(networkTimeoutReductionKey, 5*time.Millisecond, "Decrease of network timeout after a successful request.")
+	fs.Uint(sendQueueSizeKey, 4096, "Max number of messages waiting to be sent to peers.")
 
 	// Benchlist Parameters:
 	fs.Int(benchlistFailThresholdKey, 10, "Number of consecutive failed queries before benchlisting a node.")
 	fs.Bool(benchlistPeerSummaryEnabledKey, false, "Enables peer specific query latency metrics.")
-	fs.Duration(benchlistDurationKey, time.Hour, "Amount of time a peer is benchlisted after surpassing the threshold.")
+	fs.Duration(benchlistDurationKey, 30*time.Minute, "Amount of time a peer is benchlisted after surpassing the threshold.")
 	fs.Duration(benchlistMinFailingDurationKey, 5*time.Minute, "Minimum amount of time messages to a peer must be failing before the peer is benched.")
 
 	// Plugins:
@@ -207,6 +207,7 @@ func avalancheFlagSet() *flag.FlagSet {
 	fs.Int(snowAvalancheNumParentsKey, 5, "Number of vertexes for reference from each new vertex")
 	fs.Int(snowAvalancheBatchSizeKey, 30, "Number of operations to batch in each new vertex")
 	fs.Int(snowConcurrentRepollsKey, 4, "Minimum number of concurrent polls for finalizing consensus")
+	fs.Int(snowOptimalProcessingKey, 50, "Optimal number of processing vertices in consensus")
 	fs.Int64(snowEpochFirstTransition, 1607626800, "Unix timestamp of the first epoch transaction, in seconds. Defaults to 12/10/2020 @ 7:00pm (UTC)")
 	fs.Duration(snowEpochDuration, 6*time.Hour, "Duration of each epoch")
 
@@ -282,6 +283,7 @@ func setNodeConfig(v *viper.Viper) error {
 	Config.ConsensusParams.Parents = v.GetInt(snowAvalancheNumParentsKey)
 	Config.ConsensusParams.BatchSize = v.GetInt(snowAvalancheBatchSizeKey)
 	Config.ConsensusParams.ConcurrentRepolls = v.GetInt(snowConcurrentRepollsKey)
+	Config.ConsensusParams.OptimalProcessing = v.GetInt(snowOptimalProcessingKey)
 
 	Config.ConsensusGossipFrequency = v.GetDuration(consensusGossipFrequencyKey)
 	Config.ConsensusShutdownTimeout = v.GetDuration(consensusShutdownTimeoutKey)

node/node.go

@@ -67,7 +67,7 @@ var (
 	genesisHashKey = []byte("genesisID")
 
 	// Version is the version of this code
-	Version                 = version.NewDefaultVersion(constants.PlatformName, 1, 1, 5)
+	Version                 = version.NewDefaultVersion(constants.PlatformName, 1, 2, 0)
 	versionParser           = version.NewDefaultParser()
 	beaconConnectionTimeout = 1 * time.Minute
 )

scripts/build_coreth.sh

@@ -13,7 +13,7 @@ BUILD_DIR="$AVALANCHE_PATH/build" # Where binaries go
 PLUGIN_DIR="$BUILD_DIR/plugins" # Where plugin binaries (namely coreth) go
 BINARY_PATH="$PLUGIN_DIR/evm"
 
-CORETH_VER="v0.3.22"
+CORETH_VER="v0.3.23"
 
 CORETH_PATH="$GOPATH/pkg/mod/github.com/ava-labs/coreth@$CORETH_VER"
 

snow/consensus/avalanche/consensus.go

@@ -28,6 +28,9 @@ type Consensus interface {
 	// Returns the parameters that describe this avalanche instance
 	Parameters() Parameters
 
+	// Returns the number of vertices processing
+	NumProcessing() int
+
 	// Returns true if the transaction is virtuous.
 	// That is, no transaction has been added that conflicts with it
 	IsVirtuous(snowstorm.Tx) bool