mirror of
https://github.com/tendermint/tendermint.git
synced 2026-01-08 06:15:33 +00:00
fa32078ceb
This is a manual forward-port of #8944 and related fixes from v0.35.x. One difference of note is that the CheckTx response messages no longer have a field to record an error from the ABCI application. The code is set up so that these could be reported directly to the CheckTx caller, but it would be an API change, and right now a bunch of test plumbing depends on the existing semantics. Also fix up tests relying on implementation-specific mempool behavior. - Commit was setting the expected mempool size incorrectly. - Fix sequence test not to depend on the incorrect size.
121 lines
2.7 KiB
Go
121 lines
2.7 KiB
Go
package mempool
|
|
|
|
import (
|
|
"container/list"
|
|
"sync"
|
|
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// TxCache defines an interface for raw transaction caching in a mempool.
|
|
// Currently, a TxCache does not allow direct reading or getting of transaction
|
|
// values. A TxCache is used primarily to push transactions and removing
|
|
// transactions. Pushing via Push returns a boolean telling the caller if the
|
|
// transaction already exists in the cache or not.
|
|
type TxCache interface {
|
|
// Reset resets the cache to an empty state.
|
|
Reset()
|
|
|
|
// Push adds the given raw transaction to the cache and returns true if it was
|
|
// newly added. Otherwise, it returns false.
|
|
Push(tx types.Tx) bool
|
|
|
|
// Remove removes the given raw transaction from the cache.
|
|
Remove(tx types.Tx)
|
|
|
|
// Has reports whether tx is present in the cache. Checking for presence is
|
|
// not treated as an access of the value.
|
|
Has(tx types.Tx) bool
|
|
}
|
|
|
|
var _ TxCache = (*LRUTxCache)(nil)
|
|
|
|
// LRUTxCache maintains a thread-safe LRU cache of raw transactions. The cache
|
|
// only stores the hash of the raw transaction.
|
|
type LRUTxCache struct {
|
|
mtx sync.Mutex
|
|
size int
|
|
cacheMap map[types.TxKey]*list.Element
|
|
list *list.List
|
|
}
|
|
|
|
func NewLRUTxCache(cacheSize int) *LRUTxCache {
|
|
return &LRUTxCache{
|
|
size: cacheSize,
|
|
cacheMap: make(map[types.TxKey]*list.Element, cacheSize),
|
|
list: list.New(),
|
|
}
|
|
}
|
|
|
|
// GetList returns the underlying linked-list that backs the LRU cache. Note,
|
|
// this should be used for testing purposes only!
|
|
func (c *LRUTxCache) GetList() *list.List {
|
|
return c.list
|
|
}
|
|
|
|
func (c *LRUTxCache) Reset() {
|
|
c.mtx.Lock()
|
|
defer c.mtx.Unlock()
|
|
|
|
c.cacheMap = make(map[types.TxKey]*list.Element, c.size)
|
|
c.list.Init()
|
|
}
|
|
|
|
func (c *LRUTxCache) Push(tx types.Tx) bool {
|
|
c.mtx.Lock()
|
|
defer c.mtx.Unlock()
|
|
|
|
key := tx.Key()
|
|
|
|
moved, ok := c.cacheMap[key]
|
|
if ok {
|
|
c.list.MoveToBack(moved)
|
|
return false
|
|
}
|
|
|
|
if c.list.Len() >= c.size {
|
|
front := c.list.Front()
|
|
if front != nil {
|
|
frontKey := front.Value.(types.TxKey)
|
|
delete(c.cacheMap, frontKey)
|
|
c.list.Remove(front)
|
|
}
|
|
}
|
|
|
|
e := c.list.PushBack(key)
|
|
c.cacheMap[key] = e
|
|
|
|
return true
|
|
}
|
|
|
|
func (c *LRUTxCache) Remove(tx types.Tx) {
|
|
c.mtx.Lock()
|
|
defer c.mtx.Unlock()
|
|
|
|
key := tx.Key()
|
|
e := c.cacheMap[key]
|
|
delete(c.cacheMap, key)
|
|
|
|
if e != nil {
|
|
c.list.Remove(e)
|
|
}
|
|
}
|
|
|
|
func (c *LRUTxCache) Has(tx types.Tx) bool {
|
|
c.mtx.Lock()
|
|
defer c.mtx.Unlock()
|
|
|
|
_, ok := c.cacheMap[tx.Key()]
|
|
return ok
|
|
}
|
|
|
|
// NopTxCache defines a no-op raw transaction cache.
|
|
type NopTxCache struct{}
|
|
|
|
var _ TxCache = (*NopTxCache)(nil)
|
|
|
|
func (NopTxCache) Reset() {}
|
|
func (NopTxCache) Push(types.Tx) bool { return true }
|
|
func (NopTxCache) Remove(types.Tx) {}
|
|
func (NopTxCache) Has(types.Tx) bool { return false }
|