@salang/sa 0.1.2 → 0.1.4

package/sa_std/sync/mpsc.sal

@@ -0,0 +1,42 @@
+#def Mpsc_SIZE = 32
+#def Mpsc_cap = +0
+#def Mpsc_head = +8
+#def Mpsc_tail = +16
+#def Mpsc_data = +32
+
+#def Mpsc_SLOT_SIZE = 16
+#def Mpsc_SLOT_value = +0
+#def Mpsc_SLOT_ready = +8
+#def Mpsc_SLOT_EMPTY = 0
+#def Mpsc_SLOT_READY = 1
+
+#def SendErrorU64_SIZE = 8
+#def SendErrorU64_ALIGN = 8
+#def SendErrorU64_value = +0
+
+#def RecvError_SIZE = 0
+#def RecvError_ALIGN = 1
+
+#def TryRecvError_SIZE = 8
+#def TryRecvError_ALIGN = 8
+#def TryRecvError_kind = +0
+#def TRY_RECV_ERROR_EMPTY = 0
+#def TRY_RECV_ERROR_DISCONNECTED = 1
+
+#def RecvTimeoutError_SIZE = 8
+#def RecvTimeoutError_ALIGN = 8
+#def RecvTimeoutError_kind = +0
+#def RECV_TIMEOUT_ERROR_TIMEOUT = 0
+#def RECV_TIMEOUT_ERROR_DISCONNECTED = 1
+
+#def TrySendErrorU64_SIZE = 16
+#def TrySendErrorU64_ALIGN = 8
+#def TrySendErrorU64_kind = +0
+#def TrySendErrorU64_value = +8
+#def TRY_SEND_ERROR_FULL = 0
+#def TRY_SEND_ERROR_DISCONNECTED = 1
+
+#def MpscSender_SIZE = 8
+#def MpscSender_chan = +0
+#def MpscReceiver_SIZE = 8
+#def MpscReceiver_chan = +0

package/sa_std/sync/mpsc_list.sa

@@ -0,0 +1,255 @@
+// Unbounded channel backed by LinkedList + Mutex (single-producer multi not optimized).
+// Models supportable unbounded mpsc semantics without growable ring complexity.
+@import "mpsc_list.sal"
+@import "mutex.sa"
+@import "../collections/linked_list.sa"
+@import "mpsc.sal"
+@import "../time.sai"
+
+@sa_mpsc_list_new() -> ^ptr:
+L_ENTRY:
+    chan = alloc MpscList_SIZE
+    EXPAND MUTEX_NEW mtx
+    EXPAND LINKED_LIST_NEW list
+    store chan+MpscList_mutex, mtx as ptr
+    store chan+MpscList_list, list as ptr
+    return chan
+
+@sa_mpsc_list_send(&chan: ptr, value: u64) -> void:
+L_ENTRY:
+    mtx = load chan+MpscList_mutex as ptr
+    list = load chan+MpscList_list as ptr
+    null_ptr = 0 as ptr
+    disconnected = eq mtx, null_ptr
+    br disconnected -> L_SEND_DISCONNECTED, L_SEND_LOCK
+L_SEND_LOCK:
+    EXPAND MUTEX_LOCK mtx
+    EXPAND LINKED_LIST_PUSH_BACK list, value
+    EXPAND MUTEX_UNLOCK mtx
+    !disconnected
+    !null_ptr
+    !list
+    !mtx
+    !value
+    return
+L_SEND_DISCONNECTED:
+    !disconnected
+    !null_ptr
+    !list
+    !mtx
+    !value
+    return
+
+@sa_mpsc_list_try_recv(&chan: ptr, &out_value: ptr) -> i32:
+L_ENTRY:
+    mtx = load chan+MpscList_mutex as ptr
+    list = load chan+MpscList_list as ptr
+    null_ptr = 0 as ptr
+    disconnected = eq mtx, null_ptr
+    br disconnected -> L_RECV_DISCONNECTED, L_RECV_LOCK
+L_RECV_LOCK:
+    EXPAND MUTEX_LOCK mtx
+    ok = call @sa_linked_list_try_pop_front(&list, &out_value)
+    EXPAND MUTEX_UNLOCK mtx
+    !disconnected
+    !null_ptr
+    !list
+    !mtx
+    !chan
+    !out_value
+    return ok
+L_RECV_DISCONNECTED:
+    store out_value+0, 0 as u64
+    !disconnected
+    !null_ptr
+    !list
+    !mtx
+    !chan
+    !out_value
+    return 0
+
+@sa_mpsc_list_free(&chan: ptr) -> void:
+L_ENTRY:
+    list = load chan+MpscList_list as ptr
+    mtx = load chan+MpscList_mutex as ptr
+    null_ptr = 0 as ptr
+    closed = eq mtx, null_ptr
+    br closed -> L_FREE_ALREADY, L_FREE_CLOSE
+L_FREE_ALREADY:
+    !mtx
+    !closed
+    !null_ptr
+    jmp L_FREE_DONE
+L_FREE_CLOSE:
+    EXPAND LINKED_LIST_FREE list
+    EXPAND MUTEX_FREE mtx
+    store chan+MpscList_list, null_ptr as ptr
+    store chan+MpscList_mutex, null_ptr as ptr
+    !closed
+    !null_ptr
+    jmp L_FREE_DONE
+L_FREE_DONE:
+    !chan
+    return
+@sa_mpsc_list_try_recv_timeout(&chan: ptr, &out_value: 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
+L_TRY:
+    ok = call @sa_mpsc_list_try_recv(&chan, &out_value)
+    br ok -> L_OK, L_CHECK
+L_OK:
+    !ok
+    !start
+    !timeout_ns
+    !chan
+    !out_value
+    return 1
+L_CHECK:
+    now = call @sa_time_instant_ns()
+    elapsed = sub now, start
+    timed_out = uge elapsed, timeout_ns
+    br timed_out -> L_TIMEOUT, L_BACKOFF
+L_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_KEEP, L_GROW
+L_GROW:
+    next_backoff = shl backoff_ns, 1
+    store backoff_slot+0, next_backoff as u64
+    !next_backoff
+    !at_limit
+    !backoff_ns
+    !timed_out
+    !elapsed
+    !now
+    !ok
+    jmp L_TRY
+L_KEEP:
+    !at_limit
+    !backoff_ns
+    !timed_out
+    !elapsed
+    !now
+    !ok
+    jmp L_TRY
+L_TIMEOUT:
+    !timed_out
+    !elapsed
+    !now
+    !ok
+    !start
+    !timeout_ns
+    !chan
+    !out_value
+    return 0
+
+[MACRO] MPSC_LIST_NEW %out_chan
+    %out_chan = call @sa_mpsc_list_new()
+[END_MACRO]
+
+[MACRO] MPSC_LIST_SEND %chan, %value
+    call @sa_mpsc_list_send(&%chan, %value)
+[END_MACRO]
+
+[MACRO] MPSC_LIST_TRY_RECV %out_ok, %out_value, %chan
+    __mpl_slot_%out_ok = stack_alloc 8
+    store __mpl_slot_%out_ok+0, 0 as u64
+    %out_ok = call @sa_mpsc_list_try_recv(&%chan, &__mpl_slot_%out_ok)
+    %out_value = load __mpl_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] MPSC_LIST_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, %chan, %timeout_ns
+    __mpl_timeout_slot_%out_ok = stack_alloc 8
+    store __mpl_timeout_slot_%out_ok+0, 0 as u64
+    %out_ok = call @sa_mpsc_list_try_recv_timeout(&%chan, &__mpl_timeout_slot_%out_ok, %timeout_ns)
+    %out_value = load __mpl_timeout_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] MPSC_LIST_TRY_RECV_TIMEOUT_MS %out_ok, %out_value, %chan, %timeout_ms
+    EXPAND NUM_U64_CHECKED_MUL __mpl_timeout_mul_ok_%out_ok, __mpl_timeout_ns_%out_ok, %timeout_ms, 1000000
+    br __mpl_timeout_mul_ok_%out_ok -> L_MPSC_LIST_TIMEOUT_MS_OK_%out_ok, L_MPSC_LIST_TIMEOUT_MS_FAIL_%out_ok
+L_MPSC_LIST_TIMEOUT_MS_OK_%out_ok:
+    EXPAND MPSC_LIST_TRY_RECV_TIMEOUT_NS %out_ok, %out_value, %chan, __mpl_timeout_ns_%out_ok
+    !__mpl_timeout_ns_%out_ok
+    !__mpl_timeout_mul_ok_%out_ok
+    jmp L_MPSC_LIST_TIMEOUT_MS_DONE_%out_ok
+L_MPSC_LIST_TIMEOUT_MS_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    !__mpl_timeout_ns_%out_ok
+    !__mpl_timeout_mul_ok_%out_ok
+L_MPSC_LIST_TIMEOUT_MS_DONE_%out_ok:
+[END_MACRO]
+
+[MACRO] MPSC_LIST_FREE %chan
+    call @sa_mpsc_list_free(&%chan)
+[END_MACRO]
+
+[MACRO] MPSC_LIST_DROP %chan
+    EXPAND MPSC_LIST_FREE %chan
+[END_MACRO]
+
+[MACRO] MPSC_LIST_IS_DISCONNECTED %out_bool, %chan
+    __mpl_disc_mtx_%out_bool = load %chan+MpscList_mutex as ptr
+    __mpl_disc_list_%out_bool = load %chan+MpscList_list as ptr
+    __mpl_disc_null_%out_bool = 0 as ptr
+    __mpl_disc_mtx_zero_%out_bool = eq __mpl_disc_mtx_%out_bool, __mpl_disc_null_%out_bool
+    __mpl_disc_list_zero_%out_bool = eq __mpl_disc_list_%out_bool, __mpl_disc_null_%out_bool
+    %out_bool = and __mpl_disc_mtx_zero_%out_bool, __mpl_disc_list_zero_%out_bool
+    !__mpl_disc_list_zero_%out_bool
+    !__mpl_disc_mtx_zero_%out_bool
+    !__mpl_disc_null_%out_bool
+    !__mpl_disc_list_%out_bool
+    !__mpl_disc_mtx_%out_bool
+[END_MACRO]
+
+[MACRO] MPSC_LIST_LEN %out_len, %chan
+    __mpl_len_mtx_%out_len = load %chan+MpscList_mutex as ptr
+    __mpl_list_%out_len = load %chan+MpscList_list as ptr
+    __mpl_len_null_%out_len = 0 as ptr
+    __mpl_len_disconnected_%out_len = eq __mpl_len_mtx_%out_len, __mpl_len_null_%out_len
+    br __mpl_len_disconnected_%out_len -> L_MPSC_LIST_LEN_DISCONNECTED_%out_len, L_MPSC_LIST_LEN_LOCK_%out_len
+L_MPSC_LIST_LEN_LOCK_%out_len:
+    EXPAND MUTEX_LOCK __mpl_len_mtx_%out_len
+    EXPAND LINKED_LIST_LEN %out_len, __mpl_list_%out_len
+    EXPAND MUTEX_UNLOCK __mpl_len_mtx_%out_len
+    !__mpl_len_disconnected_%out_len
+    !__mpl_len_null_%out_len
+    !__mpl_list_%out_len
+    !__mpl_len_mtx_%out_len
+    jmp L_MPSC_LIST_LEN_DONE_%out_len
+L_MPSC_LIST_LEN_DISCONNECTED_%out_len:
+    %out_len = add 0, 0
+    !__mpl_len_disconnected_%out_len
+    !__mpl_len_null_%out_len
+    !__mpl_list_%out_len
+    !__mpl_len_mtx_%out_len
+L_MPSC_LIST_LEN_DONE_%out_len:
+[END_MACRO]
+
+[MACRO] MPSC_LIST_IS_EMPTY %out_bool, %chan
+    __mpl_empty_mtx_%out_bool = load %chan+MpscList_mutex as ptr
+    __mpl_list_e_%out_bool = load %chan+MpscList_list as ptr
+    __mpl_empty_null_%out_bool = 0 as ptr
+    __mpl_empty_disconnected_%out_bool = eq __mpl_empty_mtx_%out_bool, __mpl_empty_null_%out_bool
+    br __mpl_empty_disconnected_%out_bool -> L_MPSC_LIST_EMPTY_DISCONNECTED_%out_bool, L_MPSC_LIST_EMPTY_LOCK_%out_bool
+L_MPSC_LIST_EMPTY_LOCK_%out_bool:
+    EXPAND MUTEX_LOCK __mpl_empty_mtx_%out_bool
+    EXPAND LINKED_LIST_IS_EMPTY %out_bool, __mpl_list_e_%out_bool
+    EXPAND MUTEX_UNLOCK __mpl_empty_mtx_%out_bool
+    !__mpl_empty_disconnected_%out_bool
+    !__mpl_empty_null_%out_bool
+    !__mpl_list_e_%out_bool
+    !__mpl_empty_mtx_%out_bool
+    jmp L_MPSC_LIST_EMPTY_DONE_%out_bool
+L_MPSC_LIST_EMPTY_DISCONNECTED_%out_bool:
+    %out_bool = add 0, 1
+    !__mpl_empty_disconnected_%out_bool
+    !__mpl_empty_null_%out_bool
+    !__mpl_list_e_%out_bool
+    !__mpl_empty_mtx_%out_bool
+L_MPSC_LIST_EMPTY_DONE_%out_bool:
+[END_MACRO]

package/sa_std/sync/mpsc_list.sal

@@ -0,0 +1,3 @@
+#def MpscList_SIZE = 16
+#def MpscList_mutex = +0
+#def MpscList_list = +8

package/sa_std/sync/mutex.sa

@@ -0,0 +1,182 @@
+// Concrete mutex/spinlock macros built on atomic xchg and release unlock.
+@import "mutex.sal"
+@import "../time.sa"
+@import "../time.sai"
+
+@__mutex_lock_spin(lock: ptr) -> void:
+L_MUTEX_LOCK_INIT:
+    backoff_slot = stack_alloc 8
+    store backoff_slot+0, 1 as u64
+
+L_MUTEX_LOCK_TRY:
+    prev = atomic_rmw_xchg lock+Mutex_lock, 1 as u64 acq_rel
+    free = eq prev, 0
+    br free -> L_MUTEX_LOCK_DONE, L_MUTEX_LOCK_WAIT
+
+L_MUTEX_LOCK_WAIT:
+    backoff_ns = load backoff_slot+0 as u64
+    call @sa_time_sleep_ns(backoff_ns)
+    backoff_at_limit = uge backoff_ns, 1024
+    br backoff_at_limit -> L_MUTEX_LOCK_KEEP_BACKOFF, L_MUTEX_LOCK_GROW_BACKOFF
+
+L_MUTEX_LOCK_GROW_BACKOFF:
+    next_backoff = shl backoff_ns, 1
+    store backoff_slot+0, next_backoff as u64
+    !next_backoff
+    !backoff_at_limit
+    !backoff_ns
+    !free
+    !prev
+    jmp L_MUTEX_LOCK_TRY
+
+L_MUTEX_LOCK_KEEP_BACKOFF:
+    !backoff_at_limit
+    !backoff_ns
+    !free
+    !prev
+    jmp L_MUTEX_LOCK_TRY
+
+L_MUTEX_LOCK_DONE:
+    !free
+    !prev
+    return
+
+[MACRO] MUTEX_NEW %out_mutex
+    %out_mutex = alloc Mutex_SIZE
+    store %out_mutex+Mutex_lock, 0 as u64
+[END_MACRO]
+
+[MACRO] MUTEX_NEW_I32 %out_mutex, %value
+    %out_mutex = alloc 16
+    store %out_mutex+Mutex_lock, 0 as u64
+    store %out_mutex+Mutex_data, %value as i32
+[END_MACRO]
+
+[MACRO] MUTEX_LOCK %lock_ptr
+    call @__mutex_lock_spin(%lock_ptr)
+[END_MACRO]
+
+[MACRO] MUTEX_TRY_LOCK %out_ok, %lock_ptr
+    __mutex_try_prev_%out_ok = atomic_rmw_xchg %lock_ptr+Mutex_lock, 1 as u64 acq_rel
+    %out_ok = eq __mutex_try_prev_%out_ok, 0
+    !__mutex_try_prev_%out_ok
+[END_MACRO]
+
+[MACRO] MUTEX_IS_LOCKED %out_bool, %lock_ptr
+    __mutex_state_%out_bool = atomic_load %lock_ptr+Mutex_lock as u64 acquire
+    %out_bool = ne __mutex_state_%out_bool, 0
+    !__mutex_state_%out_bool
+[END_MACRO]
+
+[MACRO] MUTEX_UNLOCK %lock_ptr
+    atomic_store %lock_ptr+Mutex_lock, 0 as u64 release
+[END_MACRO]
+
+[MACRO] MUTEX_TRY_UNLOCK %out_ok, %lock_ptr
+    __mutex_unlock_state_%out_ok, %out_ok = cmpxchg %lock_ptr+Mutex_lock, 1, 0 as u64 acq_rel acquire
+    !__mutex_unlock_state_%out_ok
+[END_MACRO]
+
+[MACRO] MUTEX_FORCE_UNLOCKED %lock_ptr
+    atomic_store %lock_ptr+Mutex_lock, 0 as u64 release
+[END_MACRO]
+
+[MACRO] MUTEX_FREE %lock_ptr
+    !%lock_ptr
+[END_MACRO]
+
+[MACRO] MUTEX_DEFAULT %out_mutex
+    EXPAND MUTEX_NEW %out_mutex
+[END_MACRO]
+
+// Rust-style into_inner for MUTEX_NEW_I32 layout: returns stored i32 and releases lock word.
+[MACRO] MUTEX_INTO_INNER_I32 %out_value, %mutex_reg
+    %out_value = load %mutex_reg+Mutex_data as i32
+    atomic_store %mutex_reg+Mutex_lock, 0 as u64 release
+[END_MACRO]
+
+// Guard layout helper: store mutex ptr in guard for unlock symmetry.
+[MACRO] MUTEX_GUARD_NEW %out_guard, %mutex_reg
+    %out_guard = alloc MutexGuard_SIZE
+    store %out_guard+MutexGuard_mutex, %mutex_reg as ptr
+[END_MACRO]
+
+[MACRO] MUTEX_GUARD_UNLOCK %guard_reg
+    __mutex_guard_ptr_%guard_reg = load %guard_reg+MutexGuard_mutex as ptr
+    EXPAND MUTEX_UNLOCK __mutex_guard_ptr_%guard_reg
+    !__mutex_guard_ptr_%guard_reg
+[END_MACRO]
+
+
+[MACRO] MUTEX_GET_MUT_I32 %out_ptr, %mutex_reg
+    %out_ptr = ptr_add %mutex_reg, Mutex_data
+[END_MACRO]
+
+@__mutex_try_lock_timeout_ns(lock: 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_MT_TRY
+L_MT_TRY:
+    prev = atomic_rmw_xchg lock+Mutex_lock, 1 as u64 acq_rel
+    free = eq prev, 0
+    !prev
+    br free -> L_MT_OK, L_MT_CHECK
+L_MT_OK:
+    !lock
+    !free
+    !start
+    !timeout_ns
+    return 1
+L_MT_CHECK:
+    !free
+    now = call @sa_time_instant_ns()
+    elapsed = sub now, start
+    timed_out = uge elapsed, timeout_ns
+    !now
+    !elapsed
+    br timed_out -> L_MT_TIMEOUT, L_MT_BACKOFF
+L_MT_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_MT_KEEP, L_MT_GROW
+L_MT_GROW:
+    next = shl backoff_ns, 1
+    store backoff_slot+0, next as u64
+    !next
+    !at_limit
+    !backoff_ns
+    !timed_out
+    jmp L_MT_TRY
+L_MT_KEEP:
+    !at_limit
+    !backoff_ns
+    !timed_out
+    jmp L_MT_TRY
+L_MT_TIMEOUT:
+    !lock
+    !timed_out
+    !start
+    !timeout_ns
+    return 0
+
+[MACRO] MUTEX_TRY_LOCK_TIMEOUT_NS %out_ok, %lock_ptr, %timeout_ns
+    %out_ok = call @__mutex_try_lock_timeout_ns(%lock_ptr, %timeout_ns)
+[END_MACRO]
+
+[MACRO] MUTEX_TRY_LOCK_TIMEOUT_MS %out_ok, %lock_ptr, %timeout_ms
+    EXPAND TIME_CHECKED_MUL_NS __mutex_timeout_ms_ok_%out_ok, __mutex_timeout_ns_%out_ok, %timeout_ms, Time_NS_PER_MS
+    br __mutex_timeout_ms_ok_%out_ok -> L_MUTEX_TIMEOUT_MS_OK_%out_ok, L_MUTEX_TIMEOUT_MS_FAIL_%out_ok
+L_MUTEX_TIMEOUT_MS_OK_%out_ok:
+    EXPAND MUTEX_TRY_LOCK_TIMEOUT_NS %out_ok, %lock_ptr, __mutex_timeout_ns_%out_ok
+    !__mutex_timeout_ms_ok_%out_ok
+    !__mutex_timeout_ns_%out_ok
+    jmp L_MUTEX_TIMEOUT_MS_DONE_%out_ok
+L_MUTEX_TIMEOUT_MS_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__mutex_timeout_ms_ok_%out_ok
+    !__mutex_timeout_ns_%out_ok
+L_MUTEX_TIMEOUT_MS_DONE_%out_ok:
+[END_MACRO]

package/sa_std/sync/mutex.sal

@@ -0,0 +1,7 @@
+#def Mutex_SIZE = 8
+#def Mutex_lock = +0
+#def Mutex_data = +8
+
+#def MutexGuard_SIZE = 8
+#def MutexGuard_mutex = +0
+#def MutexGuard_data = +8