Index

Modules: lockfreequeues, lockfreequeues/atomic_dsl, lockfreequeues/constants, lockfreequeues/mupmuc, lockfreequeues/mupsic, lockfreequeues/ops, lockfreequeues/sipsic.

API symbols

acquire:

• atomic_dsl: proc acquire[T](location: var Atomic[T]): T

available:

• ops: proc available(head: int; tail: int; capacity: int): int

CacheLineBytes:

• constants: const CacheLineBytes

capacity:

• mupsic: proc capacity[N, P: static int; T](self: var Mupsic[N, P, T]): int
• sipsic: proc capacity[N: static int; T](self: var Sipsic[N, T]): int

Consumer:

• mupmuc: object Consumer

consumerCount:

• mupmuc: proc consumerCount[N, P, C: static int; T](self: var Mupmuc[N, P, C, T]): int

empty:

• ops: proc empty(head: int; tail: int; capacity: int): bool

full:

• ops: proc full(head: int; tail: int; capacity: int): bool

getConsumer:

• mupmuc: proc getConsumer[N, P, C: static int; T](self: var Mupmuc[N, P, C, T]; idx: int = NoConsumerIdx): Consumer[N, P, C, T]

getProducer:

• mupsic: proc getProducer[N, P: static int; T](self: var Mupsic[N, P, T]; idx: int = NoProducerIdx): Producer[N, P, T]

incOrReset:

• ops: proc incOrReset(original: int; amount: int; capacity: int): int

index:

• ops: proc index(value: int; capacity: int): int

initMupmuc:

• mupmuc: proc initMupmuc[N, P, C: static int; T](): Mupmuc[N, P, C, T]

initMupsic:

• mupsic: proc initMupsic[N, P: static int; T](): Mupsic[N, P, T]

initSipsic:

• sipsic: proc initSipsic[N: static int; T](): Sipsic[N, T]

InvalidCallDefect:

• mupsic: object InvalidCallDefect

Mupmuc:

• mupmuc: object Mupmuc

Mupsic:

• mupsic: object Mupsic

NoConsumerIdx:

• mupmuc: const NoConsumerIdx

NoConsumersAvailableError:

• mupmuc: object NoConsumersAvailableError

NoProducerIdx:

• mupsic: const NoProducerIdx

NoProducersAvailableError:

• mupsic: object NoProducersAvailableError

NoSlice:

• sipsic: const NoSlice

pop:

• mupmuc: proc pop[N, P, C: static int; T](self: Consumer[N, P, C, T]): Option[T]
• mupmuc: proc pop[N, P, C: static int; T](self: Consumer[N, P, C, T]; count: int): Option[ seq[T]]
• mupmuc: proc pop[N, P, C: static int; T](self: var Mupmuc[N, P, C, T]): bool
• mupmuc: proc pop[N, P, C: static int; T](self: var Mupmuc[N, P, C, T]; count: int): Option[ seq[T]]
• sipsic: proc pop[N: static int; T](self: var Sipsic[N, T]): Option[T]
• sipsic: proc pop[N: static int; T](self: var Sipsic[N, T]; count: int): Option[seq[T]]

Producer:

• mupsic: object Producer

producerCount:

• mupsic: proc producerCount[N, P: static int; T](self: var Mupsic[N, P, T]): int

push:

• mupsic: proc push[N, P: static int; T](self: var Mupsic[N, P, T]; items: openArray[T]): Option[ HSlice[int, int]]
• mupsic: proc push[N, P: static int; T](self: var Mupsic[N, P, T]; item: T): bool
• mupsic: proc push[N, P: static int; T](self: Producer[N, P, T]; items: openArray[T]): Option[ HSlice[int, int]]
• mupsic: proc push[N, P: static int; T](self: Producer[N, P, T]; item: T): bool
• sipsic: proc push[N: static int; T](self: var Sipsic[N, T]; items: openArray[T]): Option[ HSlice[int, int]]
• sipsic: proc push[N: static int; T](self: var Sipsic[N, T]; item: T): bool

relaxed:

• atomic_dsl: proc relaxed[T](location: var Atomic[T]): T
• atomic_dsl: proc relaxed[T](location: var Atomic[T]; value: T)

release:

• atomic_dsl: proc release[T](location: var Atomic[T]; value: T)

sequential:

• atomic_dsl: proc sequential[T](location: var Atomic[T]): T
• atomic_dsl: proc sequential[T](location: var Atomic[T]; value: T)

Sipsic:

• sipsic: object Sipsic

used:

• ops: proc used(head: int; tail: int; capacity: int): int

validateHeadAndTail:

• ops: proc validateHeadAndTail(head: int; tail: int; capacity: int): bool

validateHeadOrTail:

• ops: proc validateHeadOrTail(value: int; capacity: int): bool