core: use LRU cache in txNoncer to avoid memory leaks

core/tx_noncer.go

@@ -17,26 +17,27 @@
 package core
 
 import (
-	"sync"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
+	lru "github.com/hashicorp/golang-lru"
 )
 
-// txNoncer is a tiny virtual state database to manage the executable nonces of
+const nonceCacheLimit = 1024 * 50
+
+// txNoncer is a LRU cache to manage the executable nonces of
 // accounts in the pool, falling back to reading from a real state database if
 // an account is unknown.
 type txNoncer struct {
 	fallback *state.StateDB
-	nonces   map[common.Address]uint64
-	lock     sync.Mutex
+	nonces   *lru.Cache
 }
 
-// newTxNoncer creates a new virtual state database to track the pool nonces.
+// newTxNoncer creates a new LRU cache to track the pool nonces.
 func newTxNoncer(statedb *state.StateDB) *txNoncer {
+	cache, _ := lru.New(nonceCacheLimit)
 	return &txNoncer{
 		fallback: statedb.Copy(),
-		nonces:   make(map[common.Address]uint64),
+		nonces:   cache,
 	}
 }
 
@@ -45,43 +46,31 @@ func newTxNoncer(statedb *state.StateDB) *txNoncer {
 func (txn *txNoncer) get(addr common.Address) uint64 {
 	// We use mutex for get operation is the underlying
 	// state will mutate db even for read access.
-	txn.lock.Lock()
-	defer txn.lock.Unlock()
-
-	if _, ok := txn.nonces[addr]; !ok {
-		txn.nonces[addr] = txn.fallback.GetNonce(addr)
+	if _, ok := txn.nonces.Get(addr); !ok {
+		txn.nonces.Add(addr, txn.fallback.GetNonce(addr))
 	}
-	return txn.nonces[addr]
+	nonce, _ := txn.nonces.Get(addr)
+	return nonce.(uint64)
 }
 
-// set inserts a new virtual nonce into the virtual state database to be returned
+// set inserts a new virtual nonce into the LRU cache to be returned
 // whenever the pool requests it instead of reaching into the real state database.
 func (txn *txNoncer) set(addr common.Address, nonce uint64) {
-	txn.lock.Lock()
-	defer txn.lock.Unlock()
-
-	txn.nonces[addr] = nonce
+	txn.nonces.Add(addr, nonce)
 }
 
-// setIfLower updates a new virtual nonce into the virtual state database if the
+// setIfLower updates a new virtual nonce into the LRU cache if the
 // the new one is lower.
 func (txn *txNoncer) setIfLower(addr common.Address, nonce uint64) {
-	txn.lock.Lock()
-	defer txn.lock.Unlock()
-
-	if _, ok := txn.nonces[addr]; !ok {
-		txn.nonces[addr] = txn.fallback.GetNonce(addr)
-	}
-	if txn.nonces[addr] <= nonce {
+	if txn.get(addr) <= nonce {
 		return
 	}
-	txn.nonces[addr] = nonce
+	txn.nonces.Add(addr, nonce)
 }
 
 // setAll sets the nonces for all accounts to the given map.
 func (txn *txNoncer) setAll(all map[common.Address]uint64) {
-	txn.lock.Lock()
-	defer txn.lock.Unlock()
-
-	txn.nonces = all
+	for addr, nonce := range all {
+		txn.nonces.Add(addr, nonce)
+	}
 }

core/tx_pool.go

@@ -463,9 +463,6 @@ func (pool *TxPool) SetGasPrice(price *big.Int) {
 // Nonce returns the next nonce of an account, with all transactions executable
 // by the pool already applied on top.
 func (pool *TxPool) Nonce(addr common.Address) uint64 {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
-
 	return pool.pendingNonces.get(addr)
 }