@salang/sa 0.1.2 → 0.1.4

package/sa_std/sync/mpsc.sa

@@ -0,0 +1,758 @@
+// Bounded MPSC ring buffer built on inline storage and atomic indices.
+// Payloads are raw u64 bits; callers cast at the boundary explicitly.
+@import "mpsc.sal"
+@import "../core/mem.sa"
+@import "../num.sa"
+@import "../time.sai"
+
+@__mpsc_try_send(&chan: ptr, &value_slot: ptr) -> i32:
+L_ENTRY:
+    cap = atomic_load chan+Mpsc_cap as u64 acquire
+    head = atomic_load chan+Mpsc_head as u64 acquire
+    tail = atomic_load chan+Mpsc_tail as u64 acquire
+    tail_ok = uge tail, head
+    br tail_ok -> L_MPSC_TRY_SEND_USED_OK, L_MPSC_TRY_SEND_CORRUPT
+
+L_MPSC_TRY_SEND_CORRUPT:
+    used = add cap, 0
+    jmp L_MPSC_TRY_SEND_CHECK_FULL
+
+L_MPSC_TRY_SEND_USED_OK:
+    used = sub tail, head
+
+L_MPSC_TRY_SEND_CHECK_FULL:
+    full = uge used, cap
+    br full -> L_MPSC_TRY_SEND_FULL, L_MPSC_TRY_SEND_RESERVE
+
+L_MPSC_TRY_SEND_FULL:
+    !full
+    !used
+    !tail_ok
+    !tail
+    !head
+    !cap
+    return 0
+
+L_MPSC_TRY_SEND_RESERVE:
+    next_tail = add tail, 1
+    old_tail, ok = cmpxchg chan+Mpsc_tail, tail, next_tail as u64 acq_rel acquire
+    br ok -> L_MPSC_TRY_SEND_COMMIT, L_MPSC_TRY_SEND_RETRY
+
+L_MPSC_TRY_SEND_RETRY:
+    !old_tail
+    !ok
+    !next_tail
+    !full
+    !used
+    !tail_ok
+    !tail
+    !head
+    !cap
+    return 0
+
+L_MPSC_TRY_SEND_COMMIT:
+    slot_index = urem tail, cap
+    slot_base = ptr_add chan, Mpsc_data
+    slot_off = mul slot_index, Mpsc_SLOT_SIZE
+    slot = ptr_add slot_base, slot_off
+    message = load value_slot+0 as u64
+    store slot+Mpsc_SLOT_value, message as u64
+    atomic_store slot+Mpsc_SLOT_ready, Mpsc_SLOT_READY as u64 release
+    !message
+    !slot
+    !slot_index
+    !slot_off
+    !slot_base
+    !old_tail
+    !ok
+    !next_tail
+    !full
+    !used
+    !tail_ok
+    !tail
+    !head
+    !cap
+    return 1
+
+@__mpsc_try_recv(&chan: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    cap = atomic_load chan+Mpsc_cap as u64 acquire
+    head = atomic_load chan+Mpsc_head as u64 acquire
+    tail = atomic_load chan+Mpsc_tail as u64 acquire
+    tail_ok = uge tail, head
+    br tail_ok -> L_MPSC_TRY_RECV_ORDER_OK, L_MPSC_TRY_RECV_CORRUPT
+
+L_MPSC_TRY_RECV_CORRUPT:
+    !tail_ok
+    !tail
+    !head
+    !cap
+    return 0
+
+L_MPSC_TRY_RECV_ORDER_OK:
+    empty = eq head, tail
+    br empty -> L_MPSC_TRY_RECV_EMPTY, L_MPSC_TRY_RECV_CHECK
+
+L_MPSC_TRY_RECV_EMPTY:
+    !empty
+    !tail_ok
+    !tail
+    !head
+    !cap
+    return 0
+
+L_MPSC_TRY_RECV_CHECK:
+    slot_index = urem head, cap
+    slot_base = ptr_add chan, Mpsc_data
+    slot_off = mul slot_index, Mpsc_SLOT_SIZE
+    slot = ptr_add slot_base, slot_off
+    ready = atomic_load slot+Mpsc_SLOT_ready as u64 acquire
+    is_ready = eq ready, Mpsc_SLOT_READY
+    br is_ready -> L_MPSC_TRY_RECV_COMMIT, L_MPSC_TRY_RECV_WAIT
+
+L_MPSC_TRY_RECV_WAIT:
+    !is_ready
+    !ready
+    !slot
+    !slot_index
+    !slot_off
+    !slot_base
+    !tail_ok
+    !tail
+    !head
+    !cap
+    return 0
+
+L_MPSC_TRY_RECV_COMMIT:
+    message = load slot+Mpsc_SLOT_value as u64
+    atomic_store slot+Mpsc_SLOT_ready, Mpsc_SLOT_EMPTY as u64 release
+    next_head = add head, 1
+    atomic_store chan+Mpsc_head, next_head as u64 release
+    store out_value_slot+0, message as u64
+    !message
+    !next_head
+    !is_ready
+    !ready
+    !slot
+    !slot_index
+    !slot_off
+    !slot_base
+    !tail_ok
+    !tail
+    !head
+    !cap
+    return 1
+
+[MACRO] MPSC_NEW %out_chan, %cap
+    // Keep the normalization branchless to avoid backend miscompilation
+    // when the cap is a constant and the whole control-flow diamond folds.
+    __mpsc_cap_is_zero_%out_chan = eq %cap, 0
+    __mpsc_cap_%out_chan = add %cap, __mpsc_cap_is_zero_%out_chan
+    EXPAND NUM_U64_CHECKED_MUL __mpsc_data_ok_%out_chan, __mpsc_data_bytes_%out_chan, __mpsc_cap_%out_chan, Mpsc_SLOT_SIZE
+    br __mpsc_data_ok_%out_chan -> L_MPSC_NEW_DATA_OK_%out_chan, L_MPSC_NEW_DATA_OVERFLOW_%out_chan
+L_MPSC_NEW_DATA_OVERFLOW_%out_chan:
+    panic(1401)
+L_MPSC_NEW_DATA_OK_%out_chan:
+    EXPAND NUM_U64_CHECKED_ADD __mpsc_total_ok_%out_chan, __mpsc_total_bytes_%out_chan, Mpsc_data, __mpsc_data_bytes_%out_chan
+    br __mpsc_total_ok_%out_chan -> L_MPSC_NEW_ALLOC_%out_chan, L_MPSC_NEW_TOTAL_OVERFLOW_%out_chan
+L_MPSC_NEW_TOTAL_OVERFLOW_%out_chan:
+    panic(1402)
+L_MPSC_NEW_ALLOC_%out_chan:
+    %out_chan = alloc __mpsc_total_bytes_%out_chan
+    call @sa_mem_set(&%out_chan, 0, __mpsc_total_bytes_%out_chan)
+    store %out_chan+Mpsc_cap, __mpsc_cap_%out_chan as u64
+    store %out_chan+Mpsc_head, 0 as u64
+    store %out_chan+Mpsc_tail, 0 as u64
+    !__mpsc_total_ok_%out_chan
+    !__mpsc_total_bytes_%out_chan
+    !__mpsc_data_ok_%out_chan
+    !__mpsc_data_bytes_%out_chan
+    !__mpsc_cap_%out_chan
+    !__mpsc_cap_is_zero_%out_chan
+[END_MACRO]
+
+// Concrete default capacity for Default-style construction.
+// Not Rust's unbounded channel; keeps the existing bounded MPSC facade.
+[MACRO] MPSC_DEFAULT %out_chan
+    EXPAND MPSC_NEW %out_chan, 16
+[END_MACRO]
+
+[MACRO] MPSC_SEND_ERROR_NEW %out_error, %value
+    %out_error = alloc SendErrorU64_SIZE
+    store %out_error+SendErrorU64_value, %value as u64
+[END_MACRO]
+
+[MACRO] MPSC_SEND_ERROR_VALUE %out_value, %error_reg
+    %out_value = load %error_reg+SendErrorU64_value as u64
+[END_MACRO]
+
+[MACRO] MPSC_TRY_SEND_ERROR_NEW %out_error, %kind, %value
+    %out_error = alloc TrySendErrorU64_SIZE
+    store %out_error+TrySendErrorU64_kind, %kind as u64
+    store %out_error+TrySendErrorU64_value, %value as u64
+[END_MACRO]
+
+[MACRO] MPSC_TRY_SEND_ERROR_KIND %out_kind, %error_reg
+    %out_kind = load %error_reg+TrySendErrorU64_kind as u64
+[END_MACRO]
+
+[MACRO] MPSC_TRY_SEND_ERROR_VALUE %out_value, %error_reg
+    %out_value = load %error_reg+TrySendErrorU64_value as u64
+[END_MACRO]
+
+[MACRO] MPSC_TRY_RECV_ERROR_NEW %out_error, %kind
+    %out_error = alloc TryRecvError_SIZE
+    store %out_error+TryRecvError_kind, %kind as u64
+[END_MACRO]
+
+[MACRO] MPSC_TRY_RECV_ERROR_KIND %out_kind, %error_reg
+    %out_kind = load %error_reg+TryRecvError_kind as u64
+[END_MACRO]
+
+[MACRO] MPSC_RECV_TIMEOUT_ERROR_NEW %out_error, %kind
+    %out_error = alloc RecvTimeoutError_SIZE
+    store %out_error+RecvTimeoutError_kind, %kind as u64
+[END_MACRO]
+
+[MACRO] MPSC_RECV_TIMEOUT_ERROR_KIND %out_kind, %error_reg
+    %out_kind = load %error_reg+RecvTimeoutError_kind as u64
+[END_MACRO]
+[MACRO] MPSC_FREE %chan
+    !%chan
+[END_MACRO]
+
+[MACRO] MPSC_CAPACITY %out_cap, %chan
+    %out_cap = atomic_load %chan+Mpsc_cap as u64 acquire
+[END_MACRO]
+
+[MACRO] MPSC_LEN %out_len, %chan
+    __mpsc_len_head_%out_len = atomic_load %chan+Mpsc_head as u64 acquire
+    __mpsc_len_tail_%out_len = atomic_load %chan+Mpsc_tail as u64 acquire
+    __mpsc_len_order_ok_%out_len = uge __mpsc_len_tail_%out_len, __mpsc_len_head_%out_len
+    br __mpsc_len_order_ok_%out_len -> L_MPSC_LEN_OK_%out_len, L_MPSC_LEN_CORRUPT_%out_len
+L_MPSC_LEN_OK_%out_len:
+    %out_len = sub __mpsc_len_tail_%out_len, __mpsc_len_head_%out_len
+    !__mpsc_len_order_ok_%out_len
+    jmp L_MPSC_LEN_DONE_%out_len
+L_MPSC_LEN_CORRUPT_%out_len:
+    %out_len = add 0, 0
+    !__mpsc_len_order_ok_%out_len
+L_MPSC_LEN_DONE_%out_len:
+    !__mpsc_len_tail_%out_len
+    !__mpsc_len_head_%out_len
+[END_MACRO]
+
+[MACRO] MPSC_AVAILABLE %out_slots, %chan
+    __mpsc_avail_cap_%out_slots = atomic_load %chan+Mpsc_cap as u64 acquire
+    __mpsc_avail_head_%out_slots = atomic_load %chan+Mpsc_head as u64 acquire
+    __mpsc_avail_tail_%out_slots = atomic_load %chan+Mpsc_tail as u64 acquire
+    __mpsc_avail_order_ok_%out_slots = uge __mpsc_avail_tail_%out_slots, __mpsc_avail_head_%out_slots
+    br __mpsc_avail_order_ok_%out_slots -> L_MPSC_AVAIL_USED_OK_%out_slots, L_MPSC_AVAIL_CORRUPT_%out_slots
+L_MPSC_AVAIL_USED_OK_%out_slots:
+    __mpsc_avail_used_%out_slots = sub __mpsc_avail_tail_%out_slots, __mpsc_avail_head_%out_slots
+    jmp L_MPSC_AVAIL_CALC_%out_slots
+L_MPSC_AVAIL_CORRUPT_%out_slots:
+    __mpsc_avail_used_%out_slots = add __mpsc_avail_cap_%out_slots, 0
+L_MPSC_AVAIL_CALC_%out_slots:
+    %out_slots = sub __mpsc_avail_cap_%out_slots, __mpsc_avail_used_%out_slots
+    !__mpsc_avail_used_%out_slots
+    !__mpsc_avail_order_ok_%out_slots
+    !__mpsc_avail_tail_%out_slots
+    !__mpsc_avail_head_%out_slots
+    !__mpsc_avail_cap_%out_slots
+[END_MACRO]
+
+[MACRO] MPSC_IS_EMPTY %out_bool, %chan
+    __mpsc_empty_head_%out_bool = atomic_load %chan+Mpsc_head as u64 acquire
+    __mpsc_empty_tail_%out_bool = atomic_load %chan+Mpsc_tail as u64 acquire
+    %out_bool = eq __mpsc_empty_head_%out_bool, __mpsc_empty_tail_%out_bool
+    !__mpsc_empty_tail_%out_bool
+    !__mpsc_empty_head_%out_bool
+[END_MACRO]
+
+[MACRO] MPSC_IS_FULL %out_bool, %chan
+    __mpsc_full_cap_%out_bool = atomic_load %chan+Mpsc_cap as u64 acquire
+    __mpsc_full_head_%out_bool = atomic_load %chan+Mpsc_head as u64 acquire
+    __mpsc_full_tail_%out_bool = atomic_load %chan+Mpsc_tail as u64 acquire
+    __mpsc_full_order_ok_%out_bool = uge __mpsc_full_tail_%out_bool, __mpsc_full_head_%out_bool
+    br __mpsc_full_order_ok_%out_bool -> L_MPSC_FULL_USED_OK_%out_bool, L_MPSC_FULL_CORRUPT_%out_bool
+L_MPSC_FULL_USED_OK_%out_bool:
+    __mpsc_full_used_%out_bool = sub __mpsc_full_tail_%out_bool, __mpsc_full_head_%out_bool
+    jmp L_MPSC_FULL_CALC_%out_bool
+L_MPSC_FULL_CORRUPT_%out_bool:
+    __mpsc_full_used_%out_bool = add __mpsc_full_cap_%out_bool, 0
+L_MPSC_FULL_CALC_%out_bool:
+    %out_bool = uge __mpsc_full_used_%out_bool, __mpsc_full_cap_%out_bool
+    !__mpsc_full_used_%out_bool
+    !__mpsc_full_order_ok_%out_bool
+    !__mpsc_full_tail_%out_bool
+    !__mpsc_full_head_%out_bool
+    !__mpsc_full_cap_%out_bool
+[END_MACRO]
+
+[MACRO] MPSC_TRY_SEND_ERROR %out_ok, %out_error, %chan, %value
+    __mpsc_send_error_disconnected_%out_ok = eq %chan, 0
+    br __mpsc_send_error_disconnected_%out_ok -> L_MPSC_SEND_ERROR_DISCONNECTED_%out_ok, L_MPSC_SEND_ERROR_CALL_%out_ok
+L_MPSC_SEND_ERROR_CALL_%out_ok:
+    EXPAND MPSC_TRY_SEND %out_ok, %chan, %value
+    br %out_ok -> L_MPSC_SEND_ERROR_OK_%out_ok, L_MPSC_SEND_ERROR_FULL_%out_ok
+L_MPSC_SEND_ERROR_OK_%out_ok:
+    %out_error = add 0, 0
+    jmp L_MPSC_SEND_ERROR_DONE_%out_ok
+L_MPSC_SEND_ERROR_FULL_%out_ok:
+    EXPAND MPSC_TRY_SEND_ERROR_NEW %out_error, TRY_SEND_ERROR_FULL, %value
+    jmp L_MPSC_SEND_ERROR_DONE_%out_ok
+L_MPSC_SEND_ERROR_DISCONNECTED_%out_ok:
+    EXPAND MPSC_TRY_SEND_ERROR_NEW %out_error, TRY_SEND_ERROR_DISCONNECTED, %value
+L_MPSC_SEND_ERROR_DONE_%out_ok:
+    !__mpsc_send_error_disconnected_%out_ok
+[END_MACRO]
+
+[MACRO] MPSC_TRY_RECV_ERROR %out_ok, %out_error, %out_value, %chan
+    __mpsc_recv_error_disconnected_%out_ok = eq %chan, 0
+    br __mpsc_recv_error_disconnected_%out_ok -> L_MPSC_RECV_ERROR_DISCONNECTED_%out_ok, L_MPSC_RECV_ERROR_CALL_%out_ok
+L_MPSC_RECV_ERROR_CALL_%out_ok:
+    EXPAND MPSC_TRY_RECV %out_ok, %out_value, %chan
+    br %out_ok -> L_MPSC_RECV_ERROR_OK_%out_ok, L_MPSC_RECV_ERROR_EMPTY_%out_ok
+L_MPSC_RECV_ERROR_OK_%out_ok:
+    %out_error = add 0, 0
+    jmp L_MPSC_RECV_ERROR_DONE_%out_ok
+L_MPSC_RECV_ERROR_EMPTY_%out_ok:
+    EXPAND MPSC_TRY_RECV_ERROR_NEW %out_error, TRY_RECV_ERROR_EMPTY
+    jmp L_MPSC_RECV_ERROR_DONE_%out_ok
+L_MPSC_RECV_ERROR_DISCONNECTED_%out_ok:
+    %out_value = add 0, 0
+    EXPAND MPSC_TRY_RECV_ERROR_NEW %out_error, TRY_RECV_ERROR_DISCONNECTED
+L_MPSC_RECV_ERROR_DONE_%out_ok:
+    !__mpsc_recv_error_disconnected_%out_ok
+[END_MACRO]
+[MACRO] MPSC_TRY_SEND %out_ok, %chan, %value
+    __mpsc_value_slot_%out_ok = stack_alloc 8
+    store __mpsc_value_slot_%out_ok+0, %value as u64
+    __mpsc_ok_%out_ok = call @__mpsc_try_send(&%chan, &__mpsc_value_slot_%out_ok)
+    br __mpsc_ok_%out_ok -> L_MPSC_TRY_SEND_OK_%out_ok, L_MPSC_TRY_SEND_FAIL_%out_ok
+L_MPSC_TRY_SEND_OK_%out_ok:
+    %out_ok = __mpsc_ok_%out_ok
+    jmp L_MPSC_TRY_SEND_DONE_%out_ok
+L_MPSC_TRY_SEND_FAIL_%out_ok:
+    %out_ok = __mpsc_ok_%out_ok
+    jmp L_MPSC_TRY_SEND_DONE_%out_ok
+L_MPSC_TRY_SEND_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_SEND %chan, %value
+    // Keep the payload slot outside the retry loop so the allocation
+    // stays live across re-entry without creating phi conflicts.
+    __mpsc_value_slot_%value = stack_alloc 8
+    store __mpsc_value_slot_%value+0, %value as u64
+L_MPSC_SEND_ENTRY_%value:
+    __mpsc_send_ok_%value = call @__mpsc_try_send(&%chan, &__mpsc_value_slot_%value)
+    br __mpsc_send_ok_%value -> L_MPSC_SEND_DONE_%value, L_MPSC_SEND_WAIT_%value
+L_MPSC_SEND_WAIT_%value:
+    !__mpsc_send_ok_%value
+    call @sa_time_sleep_ns(1)
+    jmp L_MPSC_SEND_ENTRY_%value
+L_MPSC_SEND_DONE_%value:
+    !%value
+    !__mpsc_send_ok_%value
+[END_MACRO]
+
+[MACRO] MPSC_TRY_RECV %out_ok, %out_value, %chan
+    __mpsc_value_slot_%out_ok = stack_alloc 8
+    __mpsc_ok_%out_ok = call @__mpsc_try_recv(&%chan, &__mpsc_value_slot_%out_ok)
+    br __mpsc_ok_%out_ok -> L_MPSC_TRY_RECV_OK_%out_ok, L_MPSC_TRY_RECV_FAIL_%out_ok
+L_MPSC_TRY_RECV_OK_%out_ok:
+    %out_value = load __mpsc_value_slot_%out_ok+0 as u64
+    %out_ok = __mpsc_ok_%out_ok
+    jmp L_MPSC_TRY_RECV_DONE_%out_ok
+L_MPSC_TRY_RECV_FAIL_%out_ok:
+    %out_value = 0 as u64
+    %out_ok = __mpsc_ok_%out_ok
+    jmp L_MPSC_TRY_RECV_DONE_%out_ok
+L_MPSC_TRY_RECV_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_RECV %out_value, %chan
+    // Keep the receive slot outside the retry loop for the same reason:
+    // the loop re-enters the same live allocation on every spin.
+    __mpsc_value_slot_%out_value = stack_alloc 8
+L_MPSC_RECV_ENTRY_%out_value:
+    __mpsc_recv_ok_%out_value = call @__mpsc_try_recv(&%chan, &__mpsc_value_slot_%out_value)
+    br __mpsc_recv_ok_%out_value -> L_MPSC_RECV_DONE_%out_value, L_MPSC_RECV_WAIT_%out_value
+L_MPSC_RECV_WAIT_%out_value:
+    !__mpsc_recv_ok_%out_value
+    call @sa_time_sleep_ns(1)
+    jmp L_MPSC_RECV_ENTRY_%out_value
+L_MPSC_RECV_DONE_%out_value:
+    %out_value = load __mpsc_value_slot_%out_value+0 as u64
+    !__mpsc_recv_ok_%out_value
+[END_MACRO]
+
+// Concrete channel handle split: both ends share the same ring buffer pointer.
+// Does not model disconnect/drop of half; free still goes through MPSC_FREE on channel.
+
+[MACRO] MPSC_CHANNEL %out_tx, %out_rx, %cap
+    EXPAND MPSC_NEW __mpsc_ch_chan_%out_tx, %cap
+    %out_tx = alloc MpscSender_SIZE
+    %out_rx = alloc MpscReceiver_SIZE
+    store %out_tx+MpscSender_chan, __mpsc_ch_chan_%out_tx as ptr
+    store %out_rx+MpscReceiver_chan, __mpsc_ch_chan_%out_tx as ptr
+    !__mpsc_ch_chan_%out_tx
+[END_MACRO]
+
+[MACRO] MPSC_TX_IS_DISCONNECTED %out_bool, %tx
+    __mpsc_tx_disconnected_chan_%out_bool = load %tx+MpscSender_chan as ptr
+    %out_bool = eq __mpsc_tx_disconnected_chan_%out_bool, 0
+    !__mpsc_tx_disconnected_chan_%out_bool
+[END_MACRO]
+
+[MACRO] MPSC_RX_IS_DISCONNECTED %out_bool, %rx
+    __mpsc_rx_disconnected_chan_%out_bool = load %rx+MpscReceiver_chan as ptr
+    %out_bool = eq __mpsc_rx_disconnected_chan_%out_bool, 0
+    !__mpsc_rx_disconnected_chan_%out_bool
+[END_MACRO]
+
+[MACRO] MPSC_CHANNEL_IS_DISCONNECTED %out_bool, %tx, %rx
+    __mpsc_channel_tx_chan_%out_bool = load %tx+MpscSender_chan as ptr
+    __mpsc_channel_rx_chan_%out_bool = load %rx+MpscReceiver_chan as ptr
+    __mpsc_channel_tx_empty_%out_bool = eq __mpsc_channel_tx_chan_%out_bool, 0
+    __mpsc_channel_rx_empty_%out_bool = eq __mpsc_channel_rx_chan_%out_bool, 0
+    %out_bool = and __mpsc_channel_tx_empty_%out_bool, __mpsc_channel_rx_empty_%out_bool
+    !__mpsc_channel_rx_empty_%out_bool
+    !__mpsc_channel_tx_empty_%out_bool
+    !__mpsc_channel_rx_chan_%out_bool
+    !__mpsc_channel_tx_chan_%out_bool
+[END_MACRO]
+[MACRO] MPSC_TX_DROP %tx
+    store %tx+MpscSender_chan, 0 as ptr
+[END_MACRO]
+
+[MACRO] MPSC_RX_DROP %rx
+    store %rx+MpscReceiver_chan, 0 as ptr
+[END_MACRO]
+
+[MACRO] MPSC_TX_TRY_SEND %out_ok, %tx, %value
+    __mpsc_tx_chan_%out_ok = load %tx+MpscSender_chan as ptr
+    __mpsc_tx_disconnected_%out_ok = eq __mpsc_tx_chan_%out_ok, 0
+    br __mpsc_tx_disconnected_%out_ok -> L_MPSC_TX_TRY_SEND_FAIL_%out_ok, L_MPSC_TX_TRY_SEND_CALL_%out_ok
+L_MPSC_TX_TRY_SEND_CALL_%out_ok:
+    EXPAND MPSC_TRY_SEND %out_ok, __mpsc_tx_chan_%out_ok, %value
+    !__mpsc_tx_disconnected_%out_ok
+    !__mpsc_tx_chan_%out_ok
+    jmp L_MPSC_TX_TRY_SEND_DONE_%out_ok
+L_MPSC_TX_TRY_SEND_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__mpsc_tx_disconnected_%out_ok
+    !__mpsc_tx_chan_%out_ok
+L_MPSC_TX_TRY_SEND_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_TX_SEND %tx, %value
+    __mpsc_tx_chan_s_%tx = load %tx+MpscSender_chan as ptr
+    __mpsc_tx_disconnected_s_%tx = eq __mpsc_tx_chan_s_%tx, 0
+    br __mpsc_tx_disconnected_s_%tx -> L_MPSC_TX_SEND_DONE_%tx, L_MPSC_TX_SEND_CALL_%tx
+L_MPSC_TX_SEND_CALL_%tx:
+    EXPAND MPSC_SEND __mpsc_tx_chan_s_%tx, %value
+    !__mpsc_tx_disconnected_s_%tx
+    !__mpsc_tx_chan_s_%tx
+L_MPSC_TX_SEND_DONE_%tx:
+    !__mpsc_tx_disconnected_s_%tx
+    !__mpsc_tx_chan_s_%tx
+[END_MACRO]
+
+[MACRO] MPSC_RX_TRY_RECV %out_ok, %out_value, %rx
+    __mpsc_rx_chan_%out_ok = load %rx+MpscReceiver_chan as ptr
+    __mpsc_rx_disconnected_%out_ok = eq __mpsc_rx_chan_%out_ok, 0
+    br __mpsc_rx_disconnected_%out_ok -> L_MPSC_RX_TRY_RECV_FAIL_%out_ok, L_MPSC_RX_TRY_RECV_CALL_%out_ok
+L_MPSC_RX_TRY_RECV_CALL_%out_ok:
+    EXPAND MPSC_TRY_RECV %out_ok, %out_value, __mpsc_rx_chan_%out_ok
+    !__mpsc_rx_disconnected_%out_ok
+    !__mpsc_rx_chan_%out_ok
+    jmp L_MPSC_RX_TRY_RECV_DONE_%out_ok
+L_MPSC_RX_TRY_RECV_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    !__mpsc_rx_disconnected_%out_ok
+    !__mpsc_rx_chan_%out_ok
+L_MPSC_RX_TRY_RECV_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_RX_RECV %out_value, %rx
+    __mpsc_rx_chan_r_%out_value = load %rx+MpscReceiver_chan as ptr
+    __mpsc_rx_disconnected_r_%out_value = eq __mpsc_rx_chan_r_%out_value, 0
+    br __mpsc_rx_disconnected_r_%out_value -> L_MPSC_RX_RECV_EMPTY_%out_value, L_MPSC_RX_RECV_CALL_%out_value
+L_MPSC_RX_RECV_CALL_%out_value:
+    EXPAND MPSC_RECV %out_value, __mpsc_rx_chan_r_%out_value
+    !__mpsc_rx_disconnected_r_%out_value
+    !__mpsc_rx_chan_r_%out_value
+    jmp L_MPSC_RX_RECV_DONE_%out_value
+L_MPSC_RX_RECV_EMPTY_%out_value:
+    %out_value = add 0, 0
+L_MPSC_RX_RECV_DONE_%out_value:
+    !__mpsc_rx_disconnected_r_%out_value
+    !__mpsc_rx_chan_r_%out_value
+[END_MACRO]
+
+[MACRO] MPSC_CHANNEL_FREE %tx, %rx
+    __mpsc_cf_chan_%tx = load %tx+MpscSender_chan as ptr
+    EXPAND MPSC_FREE __mpsc_cf_chan_%tx
+    EXPAND MPSC_TX_DROP %tx
+    EXPAND MPSC_RX_DROP %rx
+[END_MACRO]
+// Unbounded-style channel: large fixed capacity ring (not growable; SA subset).
+[MACRO] MPSC_UNBOUNDED %out_tx, %out_rx
+    EXPAND MPSC_CHANNEL %out_tx, %out_rx, 1024
+[END_MACRO]
+
+[MACRO] MPSC_CHANNEL_DEFAULT %out_tx, %out_rx
+    EXPAND MPSC_CHANNEL %out_tx, %out_rx, 16
+[END_MACRO]
+
+@__mpsc_try_recv_timeout_ns(&chan: ptr, &out_value_slot: ptr, timeout_ns: u64) -> i32:
+L_ENTRY:
+    start = call @sa_time_instant_ns()
+    backoff_slot = stack_alloc 8
+    store backoff_slot+0, 1 as u64
+    jmp L_TO_TRY
+L_TO_TRY:
+    ok = call @__mpsc_try_recv(&chan, &out_value_slot)
+    br ok -> L_TO_OK, L_TO_CHECK
+L_TO_OK:
+    !start
+    !timeout_ns
+    return 1
+L_TO_CHECK:
+    now = call @sa_time_instant_ns()
+    elapsed = sub now, start
+    timed_out = uge elapsed, timeout_ns
+    !now
+    !elapsed
+    br timed_out -> L_TO_TIMEOUT, L_TO_BACKOFF
+L_TO_BACKOFF:
+    backoff_ns = load backoff_slot+0 as u64
+    call @sa_time_sleep_ns(backoff_ns)
+    at_limit = uge backoff_ns, 1024
+    br at_limit -> L_TO_KEEP, L_TO_GROW
+L_TO_GROW:
+    next = shl backoff_ns, 1
+    store backoff_slot+0, next as u64
+    !next
+    !at_limit
+    !backoff_ns
+    !timed_out
+    !ok
+    jmp L_TO_TRY
+L_TO_KEEP:
+    !at_limit
+    !backoff_ns
+    !timed_out
+    !ok
+    jmp L_TO_TRY
+L_TO_TIMEOUT:
+    !timed_out
+    !ok
+    !start
+    !timeout_ns
+    return 0
+
+[MACRO] MPSC_TRY_RECV_TIMEOUT_ERROR %out_ok, %out_error, %out_value, %chan, %timeout_ns
+    __mpsc_recv_timeout_error_disconnected_%out_ok = eq %chan, 0
+    br __mpsc_recv_timeout_error_disconnected_%out_ok -> L_MPSC_RECV_TIMEOUT_ERROR_DISCONNECTED_%out_ok, L_MPSC_RECV_TIMEOUT_ERROR_CALL_%out_ok
+L_MPSC_RECV_TIMEOUT_ERROR_CALL_%out_ok:
+    EXPAND MPSC_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, %chan, %timeout_ns
+    br %out_ok -> L_MPSC_RECV_TIMEOUT_ERROR_OK_%out_ok, L_MPSC_RECV_TIMEOUT_ERROR_TIMEOUT_%out_ok
+L_MPSC_RECV_TIMEOUT_ERROR_OK_%out_ok:
+    %out_error = add 0, 0
+    jmp L_MPSC_RECV_TIMEOUT_ERROR_DONE_%out_ok
+L_MPSC_RECV_TIMEOUT_ERROR_TIMEOUT_%out_ok:
+    EXPAND MPSC_RECV_TIMEOUT_ERROR_NEW %out_error, RECV_TIMEOUT_ERROR_TIMEOUT
+    jmp L_MPSC_RECV_TIMEOUT_ERROR_DONE_%out_ok
+L_MPSC_RECV_TIMEOUT_ERROR_DISCONNECTED_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    EXPAND MPSC_RECV_TIMEOUT_ERROR_NEW %out_error, RECV_TIMEOUT_ERROR_DISCONNECTED
+L_MPSC_RECV_TIMEOUT_ERROR_DONE_%out_ok:
+    !__mpsc_recv_timeout_error_disconnected_%out_ok
+[END_MACRO]
+
+[MACRO] MPSC_RX_TRY_RECV_TIMEOUT_ERROR %out_ok, %out_error, %out_value, %rx, %timeout_ns
+    __mpsc_rx_timeout_error_chan_%out_ok = load %rx+MpscReceiver_chan as ptr
+    EXPAND MPSC_TRY_RECV_TIMEOUT_ERROR %out_ok, %out_error, %out_value, __mpsc_rx_timeout_error_chan_%out_ok, %timeout_ns
+    !__mpsc_rx_timeout_error_chan_%out_ok
+[END_MACRO]
+[MACRO] MPSC_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, %chan, %timeout_ns
+    __mpsc_to_slot_%out_ok = stack_alloc 8
+    store __mpsc_to_slot_%out_ok+0, 0 as u64
+    %out_ok = call @__mpsc_try_recv_timeout_ns(&%chan, &__mpsc_to_slot_%out_ok, %timeout_ns)
+    %out_value = load __mpsc_to_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] MPSC_RX_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, %rx, %timeout_ns
+    __mpsc_rx_to_chan_%out_ok = load %rx+MpscReceiver_chan as ptr
+    __mpsc_rx_to_disconnected_%out_ok = eq __mpsc_rx_to_chan_%out_ok, 0
+    br __mpsc_rx_to_disconnected_%out_ok -> L_MPSC_RX_TIMEOUT_EMPTY_%out_ok, L_MPSC_RX_TIMEOUT_CALL_%out_ok
+L_MPSC_RX_TIMEOUT_CALL_%out_ok:
+    EXPAND MPSC_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, __mpsc_rx_to_chan_%out_ok, %timeout_ns
+    jmp L_MPSC_RX_TIMEOUT_DONE_%out_ok
+L_MPSC_RX_TIMEOUT_EMPTY_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+L_MPSC_RX_TIMEOUT_DONE_%out_ok:
+    !__mpsc_rx_to_disconnected_%out_ok
+    !__mpsc_rx_to_chan_%out_ok
+[END_MACRO]
+
+[MACRO] MPSC_TRY_RECV_TIMEOUT_MS %out_ok, %out_value, %chan, %timeout_ms
+    EXPAND NUM_U64_CHECKED_MUL __mpsc_recv_timeout_mul_ok_%out_ok, __mpsc_recv_timeout_ns_%out_ok, %timeout_ms, 1000000
+    br __mpsc_recv_timeout_mul_ok_%out_ok -> L_MPSC_RECV_TIMEOUT_MS_OK_%out_ok, L_MPSC_RECV_TIMEOUT_MS_FAIL_%out_ok
+L_MPSC_RECV_TIMEOUT_MS_OK_%out_ok:
+    EXPAND MPSC_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, %chan, __mpsc_recv_timeout_ns_%out_ok
+    !__mpsc_recv_timeout_ns_%out_ok
+    !__mpsc_recv_timeout_mul_ok_%out_ok
+    jmp L_MPSC_RECV_TIMEOUT_MS_DONE_%out_ok
+L_MPSC_RECV_TIMEOUT_MS_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    !__mpsc_recv_timeout_ns_%out_ok
+    !__mpsc_recv_timeout_mul_ok_%out_ok
+L_MPSC_RECV_TIMEOUT_MS_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_TRY_RECV_TIMEOUT_ERROR_MS %out_ok, %out_error, %out_value, %chan, %timeout_ms
+    EXPAND NUM_U64_CHECKED_MUL __mpsc_recv_error_timeout_mul_ok_%out_ok, __mpsc_recv_error_timeout_ns_%out_ok, %timeout_ms, 1000000
+    br __mpsc_recv_error_timeout_mul_ok_%out_ok -> L_MPSC_RECV_ERROR_TIMEOUT_MS_OK_%out_ok, L_MPSC_RECV_ERROR_TIMEOUT_MS_FAIL_%out_ok
+L_MPSC_RECV_ERROR_TIMEOUT_MS_OK_%out_ok:
+    EXPAND MPSC_TRY_RECV_TIMEOUT_ERROR %out_ok, %out_error, %out_value, %chan, __mpsc_recv_error_timeout_ns_%out_ok
+    !__mpsc_recv_error_timeout_ns_%out_ok
+    !__mpsc_recv_error_timeout_mul_ok_%out_ok
+    jmp L_MPSC_RECV_ERROR_TIMEOUT_MS_DONE_%out_ok
+L_MPSC_RECV_ERROR_TIMEOUT_MS_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    EXPAND MPSC_RECV_TIMEOUT_ERROR_NEW %out_error, RECV_TIMEOUT_ERROR_TIMEOUT
+    !__mpsc_recv_error_timeout_ns_%out_ok
+    !__mpsc_recv_error_timeout_mul_ok_%out_ok
+L_MPSC_RECV_ERROR_TIMEOUT_MS_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_RX_TRY_RECV_TIMEOUT_ERROR_MS %out_ok, %out_error, %out_value, %rx, %timeout_ms
+    __mpsc_rx_error_timeout_chan_%out_ok = load %rx+MpscReceiver_chan as ptr
+    EXPAND MPSC_TRY_RECV_TIMEOUT_ERROR_MS %out_ok, %out_error, %out_value, __mpsc_rx_error_timeout_chan_%out_ok, %timeout_ms
+    !__mpsc_rx_error_timeout_chan_%out_ok
+[END_MACRO]
+[MACRO] MPSC_RX_TRY_RECV_TIMEOUT_MS %out_ok, %out_value, %rx, %timeout_ms
+    EXPAND NUM_U64_CHECKED_MUL __mpsc_rx_timeout_mul_ok_%out_ok, __mpsc_rx_timeout_ns_%out_ok, %timeout_ms, 1000000
+    br __mpsc_rx_timeout_mul_ok_%out_ok -> L_MPSC_RX_TIMEOUT_MS_OK_%out_ok, L_MPSC_RX_TIMEOUT_MS_FAIL_%out_ok
+L_MPSC_RX_TIMEOUT_MS_OK_%out_ok:
+    EXPAND MPSC_RX_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, %rx, __mpsc_rx_timeout_ns_%out_ok
+    !__mpsc_rx_timeout_ns_%out_ok
+    !__mpsc_rx_timeout_mul_ok_%out_ok
+    jmp L_MPSC_RX_TIMEOUT_MS_DONE_%out_ok
+L_MPSC_RX_TIMEOUT_MS_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    !__mpsc_rx_timeout_ns_%out_ok
+    !__mpsc_rx_timeout_mul_ok_%out_ok
+L_MPSC_RX_TIMEOUT_MS_DONE_%out_ok:
+[END_MACRO]
+
+@__mpsc_try_send_timeout_ns(&chan: ptr, &value_slot: ptr, timeout_ns: u64) -> i32:
+L_ENTRY:
+    start = call @sa_time_instant_ns()
+    backoff_slot = stack_alloc 8
+    store backoff_slot+0, 1 as u64
+    jmp L_ST_TRY
+L_ST_TRY:
+    ok = call @__mpsc_try_send(&chan, &value_slot)
+    br ok -> L_ST_OK, L_ST_CHECK
+L_ST_OK:
+    !chan
+    !value_slot
+    !start
+    !timeout_ns
+    return 1
+L_ST_CHECK:
+    now = call @sa_time_instant_ns()
+    elapsed = sub now, start
+    timed_out = uge elapsed, timeout_ns
+    !now
+    !elapsed
+    br timed_out -> L_ST_TIMEOUT, L_ST_BACKOFF
+L_ST_BACKOFF:
+    backoff_ns = load backoff_slot+0 as u64
+    call @sa_time_sleep_ns(backoff_ns)
+    at_limit = uge backoff_ns, 1024
+    br at_limit -> L_ST_KEEP, L_ST_GROW
+L_ST_GROW:
+    next = shl backoff_ns, 1
+    store backoff_slot+0, next as u64
+    !next
+    !at_limit
+    !backoff_ns
+    !timed_out
+    !ok
+    jmp L_ST_TRY
+L_ST_KEEP:
+    !at_limit
+    !backoff_ns
+    !timed_out
+    !ok
+    jmp L_ST_TRY
+L_ST_TIMEOUT:
+    !chan
+    !value_slot
+    !timed_out
+    !ok
+    !start
+    !timeout_ns
+    return 0
+
+[MACRO] MPSC_TRY_SEND_TIMEOUT_NS %out_ok, %chan, %value, %timeout_ns
+    __mpsc_st_slot_%out_ok = stack_alloc 8
+    store __mpsc_st_slot_%out_ok+0, %value as u64
+    %out_ok = call @__mpsc_try_send_timeout_ns(&%chan, &__mpsc_st_slot_%out_ok, %timeout_ns)
+[END_MACRO]
+
+[MACRO] MPSC_TX_TRY_SEND_TIMEOUT_NS %out_ok, %tx, %value, %timeout_ns
+    __mpsc_tx_st_chan_%out_ok = load %tx+MpscSender_chan as ptr
+    __mpsc_tx_st_disconnected_%out_ok = eq __mpsc_tx_st_chan_%out_ok, 0
+    br __mpsc_tx_st_disconnected_%out_ok -> L_MPSC_TX_TIMEOUT_FAIL_%out_ok, L_MPSC_TX_TIMEOUT_CALL_%out_ok
+L_MPSC_TX_TIMEOUT_CALL_%out_ok:
+    EXPAND MPSC_TRY_SEND_TIMEOUT_NS %out_ok, __mpsc_tx_st_chan_%out_ok, %value, %timeout_ns
+    jmp L_MPSC_TX_TIMEOUT_DONE_%out_ok
+L_MPSC_TX_TIMEOUT_FAIL_%out_ok:
+    %out_ok = add 0, 0
+L_MPSC_TX_TIMEOUT_DONE_%out_ok:
+    !__mpsc_tx_st_disconnected_%out_ok
+    !__mpsc_tx_st_chan_%out_ok
+[END_MACRO]
+
+[MACRO] MPSC_TRY_SEND_TIMEOUT_MS %out_ok, %chan, %value, %timeout_ms
+    EXPAND NUM_U64_CHECKED_MUL __mpsc_send_timeout_mul_ok_%out_ok, __mpsc_send_timeout_ns_%out_ok, %timeout_ms, 1000000
+    br __mpsc_send_timeout_mul_ok_%out_ok -> L_MPSC_SEND_TIMEOUT_MS_OK_%out_ok, L_MPSC_SEND_TIMEOUT_MS_FAIL_%out_ok
+L_MPSC_SEND_TIMEOUT_MS_OK_%out_ok:
+    EXPAND MPSC_TRY_SEND_TIMEOUT_NS %out_ok, %chan, %value, __mpsc_send_timeout_ns_%out_ok
+    !__mpsc_send_timeout_ns_%out_ok
+    !__mpsc_send_timeout_mul_ok_%out_ok
+    jmp L_MPSC_SEND_TIMEOUT_MS_DONE_%out_ok
+L_MPSC_SEND_TIMEOUT_MS_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__mpsc_send_timeout_ns_%out_ok
+    !__mpsc_send_timeout_mul_ok_%out_ok
+L_MPSC_SEND_TIMEOUT_MS_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_TX_TRY_SEND_TIMEOUT_MS %out_ok, %tx, %value, %timeout_ms
+    EXPAND NUM_U64_CHECKED_MUL __mpsc_tx_timeout_mul_ok_%out_ok, __mpsc_tx_timeout_ns_%out_ok, %timeout_ms, 1000000
+    br __mpsc_tx_timeout_mul_ok_%out_ok -> L_MPSC_TX_TIMEOUT_MS_OK_%out_ok, L_MPSC_TX_TIMEOUT_MS_FAIL_%out_ok
+L_MPSC_TX_TIMEOUT_MS_OK_%out_ok:
+    EXPAND MPSC_TX_TRY_SEND_TIMEOUT_NS %out_ok, %tx, %value, __mpsc_tx_timeout_ns_%out_ok
+    !__mpsc_tx_timeout_ns_%out_ok
+    !__mpsc_tx_timeout_mul_ok_%out_ok
+    jmp L_MPSC_TX_TIMEOUT_MS_DONE_%out_ok
+L_MPSC_TX_TIMEOUT_MS_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__mpsc_tx_timeout_ns_%out_ok
+    !__mpsc_tx_timeout_mul_ok_%out_ok
+L_MPSC_TX_TIMEOUT_MS_DONE_%out_ok:
+[END_MACRO]