slots

nimony/lib/std/ioring/core/slots.nim

• type SlotObj = object
    op: OpContext
    cancelRes: int64
    timerPos: int64
    backendData: pointer
    nextInFd: ref SlotObj
    prevInFd: ref SlotObj

• type Slot = ref SlotObj not nil

• type SlotArena = object
    fdHeads: seq[ref SlotObj]

• proc init(a: var SlotArena)
• proc toPointer(s: ref SlotObj not nil): pointer not nil

  The address a backend hands the kernel for s.

• proc toSlot(p: pointer): ref SlotObj not nil

  The slot whose toPointer is p. The slot must still be in flight.

• proc allocSlot(a: var SlotArena; op: OpContext): ref SlotObj

  A fresh slot holding op, or nil when memory is exhausted.

• proc freeSlot(a: var SlotArena; s: ref SlotObj not nil)

  Unlink s from its fd's list, which drops the ring's reference to it. The links are moved, not copied: every refcount update is atomic.

• proc hasPendingForFd(a: var SlotArena; fd: int32): bool

  var, like slotsForFd, purely to avoid copying the arena — see there.

• iterator slotsForFd(a: var SlotArena; fd: int32): ref SlotObj not nil

  Yield every in-flight slot for fd, O(k) in the number of ops on this fd rather than O(ops in flight).

  a is var even though nothing here writes to it: the callers all pass a seq element (gSlots[lane].slotsForFd(...)), and for a non-var parameter that materialises a copy of the arena's tables on every call. var passes the arena itself.

  The body may complete the slot it was handed (complete/closeFd both do), so the successor is taken before yielding; holding it also keeps it alive while the body runs.

• iterator pendingFds(a: var SlotArena): int32

  Every fd that has at least one in-flight slot. The table is mutated by freeSlot, so a caller that completes ops must collect the fds first and dispatch afterwards — never complete from inside this loop.

• iterator allSlots(a: var SlotArena): ref SlotObj not nil

  Every in-flight slot. The body must not complete any of them.