txcache

Documentation

Index

• Variables
• type ConcurrentMap
  • func NewConcurrentMap(nChunks uint32) *ConcurrentMap
  • func (m *ConcurrentMap) Count() int
  • func (m *ConcurrentMap) Get(key string) (interface{}, bool)
  • func (m *ConcurrentMap) Has(key string) bool
  • func (m *ConcurrentMap) IsEmpty() bool
  • func (m *ConcurrentMap) IterCb(fn IterCb)
  • func (m *ConcurrentMap) Remove(key string)
  • func (m *ConcurrentMap) Set(key string, value interface{})
• type EvictionConfig
• type ForEachSender
• type IterCb
• type TxCache
  • func NewTxCache(nChunksHint uint32) *TxCache
  • func NewTxCacheWithEviction(nChunksHint uint32, evictionConfig EvictionConfig) *TxCache
  • func (cache *TxCache) AddTx(txHash []byte, tx data.TransactionHandler)
  • func (cache *TxCache) CountSenders() int64
  • func (cache *TxCache) CountTx() int64
  • func (cache *TxCache) GetByTxHash(txHash []byte) (data.TransactionHandler, bool)
  • func (cache *TxCache) GetTransactions(numRequested int, batchSizePerSender int) []data.TransactionHandler
  • func (cache *TxCache) RemoveTxByHash(txHash []byte) error

Variables

var ErrMapsSyncInconsistency = fmt.Errorf("maps sync inconsistency between 'txByHash' and 'txListBySender'")

ErrMapsSyncInconsistency signals that there's an inconsistency between the internal maps on which the cache relies

var ErrTxNotFound = fmt.Errorf("tx not found in cache")

ErrTxNotFound signals that the transactions was not found in the cache

Types

type ConcurrentMap

type ConcurrentMap struct {
	// contains filtered or unexported fields
}

ConcurrentMap is a thread safe map of type string:Anything. To avoid lock bottlenecks this map is divided to several map chunks.

func NewConcurrentMap

func NewConcurrentMap(nChunks uint32) *ConcurrentMap

NewConcurrentMap creates a new concurrent map.

func (*ConcurrentMap) Count

func (m *ConcurrentMap) Count() int

Count returns the number of elements within the map.

func (*ConcurrentMap) Get

func (m *ConcurrentMap) Get(key string) (interface{}, bool)

Get retrieves an element from map under given key.

func (*ConcurrentMap) Has

func (m *ConcurrentMap) Has(key string) bool

Has looks up an item under specified key.

func (*ConcurrentMap) IsEmpty

func (m *ConcurrentMap) IsEmpty() bool

IsEmpty checks if map is empty.

func (*ConcurrentMap) IterCb

func (m *ConcurrentMap) IterCb(fn IterCb)

IterCb iterates over the map (cheapest way to read all elements in a map)

func (*ConcurrentMap) Remove

func (m *ConcurrentMap) Remove(key string)

Remove removes an element from the map.

func (*ConcurrentMap) Set

func (m *ConcurrentMap) Set(key string, value interface{})

Set sets the given value under the specified key.

type EvictionConfig

type EvictionConfig struct {
	Enabled                         bool
	CountThreshold                  uint32
	ThresholdEvictSenders           uint32
	NumOldestSendersToEvict         uint32
	ALotOfTransactionsForASender    uint32
	NumTxsToEvictForASenderWithALot uint32
}

EvictionConfig is a cache eviction model

type ForEachSender

type ForEachSender func(key string, value *txListForSender)

ForEachSender is an iterator callback

type IterCb

type IterCb func(key string, v interface{})

IterCb is an iterator callback

type TxCache

type TxCache struct {
	// contains filtered or unexported fields
}

TxCache represents a cache-like structure (it has a fixed capacity and implements an eviction mechanism) for holding transactions

func NewTxCache

func NewTxCache(nChunksHint uint32) *TxCache

NewTxCache creates a new transaction cache "nChunksHint" is used to configure the internal concurrent maps on which the implementation relies

func NewTxCacheWithEviction

func NewTxCacheWithEviction(nChunksHint uint32, evictionConfig EvictionConfig) *TxCache

NewTxCacheWithEviction creates a new transaction cache with eviction

func (*TxCache) AddTx

func (cache *TxCache) AddTx(txHash []byte, tx data.TransactionHandler)

AddTx adds a transaction in the cache Eviction happens if maximum capacity is reached

func (*TxCache) CountSenders

func (cache *TxCache) CountSenders() int64

CountSenders gets the number of senders in the cache

func (*TxCache) CountTx

func (cache *TxCache) CountTx() int64

CountTx gets the number of transactions in the cache

func (*TxCache) GetByTxHash

func (cache *TxCache) GetByTxHash(txHash []byte) (data.TransactionHandler, bool)

GetByTxHash gets the transaction by hash

func (*TxCache) GetTransactions

func (cache *TxCache) GetTransactions(numRequested int, batchSizePerSender int) []data.TransactionHandler

GetTransactions gets a reasonably fair list of transactions to be included in the next miniblock It returns at most "numRequested" transactions Each sender gets the chance to give at least "batchSizePerSender" transactions, unless "numRequested" limit is reached before iterating over all senders

func (*TxCache) RemoveTxByHash

func (cache *TxCache) RemoveTxByHash(txHash []byte) error

RemoveTxByHash removes