Merge cosmos sdk pr for performance.(6811,10339,8811)

libs/cosmos-sdk/store/cachekv/memiterator.go

@@ -1,10 +1,8 @@
 package cachekv
 
 import (
-	"container/list"
 	"errors"
-
-	tmkv "github.com/okex/exchain/libs/tendermint/libs/kv"
+	kv "github.com/okex/exchain/libs/cosmos-sdk/types/kv"
 	dbm "github.com/okex/exchain/libs/tm-db"
 )
 
@@ -13,15 +11,16 @@ import (
 // Implements Iterator.
 type memIterator struct {
 	start, end []byte
-	items      []*tmkv.Pair
+	items      []*kv.Pair
 	ascending  bool
 }
 
-func newMemIterator(start, end []byte, items *list.List, ascending bool) *memIterator {
-	itemsInDomain := make([]*tmkv.Pair, 0)
+func newMemIterator(start, end []byte, items *kv.List, ascending bool) *memIterator {
+	itemsInDomain := make([]*kv.Pair, 0, items.Len())
+
 	var entered bool
 	for e := items.Front(); e != nil; e = e.Next() {
-		item := e.Value.(*tmkv.Pair)
+		item := e.Value
 		if !dbm.IsKeyInDomain(item.Key, start, end) {
 			if entered {
 				break

libs/cosmos-sdk/store/cachekv/store.go

@@ -2,22 +2,19 @@ package cachekv
 
 import (
 	"bytes"
-	"container/list"
 	"io"
 	"reflect"
 	"sort"
 	"sync"
 	"unsafe"
 
 	"github.com/okex/exchain/libs/iavl"
-
-	"github.com/tendermint/go-amino"
-
-	tmkv "github.com/okex/exchain/libs/tendermint/libs/kv"
 	dbm "github.com/okex/exchain/libs/tm-db"
+	"github.com/tendermint/go-amino"
 
 	"github.com/okex/exchain/libs/cosmos-sdk/store/tracekv"
 	"github.com/okex/exchain/libs/cosmos-sdk/store/types"
+	kv "github.com/okex/exchain/libs/cosmos-sdk/types/kv"
 )
 
 // If value is nil but deleted is false, it means the parent doesn't have the
@@ -35,7 +32,7 @@ type Store struct {
 	dirty         map[string]cValue
 	readList      map[string][]byte
 	unsortedCache map[string]struct{}
-	sortedCache   *list.List // always ascending sorted
+	sortedCache   *kv.List // always ascending sorted
 	parent        types.KVStore
 
 	preChangesHandler PreChangesHandler
@@ -48,7 +45,7 @@ func NewStore(parent types.KVStore) *Store {
 		dirty:         make(map[string]cValue),
 		readList:      make(map[string][]byte),
 		unsortedCache: make(map[string]struct{}),
-		sortedCache:   list.New(),
+		sortedCache:   kv.NewList(),
 		parent:        parent,
 	}
 }
@@ -309,13 +306,13 @@ func byteSliceToStr(b []byte) string {
 
 // Constructs a slice of dirty items, to use w/ memIterator.
 func (store *Store) dirtyItems(start, end []byte) {
-	unsorted := make([]*tmkv.Pair, 0)
+	unsorted := make([]*kv.Pair, 0)
 
 	n := len(store.unsortedCache)
 	for key := range store.unsortedCache {
 		if dbm.IsKeyInDomain(strToByte(key), start, end) {
 			cacheValue := store.dirty[key]
-			unsorted = append(unsorted, &tmkv.Pair{Key: []byte(key), Value: cacheValue.value})
+			unsorted = append(unsorted, &kv.Pair{Key: []byte(key), Value: cacheValue.value})
 		}
 	}
 
@@ -335,7 +332,7 @@ func (store *Store) dirtyItems(start, end []byte) {
 
 	for e := store.sortedCache.Front(); e != nil && len(unsorted) != 0; {
 		uitem := unsorted[0]
-		sitem := e.Value.(*tmkv.Pair)
+		sitem := e.Value
 		comp := bytes.Compare(uitem.Key, sitem.Key)
 		switch comp {
 		case -1:

libs/cosmos-sdk/types/coin.go

@@ -558,18 +558,24 @@ func (coins Coins) IsAnyGTE(coinsB Coins) bool {
 
 // removeZeroCoins removes all zero coins from the given coin set in-place.
 func removeZeroCoins(coins Coins) Coins {
-	i, l := 0, len(coins)
-	for i < l {
+	for i := 0; i < len(coins); i++ {
 		if coins[i].IsZero() {
-			// remove coin
-			coins = append(coins[:i], coins[i+1:]...)
-			l--
-		} else {
-			i++
+			break
+		} else if i == len(coins)-1 {
+			return coins
 		}
 	}
+	var result []Coin
+	if len(coins) > 0 {
+		result = make([]Coin, 0, len(coins)-1)
+	}
 
-	return coins[:i]
+	for _, coin := range coins {
+		if !coin.IsZero() {
+			result = append(result, coin)
+		}
+	}
+	return result
 }
 
 //-----------------------------------------------------------------------------

libs/cosmos-sdk/types/coin_test.go

@@ -212,6 +212,58 @@ func TestCoinIsZero(t *testing.T) {
 	require.False(t, res)
 }
 
+func TestFilteredZeroCoins(t *testing.T) {
+	cases := []struct {
+		name     string
+		input    Coins
+		original string
+		expected string
+	}{
+		{
+			name: "all greater than zero",
+			input: Coins{
+				NewInt64Coin("testa", 1),
+				NewInt64Coin("testb", 2),
+				NewInt64Coin("testc", 3),
+				NewInt64Coin("testd", 4),
+				NewInt64Coin("teste", 5),
+			},
+			original: "1.000000000000000000testa,2.000000000000000000testb,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+			expected: "1.000000000000000000testa,2.000000000000000000testb,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+		},
+		{
+			name: "zero coin in middle",
+			input: Coins{
+				NewInt64Coin("testa", 1),
+				NewInt64Coin("testb", 2),
+				NewInt64Coin("testc", 0),
+				NewInt64Coin("testd", 4),
+				NewInt64Coin("teste", 5),
+			},
+			original: "1.000000000000000000testa,2.000000000000000000testb,0.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+			expected: "1.000000000000000000testa,2.000000000000000000testb,4.000000000000000000testd,5.000000000000000000teste",
+		},
+		{
+			name: "zero coin end (unordered)",
+			input: Coins{
+				NewInt64Coin("teste", 5),
+				NewInt64Coin("testc", 3),
+				NewInt64Coin("testa", 1),
+				NewInt64Coin("testd", 4),
+				NewInt64Coin("testb", 0),
+			},
+			original: "5.000000000000000000teste,3.000000000000000000testc,1.000000000000000000testa,4.000000000000000000testd,0.000000000000000000testb",
+			expected: "1.000000000000000000testa,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+		},
+	}
+
+	for _, tt := range cases {
+		undertest := NewCoins(tt.input...)
+		require.Equal(t, tt.expected, undertest.String(), "NewCoins must return expected results")
+		require.Equal(t, tt.original, tt.input.String(), "input must be unmodified and match original")
+	}
+}
+
 // ----------------------------------------------------------------------------
 // Coins tests
 

libs/cosmos-sdk/types/dec_coin.go

@@ -659,18 +659,24 @@ func (coins DecCoins) IsAllPositive() bool {
 }
 
 func removeZeroDecCoins(coins DecCoins) DecCoins {
-	i, l := 0, len(coins)
-	for i < l {
+	for i := 0; i < len(coins); i++ {
 		if coins[i].IsZero() {
-			// remove coin
-			coins = append(coins[:i], coins[i+1:]...)
-			l--
-		} else {
-			i++
+			break
+		} else if i == len(coins)-1 {
+			return coins
 		}
 	}
+	var result []DecCoin
+	if len(coins) > 0 {
+		result = make([]DecCoin, 0, len(coins)-1)
+	}
 
-	return coins[:i]
+	for _, coin := range coins {
+		if !coin.IsZero() {
+			result = append(result, coin)
+		}
+	}
+	return result
 }
 
 //-----------------------------------------------------------------------------

libs/cosmos-sdk/types/dec_coin_test.go

@@ -101,6 +101,57 @@ func TestAddDecCoins(t *testing.T) {
 	}
 }
 
+func TestFilteredZeroDecCoins(t *testing.T) {
+	cases := []struct {
+		name     string
+		input    DecCoins
+		original string
+		expected string
+	}{
+		{
+			name: "all greater than zero",
+			input: DecCoins{
+				{"testa", NewDec(1)},
+				{"testb", NewDec(2)},
+				{"testc", NewDec(3)},
+				{"testd", NewDec(4)},
+				{"teste", NewDec(5)},
+			},
+			original: "1.000000000000000000testa,2.000000000000000000testb,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+			expected: "1.000000000000000000testa,2.000000000000000000testb,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+		},
+		{
+			name: "zero coin in middle",
+			input: DecCoins{
+				{"testa", NewDec(1)},
+				{"testb", NewDec(2)},
+				{"testc", NewDec(0)},
+				{"testd", NewDec(4)},
+				{"teste", NewDec(5)},
+			},
+			original: "1.000000000000000000testa,2.000000000000000000testb,0.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+			expected: "1.000000000000000000testa,2.000000000000000000testb,4.000000000000000000testd,5.000000000000000000teste",
+		},
+		{
+			name: "zero coin end (unordered)",
+			input: DecCoins{
+				{"teste", NewDec(5)},
+				{"testc", NewDec(3)},
+				{"testa", NewDec(1)},
+				{"testd", NewDec(4)},
+				{"testb", NewDec(0)},
+			},
+			original: "5.000000000000000000teste,3.000000000000000000testc,1.000000000000000000testa,4.000000000000000000testd,0.000000000000000000testb",
+			expected: "1.000000000000000000testa,3.000000000000000000testc,4.000000000000000000testd,5.000000000000000000teste",
+		},
+	}
+
+	for _, tt := range cases {
+		undertest := NewDecCoins(tt.input...)
+		require.Equal(t, tt.expected, undertest.String(), "NewDecCoins must return expected results")
+		require.Equal(t, tt.original, tt.input.String(), "input must be unmodified and match original")
+	}
+}
 func TestIsValid(t *testing.T) {
 	tests := []struct {
 		coin       DecCoin