Index

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

API symbols

acquire:

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

available:

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

CacheLineBytes:

• constants: CacheLineBytes

capacity:

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

Consumer:

• mupmuc: Consumer

consumerCount:

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

empty:

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

full:

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

getConsumer:

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

getProducer:

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

incOrReset:

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

index:

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

initMupmuc:

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

initMupsic:

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

initSipsic:

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

InvalidCallDefect:

• mupsic: InvalidCallDefect

Mupmuc:

• mupmuc: Mupmuc

Mupsic:

• mupsic: Mupsic

NoConsumerIdx:

• mupmuc: NoConsumerIdx

NoConsumersAvailableError:

• mupmuc: NoConsumersAvailableError

NoProducerIdx:

• mupsic: NoProducerIdx

NoProducersAvailableError:

• mupsic: NoProducersAvailableError

NoSlice:

• sipsic: NoSlice

pop:

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

Producer:

• mupsic: Producer

producerCount:

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

push:

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

relaxed:

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

release:

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

sequential:

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

Sipsic:

• sipsic: Sipsic

used:

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

validateHeadOrTail:

• ops: validateHeadOrTail(value: int; capacity: int): void