Index

Modules: sync, sync/atomics2, sync/barrier, sync/latch, sync/once, sync/rwlock, sync/semaphore, sync/smartptrs, sync/spinlock, sync/spsc, sync/spsc_queue.

API symbols

`$`:

• smartptrs: proc `$`[T](p: ConstPtr[T]): string
• smartptrs: proc `$`[T](p: SharedPtr[T]): string
• smartptrs: proc `$`[T](p: UniquePtr[T]): string

`+=`:

• atomics2: proc `+=`[T: SomeInteger](location: var Atomic[T]; value: T)

`-=`:

• atomics2: proc `-=`[T: SomeInteger](location: var Atomic[T]; value: T)

`=copy`:

• atomics2: proc `=copy`[T](dst: var Atomic[T]; src: Atomic[T])
• barrier: proc `=copy`(dest: var Barrier; source: Barrier)
• latch: proc `=copy`(dest: var Latch; source: Latch)
• rwlock: proc `=copy`(dest: var RwLock; source: RwLock)
• semaphore: proc `=copy`(dest: var Semaphore; source: Semaphore)
• smartptrs: proc `=copy`[T](dest: var SharedPtr[T]; src: SharedPtr[T])
• smartptrs: proc `=copy`[T](dest: var UniquePtr[T]; src: UniquePtr[T])
• spinlock: proc `=copy`(dest: var SpinLock; source: SpinLock)
• spsc_queue: proc `=copy`[T](dest: var SpscQueue[T]; source: SpscQueue[T])

`=destroy`:

• barrier: proc `=destroy`(b: var Barrier)
• latch: proc `=destroy`(x: var Latch)
• once: proc `=destroy`(o: var Once)
• rwlock: proc `=destroy`(rw: var RwLock)
• semaphore: proc `=destroy`(s: var Semaphore)
• smartptrs: proc `=destroy`[T](p: var SharedPtr[T])
• smartptrs: proc `=destroy`[T](p: var UniquePtr[T])
• spsc_queue: proc `=destroy`[T](self: var SpscQueue[T])

`=sink`:

• atomics2: proc `=sink`[T](dst: var Atomic[T]; src: Atomic[T])
• barrier: proc `=sink`(dest: var Barrier; source: Barrier)
• latch: proc `=sink`(dest: var Latch; source: Latch)
• rwlock: proc `=sink`(dest: var RwLock; source: RwLock)
• semaphore: proc `=sink`(dest: var Semaphore; source: Semaphore)
• spinlock: proc `=sink`(dest: var SpinLock; source: SpinLock)

`[]=`:

• smartptrs: proc `[]=`[T](p: ConstPtr[T]; v: T)
• smartptrs: proc `[]=`[T](p: SharedPtr[T]; val: sink Isolated[T])
• smartptrs: proc `[]=`[T](p: UniquePtr[T]; val: sink Isolated[T])
• smartptrs: template `[]=`[T](p: SharedPtr[T]; val: T)
• smartptrs: template `[]=`[T](p: UniquePtr[T]; val: T)

`[]`:

• smartptrs: proc `[]`[T](p: ConstPtr[T]): lent T
• smartptrs: proc `[]`[T](p: SharedPtr[T]): var T
• smartptrs: proc `[]`[T](p: UniquePtr[T]): var T

acquire:

• spinlock: proc acquire(s: var SpinLock)

Atomic:

• atomics2: type Atomic

atomicDec:

• atomics2: proc atomicDec[T: SomeInteger](location: var Atomic[T]; value: T = 1)

atomicInc:

• atomics2: proc atomicInc[T: SomeInteger](location: var Atomic[T]; value: T = 1)

Barrier:

• barrier: object Barrier

beginRead:

• rwlock: proc beginRead(rw: var RwLock)

beginWrite:

• rwlock: proc beginWrite(rw: var RwLock)

cap:

• spsc_queue: proc cap[T](self: SpscQueue[T]): int

compareExchange:

• atomics2: proc compareExchange[T](location: var Atomic[T]; expected: var T; desired: T; order: Ordering = SeqCst): bool
• atomics2: proc compareExchange[T](location: var Atomic[T]; expected: var T; desired: T; success, failure: Ordering): bool

compareExchangeWeak:

• atomics2: proc compareExchangeWeak[T](location: var Atomic[T]; expected: var T; desired: T; order: Ordering = SeqCst): bool
• atomics2: proc compareExchangeWeak[T](location: var Atomic[T]; expected: var T; desired: T; success, failure: Ordering): bool

ConstPtr:

• smartptrs: type ConstPtr

dec:

• latch: proc dec(x: var Latch)

endRead:

• rwlock: proc endRead(rw: var RwLock)

endWrite:

• rwlock: proc endWrite(rw: var RwLock)

exchange:

• atomics2: proc exchange[T](location: var Atomic[T]; desired: T; order: Ordering = SeqCst): T

fetchAdd:

• atomics2: proc fetchAdd[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchAnd:

• atomics2: proc fetchAnd[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchOr:

• atomics2: proc fetchOr[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchSub:

• atomics2: proc fetchSub[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchXor:

• atomics2: proc fetchXor[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

init:

• barrier: proc init(b: out Barrier; parties: Natural)
• latch: proc init(x: out Latch; count: Natural)
• once: proc init(o: var Once)
• rwlock: proc init(rw: out RwLock)
• semaphore: proc init(s: out Semaphore; count = 0)
• spsc_queue: proc init[T](self: out SpscQueue[T]; capacity: Natural)

isNil:

• smartptrs: proc isNil[T](p: ConstPtr[T]): bool
• smartptrs: proc isNil[T](p: SharedPtr[T]): bool
• smartptrs: proc isNil[T](p: UniquePtr[T]): bool

Latch:

• latch: object Latch

len:

• spsc_queue: proc len[T](self: SpscQueue[T]): int

load:

• atomics2: proc load[T](location: var Atomic[T]; order: Ordering = SeqCst): T

newConstPtr:

• smartptrs: proc newConstPtr[T](val: sink Isolated[T]): ConstPtr[T]
• smartptrs: template newConstPtr[T](val: T): ConstPtr[T]

newSharedPtr:

• smartptrs: proc newSharedPtr[T](val: sink Isolated[T]): SharedPtr[T]
• smartptrs: proc newSharedPtr[T](t: typedesc[T]): SharedPtr[T]
• smartptrs: template newSharedPtr[T](val: T): SharedPtr[T]

newSpscChannel:

• spsc: proc newSpscChannel[T](cap: int): (SpscSender[T], SpscReceiver[T])

newSpscQueue:

• spsc_queue: proc newSpscQueue[T](cap: int): SpscQueue[T]

newSpscReceiver:

• spsc: proc newSpscReceiver[T](queue: sink SharedPtr[SpscQueue[T]]): SpscReceiver[T]

newSpscSender:

• spsc: proc newSpscSender[T](queue: sink SharedPtr[SpscQueue[T]]): SpscSender[T]

newUniquePtr:

• smartptrs: proc newUniquePtr[T](val: sink Isolated[T]): UniquePtr[T]
• smartptrs: proc newUniquePtr[T](t: typedesc[T]): UniquePtr[T]
• smartptrs: template newUniquePtr[T](val: T): UniquePtr[T]

Once:

• once: object Once

once:

• once: template once(o: Once; body: untyped)

Ordering:

• atomics2: enum Ordering

readWith:

• rwlock: template readWith(a: RwLock; body: untyped)

release:

• spinlock: proc release(s: var SpinLock)

RwLock:

• rwlock: object RwLock

Semaphore:

• semaphore: object Semaphore

SharedPtr:

• smartptrs: object SharedPtr

signal:

• semaphore: proc signal(s: var Semaphore)

SpinLock:

• spinlock: object SpinLock

SpscQueue:

• spsc_queue: object SpscQueue

SpscReceiver:

• spsc: object SpscReceiver

SpscSender:

• spsc: object SpscSender

store:

• atomics2: proc store[T](location: var Atomic[T]; desired: T; order: Ordering = SeqCst)

tryAcquire:

• spinlock: proc tryAcquire(s: var SpinLock): bool

tryPop:

• spsc_queue: proc tryPop[T](self: var SpscQueue[T]; value: var T): bool

tryPush:

• spsc_queue: proc tryPush[T](self: var SpscQueue[T]; value: var Isolated[T]): bool
• spsc_queue: template tryPush[T](self: SpscQueue[T]; value: T): bool

tryRecv:

• spsc: proc tryRecv[T](self: SpscReceiver; dst: out T): bool

trySend:

• spsc: proc trySend[T](self: SpscSender; t: var Isolated[T]): bool
• spsc: template trySend[T](self: SpscSender[T]; value: T): bool

UniquePtr:

• smartptrs: object UniquePtr

wait:

• barrier: proc wait(b: var Barrier)
• latch: proc wait(x: var Latch)
• semaphore: proc wait(s: var Semaphore)

withLock:

• spinlock: template withLock(a: SpinLock; body: untyped)

writeWith:

• rwlock: template writeWith(a: RwLock; body: untyped)