You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
249 lines
7.0 KiB
249 lines
7.0 KiB
package mempool
|
|
|
|
import (
|
|
"bytes"
|
|
"container/list"
|
|
"sync"
|
|
"sync/atomic"
|
|
|
|
"github.com/tendermint/go-clist"
|
|
. "github.com/tendermint/go-common"
|
|
"github.com/tendermint/tendermint/proxy"
|
|
"github.com/tendermint/tendermint/types"
|
|
tmsp "github.com/tendermint/tmsp/types"
|
|
)
|
|
|
|
/*
|
|
|
|
The mempool pushes new txs onto the proxyAppCtx.
|
|
It gets a stream of (req, res) tuples from the proxy.
|
|
The memool stores good txs in a concurrent linked-list.
|
|
|
|
Multiple concurrent go-routines can traverse this linked-list
|
|
safely by calling .NextWait() on each element.
|
|
|
|
So we have several go-routines:
|
|
1. Consensus calling Update() and Reap() synchronously
|
|
2. Many mempool reactor's peer routines calling AppendTx()
|
|
3. Many mempool reactor's peer routines traversing the txs linked list
|
|
4. Another goroutine calling GarbageCollectTxs() periodically
|
|
|
|
To manage these goroutines, there are three methods of locking.
|
|
1. Mutations to the linked-list is protected by an internal mtx (CList is goroutine-safe)
|
|
2. Mutations to the linked-list elements are atomic
|
|
3. AppendTx() calls can be paused upon Update() and Reap(), protected by .proxyMtx
|
|
|
|
Garbage collection of old elements from mempool.txs is handlde via
|
|
the DetachPrev() call, which makes old elements not reachable by
|
|
peer broadcastTxRoutine() automatically garbage collected.
|
|
|
|
*/
|
|
|
|
const cacheSize = 100000
|
|
|
|
type Mempool struct {
|
|
proxyMtx sync.Mutex
|
|
proxyAppCtx proxy.AppContext
|
|
txs *clist.CList // concurrent linked-list of good txs
|
|
counter int64 // simple incrementing counter
|
|
height int // the last block Update()'d to
|
|
expected *clist.CElement // pointer to .txs for next response
|
|
|
|
// Keep a cache of already-seen txs.
|
|
// This reduces the pressure on the proxyApp.
|
|
cacheMap map[string]struct{}
|
|
cacheList *list.List
|
|
}
|
|
|
|
func NewMempool(proxyAppCtx proxy.AppContext) *Mempool {
|
|
mempool := &Mempool{
|
|
proxyAppCtx: proxyAppCtx,
|
|
txs: clist.New(),
|
|
counter: 0,
|
|
height: 0,
|
|
expected: nil,
|
|
|
|
cacheMap: make(map[string]struct{}, cacheSize),
|
|
cacheList: list.New(),
|
|
}
|
|
proxyAppCtx.SetResponseCallback(mempool.resCb)
|
|
return mempool
|
|
}
|
|
|
|
// Return the first element of mem.txs for peer goroutines to call .NextWait() on.
|
|
// Blocks until txs has elements.
|
|
func (mem *Mempool) TxsFrontWait() *clist.CElement {
|
|
return mem.txs.FrontWait()
|
|
}
|
|
|
|
// Try a new transaction in the mempool.
|
|
// Potentially blocking if we're blocking on Update() or Reap().
|
|
func (mem *Mempool) AppendTx(tx types.Tx) (err error) {
|
|
mem.proxyMtx.Lock()
|
|
defer mem.proxyMtx.Unlock()
|
|
|
|
// CACHE
|
|
if _, exists := mem.cacheMap[string(tx)]; exists {
|
|
return nil
|
|
}
|
|
if mem.cacheList.Len() >= cacheSize {
|
|
popped := mem.cacheList.Front()
|
|
poppedTx := popped.Value.(types.Tx)
|
|
delete(mem.cacheMap, string(poppedTx))
|
|
mem.cacheList.Remove(popped)
|
|
}
|
|
mem.cacheMap[string(tx)] = struct{}{}
|
|
mem.cacheList.PushBack(tx)
|
|
// END CACHE
|
|
|
|
if err = mem.proxyAppCtx.Error(); err != nil {
|
|
return err
|
|
}
|
|
mem.proxyAppCtx.AppendTxAsync(tx)
|
|
return nil
|
|
}
|
|
|
|
// TMSP callback function
|
|
// CONTRACT: No other goroutines mutate mem.expected concurrently.
|
|
func (mem *Mempool) resCb(req tmsp.Request, res tmsp.Response) {
|
|
switch res := res.(type) {
|
|
case tmsp.ResponseAppendTx:
|
|
reqAppendTx := req.(tmsp.RequestAppendTx)
|
|
if mem.expected == nil { // Normal operation
|
|
if res.RetCode == tmsp.RetCodeOK {
|
|
mem.counter++
|
|
memTx := &mempoolTx{
|
|
counter: mem.counter,
|
|
height: int64(mem.height),
|
|
tx: reqAppendTx.TxBytes,
|
|
}
|
|
mem.txs.PushBack(memTx)
|
|
} else {
|
|
// ignore bad transaction
|
|
// TODO: handle other retcodes
|
|
}
|
|
} else { // During Update()
|
|
// TODO Log sane warning if mem.expected is nil.
|
|
memTx := mem.expected.Value.(*mempoolTx)
|
|
if !bytes.Equal(reqAppendTx.TxBytes, memTx.tx) {
|
|
PanicSanity("Unexpected tx response from proxy")
|
|
}
|
|
if res.RetCode == tmsp.RetCodeOK {
|
|
// Good, nothing to do.
|
|
} else {
|
|
// TODO: handle other retcodes
|
|
// Tx became invalidated due to newly committed block.
|
|
// NOTE: Concurrent traversal of mem.txs via CElement.Next() still works.
|
|
mem.txs.Remove(mem.expected)
|
|
mem.expected.DetachPrev()
|
|
}
|
|
mem.expected = mem.expected.Next()
|
|
}
|
|
default:
|
|
// ignore other messages
|
|
}
|
|
}
|
|
|
|
// Get the valid transactions run so far, and the hash of
|
|
// the application state that results from those transactions.
|
|
func (mem *Mempool) Reap() ([]types.Tx, []byte, error) {
|
|
mem.proxyMtx.Lock()
|
|
defer mem.proxyMtx.Unlock()
|
|
|
|
// First, get the hash of txs run so far
|
|
hash, err := mem.proxyAppCtx.GetHashSync()
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// And collect all the transactions.
|
|
txs := mem.collectTxs()
|
|
|
|
return txs, hash, nil
|
|
}
|
|
|
|
func (mem *Mempool) collectTxs() []types.Tx {
|
|
txs := make([]types.Tx, 0, mem.txs.Len())
|
|
for e := mem.txs.Front(); e != nil; e = e.Next() {
|
|
memTx := e.Value.(*mempoolTx)
|
|
txs = append(txs, memTx.tx)
|
|
}
|
|
return txs
|
|
}
|
|
|
|
// "block" is the new block that was committed.
|
|
// Txs that are present in "block" are discarded from mempool.
|
|
// NOTE: this should be called *after* block is committed by consensus.
|
|
// CONTRACT: block is valid and next in sequence.
|
|
func (mem *Mempool) Update(block *types.Block) error {
|
|
mem.proxyMtx.Lock()
|
|
defer mem.proxyMtx.Unlock()
|
|
|
|
// Rollback mempool synchronously
|
|
// TODO: test that proxyAppCtx's state matches the block's
|
|
err := mem.proxyAppCtx.RollbackSync()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// First, create a lookup map of txns in new block.
|
|
blockTxsMap := make(map[string]struct{})
|
|
for _, tx := range block.Data.Txs {
|
|
blockTxsMap[string(tx)] = struct{}{}
|
|
}
|
|
|
|
// Remove transactions that are already in block.
|
|
// Return the remaining potentially good txs.
|
|
goodTxs := mem.filterTxs(block.Height, blockTxsMap)
|
|
|
|
// Set height and expected
|
|
mem.height = block.Height
|
|
mem.expected = mem.txs.Front()
|
|
|
|
// Push good txs to proxyAppCtx
|
|
// NOTE: resCb() may be called concurrently.
|
|
for _, tx := range goodTxs {
|
|
mem.proxyAppCtx.AppendTxAsync(tx)
|
|
if err := mem.proxyAppCtx.Error(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// NOTE: Even though we return immediately without e.g.
|
|
// calling mem.proxyAppCtx.FlushSync(),
|
|
// New mempool txs will still have to wait until
|
|
// all goodTxs are re-processed.
|
|
// So we could make synchronous calls here to proxyAppCtx.
|
|
|
|
return nil
|
|
}
|
|
|
|
func (mem *Mempool) filterTxs(height int, blockTxsMap map[string]struct{}) []types.Tx {
|
|
goodTxs := make([]types.Tx, 0, mem.txs.Len())
|
|
for e := mem.txs.Front(); e != nil; e = e.Next() {
|
|
memTx := e.Value.(*mempoolTx)
|
|
if _, ok := blockTxsMap[string(memTx.tx)]; ok {
|
|
// Remove the tx since already in block.
|
|
mem.txs.Remove(e)
|
|
e.DetachPrev()
|
|
continue
|
|
}
|
|
// Good tx!
|
|
atomic.StoreInt64(&memTx.height, int64(height))
|
|
goodTxs = append(goodTxs, memTx.tx)
|
|
}
|
|
return goodTxs
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
// A transaction that successfully ran
|
|
type mempoolTx struct {
|
|
counter int64 // a simple incrementing counter
|
|
height int64 // height that this tx had been validated in
|
|
tx types.Tx //
|
|
}
|
|
|
|
func (memTx *mempoolTx) Height() int {
|
|
return int(atomic.LoadInt64(&memTx.height))
|
|
}
|