Index

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

API symbols

`=destroy`:

• loony: proc `=destroy`[T](x: var LoonyQueueImpl[T])
• node: proc `=destroy`(n: var Node)

allocAligned:

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

allocAligned0:

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

allocNode:

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

compareAndSwapNext:

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

CONSUMED:

• spec: const CONSUMED

ControlBlock:

• spec: object ControlBlock

ControlMask:

• spec: type ControlMask

deallocAligned:

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

deallocNode:

• node: proc deallocNode(n: ptr Node)

debugNodeCounter:

• node: template debugNodeCounter(body: untyped)

decDebugCounter:

• node: template decDebugCounter(): untyped

DEQ:

• spec: const DEQ

deqCounter:

• node: var deqCounter

deqPathCounter:

• node: var deqPathCounter

echoDebugNodeCounter:

• node: proc echoDebugNodeCounter()

ENQ:

• spec: const ENQ

enqCounter:

• node: var enqCounter

enqPathCounter:

• node: var enqPathCounter

fetchAddHead:

• spec: proc fetchAddHead(ctrl: var ControlBlock; v: uint32 = 1): ControlMask

fetchAddReclaim:

• spec: proc fetchAddReclaim(ctrl: var ControlBlock; v: uint8 = 1): uint8

fetchAddSlot:

• node: proc fetchAddSlot(t: var Node; idx: uint16; w: uint; moorder: MemoryOrder): uint

fetchAddTail:

• spec: proc fetchAddTail(ctrl: var ControlBlock; v: uint32 = 1): ControlMask

fetchNext:

• node: proc fetchNext(node: NodePtr; moorder: MemoryOrder): NodePtr

getHigh:

• spec: proc getHigh(mask: ControlMask): uint16

getLow:

• spec: proc getLow(mask: ControlMask): uint16

incDebugCounter:

• node: template incDebugCounter(): untyped

incDeqCounter:

• node: template incDeqCounter(): untyped

incDeqPathCounter:

• node: template incDeqPathCounter(): untyped

incEnqCounter:

• node: template incEnqCounter(): untyped

incEnqPathCounter:

• node: template incEnqPathCounter(): untyped

incrDeqCount:

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

incReclaimCounter:

• node: template incReclaimCounter(): untyped

incRecPathCounter:

• node: template incRecPathCounter(): untyped

incrEnqCount:

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

initLoonyQueue:

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

isEmpty:

• loony: proc isEmpty(queue: LoonyQueue): bool

loonyIsolated:

• spec: const loonyIsolated

loonyNodeAlignment:

• spec: const loonyNodeAlignment

LoonyQueue:

• loony: type LoonyQueue

LoonyQueueImpl:

• loony: object LoonyQueueImpl

loonyRotate:

• spec: const loonyRotate

loonySlotCount:

• spec: const loonySlotCount

lShiftBits:

• spec: const lShiftBits

MASK:

• spec: const MASK

N:

• spec: const N

newLoonyQueue:

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

Node:

• node: object Node

NODEALIGN:

• spec: const NODEALIGN

nodeCounter:

• node: var nodeCounter

NodePtr:

• spec: type NodePtr

pop:

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

prepareElement:

• node: proc prepareElement[T](el: var T): uint

prn:

• node: template prn(idx: uint16): uint16

PTRMASK:

• spec: const PTRMASK

push:

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

READER:

• spec: const READER

reclaimCounter:

• node: var reclaimCounter

recPathCounter:

• node: var recPathCounter

RESUME:

• spec: const RESUME

rShiftBits:

• spec: const rShiftBits

SHIFT:

• spec: const SHIFT

SLOT:

• spec: const SLOT

SLOTMASK:

• spec: const SLOTMASK

TAGBITS:

• spec: const TAGBITS

TAGMASK:

• spec: const TAGMASK

TagPtr:

• spec: type TagPtr

toNode:

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

toNodePtr:

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

toStrTuple:

• loony: proc toStrTuple(tag: TagPtr): string

toUInt:

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

tryReclaim:

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

UNINIT:

• spec: const UNINIT

unsafePop:

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

unsafePush:

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

WRITER:

• spec: const WRITER