Index

Modules: loony, loony/memalloc, loony/node, loony/spec.

API symbols

`=destroy`:

• node: `=destroy`(n: var Node)

allocAligned:

• memalloc: allocAligned(size, align: Natural): pointer

allocAligned0:

• memalloc: allocAligned0(size, align: Natural): pointer

allocNode:

• node: allocNode(): ptr Node
• node: allocNode[T](pel: T): ptr Node

compareAndSwapNext:

• node: compareAndSwapNext(t: Node; expect: var uint; swap: uint): bool
• node: compareAndSwapNext(t: NodePtr; expect: var uint; swap: uint): bool

CONSUMED:

• spec: CONSUMED

ControlBlock:

• spec: ControlBlock

ControlMask:

• spec: ControlMask

deallocAligned:

• memalloc: deallocAligned(p: pointer; align: int)

deallocNode:

• node: deallocNode(n: ptr Node)

debugNodeCounter:

• node: debugNodeCounter(body: untyped)

decDebugCounter:

• node: decDebugCounter(): untyped

DEQ:

• spec: DEQ

deqCounter:

• node: deqCounter

deqPathCounter:

• node: deqPathCounter

echoDebugNodeCounter:

• node: echoDebugNodeCounter()

ENQ:

• spec: ENQ

enqCounter:

• node: enqCounter

enqPathCounter:

• node: enqPathCounter

fetchAddHead:

• spec: fetchAddHead(ctrl: var ControlBlock; v: uint32 = 1; moorder: MemoryOrder = moRelease): ControlMask

fetchAddReclaim:

• spec: fetchAddReclaim(ctrl: var ControlBlock; v: uint8 = 1; moorder: MemoryOrder = moAcquireRelease): uint8

fetchAddSlot:

• node: fetchAddSlot(t: Node; idx: uint16; w: uint; moorder: MemoryOrder = moAcquireRelease): uint

fetchAddTail:

• spec: fetchAddTail(ctrl: var ControlBlock; v: uint32 = 1; moorder: MemoryOrder = moRelease): ControlMask

fetchNext:

• node: fetchNext(node: Node; moorder: MemoryOrder = moAcquireRelease): NodePtr
• node: fetchNext(node: NodePtr; moorder: MemoryOrder = moAcquireRelease): NodePtr

getHigh:

• spec: getHigh(mask: ControlMask): uint16

getLow:

• spec: getLow(mask: ControlMask): uint16

incDebugCounter:

• node: incDebugCounter(): untyped

incDeqCounter:

• node: incDeqCounter(): untyped

incDeqPathCounter:

• node: incDeqPathCounter(): untyped

incEnqCounter:

• node: incEnqCounter(): untyped

incEnqPathCounter:

• node: incEnqPathCounter(): untyped

incrDeqCount:

• node: incrDeqCount(node: var Node; final: uint16 = 0)

incReclaimCounter:

• node: incReclaimCounter(): untyped

incRecPathCounter:

• node: incRecPathCounter(): untyped

incrEnqCount:

• node: incrEnqCount(node: var Node; final: uint16 = 0)

initLoonyQueue:

• loony: initLoonyQueue[T](): LoonyQueue[T]
• loony: initLoonyQueue(q: LoonyQueue)

isEmpty:

• loony: isEmpty(queue: LoonyQueue): bool

LoonyQueue:

• loony: LoonyQueue

MASK:

• spec: MASK

N:

• spec: N

newLoonyQueue:

• loony: newLoonyQueue[T](): LoonyQueue[T]

Node:

• node: Node

NODEALIGN:

• spec: NODEALIGN

nodeCounter:

• node: nodeCounter

NodePtr:

• spec: NodePtr

pop:

• loony: pop[T](queue: LoonyQueue[T]): T

prepareElement:

• node: prepareElement[T: ref](el: T): uint

PTRMASK:

• spec: PTRMASK

push:

• loony: push[T](queue: LoonyQueue[T]; el: T)

READER:

• spec: READER

reclaimCounter:

• node: reclaimCounter

recPathCounter:

• node: recPathCounter

RESUME:

• spec: RESUME

SHIFT:

• spec: SHIFT

SLOT:

• spec: SLOT

SLOTMASK:

• spec: SLOTMASK

TAGBITS:

• spec: TAGBITS

TAGMASK:

• spec: TAGMASK

TagPtr:

• spec: TagPtr

toNode:

• node: toNode(pt: NodePtr | uint): Node

toNodePtr:

• node: toNodePtr(pt: uint | ptr Node): NodePtr

toStrTuple:

• loony: toStrTuple(tag: TagPtr): string

toUInt:

• node: toUInt(node: var Node): uint
• node: toUInt(nodeptr: ptr Node): uint

tryReclaim:

• node: tryReclaim(node: var Node; start: uint16)

UNINIT:

• spec: UNINIT

unsafePop:

• loony: unsafePop[T](queue: LoonyQueue[T]): T

unsafePush:

• loony: unsafePush[T](queue: LoonyQueue[T]; el: T)

WRITER:

• spec: WRITER