queue

Documentation

Index

• type Blockify
• type HeroQueue
  • func NewHeroQueue(sizeLimit uint32, logger zerolog.Logger, collector module.HeroCacheMetrics) *HeroQueue
  • func (c *HeroQueue) Pop() (flow.Entity, bool)
  • func (c *HeroQueue) Push(entity flow.Entity) bool
  • func (c *HeroQueue) Size() uint
• type HeroStore
  • func NewHeroStore(sizeLimit uint32, logger zerolog.Logger, collector module.HeroCacheMetrics) *HeroStore
  • func (c *HeroStore) Get() (*engine.Message, bool)
  • func (c *HeroStore) Put(message *engine.Message) bool
• type HeroStoreConfig
• type HeroStoreConfigOption
  • func WithHeroStoreCollector(collector module.HeroCacheMetrics) HeroStoreConfigOption
  • func WithHeroStoreSizeLimit(sizeLimit uint32) HeroStoreConfigOption
• type Node
• type Queue
  • func NewQueue(blockify Blockify) *Queue
  • func (q *Queue) Checksum() flow.Identifier
  • func (q *Queue) Dismount() (Blockify, []*Queue)
  • func (q *Queue) Height() uint64
  • func (q *Queue) ID() flow.Identifier
  • func (q *Queue) Size() int
  • func (q *Queue) TryAdd(element Blockify) (stored bool, new bool)

Types

type Blockify

type Blockify interface {
	flow.Entity
	Height() uint64
	ParentID() flow.Identifier
}

Blockify becuase Blocker seems a bit off. Make items behave like a block, so it can be queued

type HeroQueue

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

HeroQueue implements a HeroCache-based in-memory queue. HeroCache is a key-value cache with zero heap allocation and optimized Garbage Collection.

func NewHeroQueue

func NewHeroQueue(sizeLimit uint32, logger zerolog.Logger, collector module.HeroCacheMetrics) *HeroQueue

func (*HeroQueue) Pop

func (c *HeroQueue) Pop() (flow.Entity, bool)

Pop removes and returns the head of queue, and updates the head to the next element. Boolean return value determines whether pop is successful, i.e., popping an empty queue returns false.

func (*HeroQueue) Push

func (c *HeroQueue) Push(entity flow.Entity) bool

Push stores the entity into the queue. Boolean returned variable determines whether push was successful, i.e., push may be dropped if queue is full or already exists.

func (*HeroQueue) Size

func (c *HeroQueue) Size() uint

type HeroStore

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

HeroStore is a FIFO (first-in-first-out) size-bound queue for maintaining engine.Message types. It is based on HeroQueue.

func NewHeroStore

func NewHeroStore(sizeLimit uint32, logger zerolog.Logger, collector module.HeroCacheMetrics) *HeroStore

func (*HeroStore) Get

func (c *HeroStore) Get() (*engine.Message, bool)

Get pops the queue, i.e., it returns the head of queue, and updates the head to the next element. Boolean return value determines whether pop is successful, i.e., popping an empty queue returns false.

func (*HeroStore) Put

func (c *HeroStore) Put(message *engine.Message) bool

Put enqueues the message into the message store.

Boolean returned variable determines whether enqueuing was successful, i.e., put may be dropped if queue is full or already exists.

type HeroStoreConfig

type HeroStoreConfig struct {
	SizeLimit uint32
	Collector module.HeroCacheMetrics
}

type HeroStoreConfigOption

type HeroStoreConfigOption func(builder *HeroStoreConfig)

func WithHeroStoreCollector

func WithHeroStoreCollector(collector module.HeroCacheMetrics) HeroStoreConfigOption

func WithHeroStoreSizeLimit

func WithHeroStoreSizeLimit(sizeLimit uint32) HeroStoreConfigOption

type Node

type Node struct {
	Item     Blockify
	Children []*Node
}

type Queue

type Queue struct {
	Head    *Node
	Highest *Node
	Nodes   map[flow.Identifier]*Node
}

Queue is a fork-aware queue/tree of blocks for use in execution Node, where parallel forks can be processed simultaneously. For fast lookup which is predicted to be common case all nodes are kept as one queue, which is expected to split into separate queues once a fork (multiple children) is reached. Note that this is not a thread-safe structure and external synchronisation is required to use in concurrent environment

func NewQueue

func NewQueue(blockify Blockify) *Queue

func (*Queue) Checksum

func (q *Queue) Checksum() flow.Identifier

func (*Queue) Dismount

func (q *Queue) Dismount() (Blockify, []*Queue)

Dismount removes the head element, returns it and it's children as new queues

func (*Queue) Height

func (q *Queue) Height() uint64

Returns difference between lowest and highest element in the queue Formally, the Queue stores a tree. The height of the tree is the number of edges on the longest downward path between the root and any leaf.

func (*Queue) ID

func (q *Queue) ID() flow.Identifier

func (*Queue) Size

func (q *Queue) Size() int

Size returns number of elements in the queue

func (*Queue) TryAdd

func (q *Queue) TryAdd(element Blockify) (stored bool, new bool)

TryAdd tries to add a new element to the queue. A element can only be added if the parent exists in the queue. TryAdd(elmt) is an idempotent operation for the same elmt, i.e. after the first, subsequent additions of the same elements are NoOps. Returns: stored = True if and only if _after_ the operation, the element is stored in the queue. This is the case if (a) element was newly added to the queue or (b) element was already stored in the queue _before_ the call. new = Indicates if element was new to the queue, when `stored` was true. It lets distinguish (a) and (b) cases. Adding an element fails with return value `false` for `stored` in the following cases:

• element.ParentID() is _not_ stored in the queue
• element's height is _unequal to_ its parent's height + 1