@salang/sa 0.1.2 → 0.1.4

package/sa_std/sync/once.sa

@@ -0,0 +1,371 @@
+// Concrete OnceCell helpers built on an explicit three-state machine.
+// The payload is stored as raw u64 bits so callers can round-trip ptr or
+// integer values without hidden type magic.
+@import "once.sal"
+@import "../time.sai"
+
+@__once_wait_ready(&once: ptr) -> void:
+L_ENTRY:
+    state = atomic_load once+Once_state as u32 acquire
+    ready = eq state, Once_STATE_READY
+    br ready -> L_ONCE_WAIT_READY_DONE, L_ONCE_WAIT_READY_SPIN
+
+L_ONCE_WAIT_READY_SPIN:
+    !ready
+    !state
+    call @sa_time_sleep_ns(1)
+    jmp L_ENTRY
+
+L_ONCE_WAIT_READY_DONE:
+    !ready
+    !state
+    !once
+    return
+
+@__once_try_claim(&once: ptr) -> i32:
+L_ENTRY:
+    state = atomic_load once+Once_state as u32 acquire
+    ready = eq state, Once_STATE_READY
+    br ready -> L_ONCE_TRY_READY, L_ONCE_TRY_CHECK
+
+L_ONCE_TRY_CHECK:
+    is_uninit = eq state, Once_STATE_UNINIT
+    br is_uninit -> L_ONCE_TRY_CLAIM, L_ONCE_TRY_WAIT
+
+L_ONCE_TRY_CLAIM:
+    old, ok = cmpxchg once+Once_state, Once_STATE_UNINIT, Once_STATE_RUNNING as u32 acq_rel acquire
+    br ok -> L_ONCE_TRY_OWNER, L_ONCE_TRY_RETRY
+
+L_ONCE_TRY_RETRY:
+    !old
+    !ok
+    !is_uninit
+    !ready
+    !state
+    call @sa_time_sleep_ns(1)
+    jmp L_ENTRY
+
+L_ONCE_TRY_WAIT:
+    !is_uninit
+    !ready
+    !state
+    call @sa_time_sleep_ns(1)
+    jmp L_ENTRY
+
+L_ONCE_TRY_OWNER:
+    !old
+    !ok
+    !is_uninit
+    !ready
+    !state
+    !once
+    return 1
+
+L_ONCE_TRY_READY:
+    !ready
+    !state
+    !once
+    return 0
+
+[MACRO] ONCE_NEW %out_once
+    %out_once = alloc Once_SIZE
+    store %out_once+Once_state, Once_STATE_UNINIT as u32
+    store %out_once+Once_value, 0 as u64
+[END_MACRO]
+
+[MACRO] ONCE_IS_READY %out_ready, %once_reg
+    __once_state = atomic_load %once_reg+Once_state as u32 acquire
+    %out_ready = eq __once_state, Once_STATE_READY
+    !__once_state
+[END_MACRO]
+
+[MACRO] ONCE_STATE %out_state, %once_reg
+    %out_state = atomic_load %once_reg+Once_state as u32 acquire
+[END_MACRO]
+
+[MACRO] ONCE_STATE_NEW %state_ptr, %poisoned
+    store %state_ptr+OnceState_poisoned, %poisoned as u8
+    store %state_ptr+OnceState_set_state_to, OnceState_STATE_COMPLETE as u32
+[END_MACRO]
+
+[MACRO] ONCE_STATE_IS_POISONED %out_bool, %state_ptr
+    __once_state_poisoned_%out_bool = load %state_ptr+OnceState_poisoned as u8
+    %out_bool = ne __once_state_poisoned_%out_bool, 0
+    !__once_state_poisoned_%out_bool
+[END_MACRO]
+
+[MACRO] ONCE_STATE_POISON %state_ptr
+    store %state_ptr+OnceState_set_state_to, OnceState_STATE_POISONED as u32
+[END_MACRO]
+
+[MACRO] ONCE_STATE_SET_STATE_TO %out_state, %state_ptr
+    %out_state = load %state_ptr+OnceState_set_state_to as u32
+[END_MACRO]
+
+[MACRO] ONCE_IS_UNINIT %out_bool, %once_reg
+    __once_uninit_state_%out_bool = atomic_load %once_reg+Once_state as u32 acquire
+    %out_bool = eq __once_uninit_state_%out_bool, Once_STATE_UNINIT
+    !__once_uninit_state_%out_bool
+[END_MACRO]
+
+[MACRO] ONCE_IS_RUNNING %out_bool, %once_reg
+    __once_running_state_%out_bool = atomic_load %once_reg+Once_state as u32 acquire
+    %out_bool = eq __once_running_state_%out_bool, Once_STATE_RUNNING
+    !__once_running_state_%out_bool
+[END_MACRO]
+
+[MACRO] ONCE_TRY_CLAIM %out_owned, %once_reg
+    __once_owned = call @__once_try_claim(&%once_reg)
+    %out_owned = __once_owned
+[END_MACRO]
+
+[MACRO] ONCE_WAIT_READY %once_reg
+    call @__once_wait_ready(&%once_reg)
+[END_MACRO]
+
+[MACRO] ONCE_PUBLISH %once_reg, %value
+    store %once_reg+Once_value, %value as u64
+    atomic_store %once_reg+Once_state, Once_STATE_READY as u32 release
+[END_MACRO]
+
+[MACRO] ONCE_SET %out_ok, %once_reg, %value
+    __once_set_ok_slot_%out_ok = stack_alloc 8
+    __once_set_owner_%out_ok = call @__once_try_claim(&%once_reg)
+    br __once_set_owner_%out_ok -> L_ONCE_SET_STORE_%out_ok, L_ONCE_SET_READY_%out_ok
+L_ONCE_SET_STORE_%out_ok:
+    EXPAND ONCE_PUBLISH %once_reg, %value
+    store __once_set_ok_slot_%out_ok+0, 1 as u64
+    !__once_set_owner_%out_ok
+    jmp L_ONCE_SET_DONE_%out_ok
+L_ONCE_SET_READY_%out_ok:
+    store __once_set_ok_slot_%out_ok+0, 0 as u64
+    !__once_set_owner_%out_ok
+    jmp L_ONCE_SET_DONE_%out_ok
+L_ONCE_SET_DONE_%out_ok:
+    %out_ok = load __once_set_ok_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] ONCE_TRY_GET %out_ok, %out_value, %once_reg
+    __once_try_get_ok_slot_%out_ok = stack_alloc 8
+    __once_try_get_value_slot_%out_ok = stack_alloc 8
+    __once_try_get_state_%out_ok = atomic_load %once_reg+Once_state as u32 acquire
+    __once_try_get_ready_%out_ok = eq __once_try_get_state_%out_ok, Once_STATE_READY
+    br __once_try_get_ready_%out_ok -> L_ONCE_TRY_GET_READY_%out_ok, L_ONCE_TRY_GET_EMPTY_%out_ok
+L_ONCE_TRY_GET_READY_%out_ok:
+    __once_try_get_value_%out_ok = load %once_reg+Once_value as u64
+    store __once_try_get_value_slot_%out_ok+0, __once_try_get_value_%out_ok as u64
+    store __once_try_get_ok_slot_%out_ok+0, 1 as u64
+    !__once_try_get_value_%out_ok
+    jmp L_ONCE_TRY_GET_DONE_%out_ok
+L_ONCE_TRY_GET_EMPTY_%out_ok:
+    store __once_try_get_value_slot_%out_ok+0, 0 as u64
+    store __once_try_get_ok_slot_%out_ok+0, 0 as u64
+    jmp L_ONCE_TRY_GET_DONE_%out_ok
+L_ONCE_TRY_GET_DONE_%out_ok:
+    %out_value = load __once_try_get_value_slot_%out_ok+0 as u64
+    %out_ok = load __once_try_get_ok_slot_%out_ok+0 as u64
+    !__once_try_get_ready_%out_ok
+    !__once_try_get_state_%out_ok
+[END_MACRO]
+
+[MACRO] ONCE_GET_UNCHECKED %out_value, %once_reg
+    %out_value = load %once_reg+Once_value as u64
+[END_MACRO]
+
+[MACRO] ONCE_GET_MUT %out_ok, %out_ptr, %once_reg
+    __once_get_mut_ok_slot_%out_ok = stack_alloc 8
+    __once_get_mut_ptr_slot_%out_ok = stack_alloc 8
+    __once_get_mut_state_%out_ok = atomic_load %once_reg+Once_state as u32 acquire
+    __once_get_mut_ready_%out_ok = eq __once_get_mut_state_%out_ok, Once_STATE_READY
+    br __once_get_mut_ready_%out_ok -> L_ONCE_GET_MUT_READY_%out_ok, L_ONCE_GET_MUT_EMPTY_%out_ok
+L_ONCE_GET_MUT_READY_%out_ok:
+    __once_get_mut_ptr_%out_ok = ptr_add %once_reg, Once_value
+    store __once_get_mut_ptr_slot_%out_ok+0, __once_get_mut_ptr_%out_ok as ptr
+    store __once_get_mut_ok_slot_%out_ok+0, 1 as u64
+    !__once_get_mut_ptr_%out_ok
+    jmp L_ONCE_GET_MUT_DONE_%out_ok
+L_ONCE_GET_MUT_EMPTY_%out_ok:
+    store __once_get_mut_ptr_slot_%out_ok+0, 0 as ptr
+    store __once_get_mut_ok_slot_%out_ok+0, 0 as u64
+    jmp L_ONCE_GET_MUT_DONE_%out_ok
+L_ONCE_GET_MUT_DONE_%out_ok:
+    %out_ptr = load __once_get_mut_ptr_slot_%out_ok+0 as ptr
+    %out_ok = load __once_get_mut_ok_slot_%out_ok+0 as u64
+    !__once_get_mut_ready_%out_ok
+    !__once_get_mut_state_%out_ok
+[END_MACRO]
+
+[MACRO] ONCE_GET %out_value, %once_reg
+    EXPAND ONCE_WAIT_READY %once_reg
+    %out_value = load %once_reg+Once_value as u64
+[END_MACRO]
+
+[MACRO] ONCE_TAKE %out_ok, %out_value, %once_reg
+    __once_take_ok_slot_%out_ok = stack_alloc 8
+    __once_take_value_slot_%out_ok = stack_alloc 8
+    store __once_take_ok_slot_%out_ok+0, 0 as u64
+    store __once_take_value_slot_%out_ok+0, 0 as u64
+    __once_take_state_%out_ok = atomic_load %once_reg+Once_state as u32 acquire
+    __once_take_ready_%out_ok = eq __once_take_state_%out_ok, Once_STATE_READY
+    br __once_take_ready_%out_ok -> L_ONCE_TAKE_CLAIM_%out_ok, L_ONCE_TAKE_EMPTY_%out_ok
+L_ONCE_TAKE_CLAIM_%out_ok:
+    __once_take_claimed_state_%out_ok, __once_take_claimed_%out_ok = cmpxchg %once_reg+Once_state, Once_STATE_READY, Once_STATE_RUNNING as u32 acq_rel acquire
+    br __once_take_claimed_%out_ok -> L_ONCE_TAKE_READY_%out_ok, L_ONCE_TAKE_CLAIM_FAILED_%out_ok
+L_ONCE_TAKE_READY_%out_ok:
+    __once_take_value_%out_ok = load %once_reg+Once_value as u64
+    store __once_take_value_slot_%out_ok+0, __once_take_value_%out_ok as u64
+    store %once_reg+Once_value, 0 as u64
+    atomic_store %once_reg+Once_state, Once_STATE_UNINIT as u32 release
+    store __once_take_ok_slot_%out_ok+0, 1 as u64
+    !__once_take_value_%out_ok
+    !__once_take_claimed_state_%out_ok
+    !__once_take_claimed_%out_ok
+    jmp L_ONCE_TAKE_DONE_%out_ok
+L_ONCE_TAKE_CLAIM_FAILED_%out_ok:
+    !__once_take_claimed_state_%out_ok
+    !__once_take_claimed_%out_ok
+    jmp L_ONCE_TAKE_EMPTY_%out_ok
+L_ONCE_TAKE_EMPTY_%out_ok:
+    jmp L_ONCE_TAKE_DONE_%out_ok
+L_ONCE_TAKE_DONE_%out_ok:
+    %out_value = load __once_take_value_slot_%out_ok+0 as u64
+    %out_ok = load __once_take_ok_slot_%out_ok+0 as u64
+    !__once_take_ready_%out_ok
+    !__once_take_state_%out_ok
+[END_MACRO]
+
+[MACRO] ONCE_INTO_INNER %out_ok, %out_value, %once_reg
+    __once_inner_ok_slot_%out_ok = stack_alloc 8
+    __once_inner_value_slot_%out_ok = stack_alloc 8
+    __once_inner_state_%out_ok = atomic_load %once_reg+Once_state as u32 acquire
+    __once_inner_ready_%out_ok = eq __once_inner_state_%out_ok, Once_STATE_READY
+    br __once_inner_ready_%out_ok -> L_ONCE_INNER_READY_%out_ok, L_ONCE_INNER_EMPTY_%out_ok
+L_ONCE_INNER_READY_%out_ok:
+    __once_inner_value_%out_ok = load %once_reg+Once_value as u64
+    store __once_inner_value_slot_%out_ok+0, __once_inner_value_%out_ok as u64
+    store __once_inner_ok_slot_%out_ok+0, 1 as u64
+    !__once_inner_value_%out_ok
+    jmp L_ONCE_INNER_DONE_%out_ok
+L_ONCE_INNER_EMPTY_%out_ok:
+    store __once_inner_value_slot_%out_ok+0, 0 as u64
+    store __once_inner_ok_slot_%out_ok+0, 0 as u64
+    jmp L_ONCE_INNER_DONE_%out_ok
+L_ONCE_INNER_DONE_%out_ok:
+    %out_value = load __once_inner_value_slot_%out_ok+0 as u64
+    %out_ok = load __once_inner_ok_slot_%out_ok+0 as u64
+    !__once_inner_ready_%out_ok
+    !__once_inner_state_%out_ok
+    !%once_reg
+[END_MACRO]
+
+[MACRO] ONCE_GET_OR_INIT %out_value, %once_reg, %init_fn
+    __once_owner = call @__once_try_claim(&%once_reg)
+    br __once_owner -> L_ONCE_GET_OR_INIT_INIT_%out_value, L_ONCE_GET_OR_INIT_READY_%out_value
+L_ONCE_GET_OR_INIT_INIT_%out_value:
+    __once_init_value = call %init_fn()
+    EXPAND ONCE_PUBLISH %once_reg, __once_init_value
+    %out_value = __once_init_value
+    !__once_owner
+    jmp L_ONCE_GET_OR_INIT_DONE_%out_value
+L_ONCE_GET_OR_INIT_READY_%out_value:
+    %out_value = load %once_reg+Once_value as u64
+    !__once_owner
+    jmp L_ONCE_GET_OR_INIT_DONE_%out_value
+L_ONCE_GET_OR_INIT_DONE_%out_value:
+[END_MACRO]
+
+// Concrete LazyLock-style aliases over the existing Once/OnceLock u64 cell.
+// Callers still provide an explicit init function register; this is not a
+// generic type holding a function pointer object.
+
+[MACRO] LAZY_LOCK_NEW %out_lazy
+    EXPAND ONCE_NEW %out_lazy
+[END_MACRO]
+
+[MACRO] LAZY_LOCK_FORCE %out_value, %lazy_reg, %init_fn
+    EXPAND ONCE_GET_OR_INIT %out_value, %lazy_reg, %init_fn
+[END_MACRO]
+
+[MACRO] LAZY_LOCK_GET %out_ok, %out_value, %lazy_reg
+    EXPAND ONCE_TRY_GET %out_ok, %out_value, %lazy_reg
+[END_MACRO]
+
+[MACRO] LAZY_LOCK_IS_READY %out_ready, %lazy_reg
+    EXPAND ONCE_IS_READY %out_ready, %lazy_reg
+[END_MACRO]
+
+[MACRO] LAZY_LOCK_INTO_INNER %out_ok, %out_value, %lazy_reg
+    EXPAND ONCE_INTO_INNER %out_ok, %out_value, %lazy_reg
+[END_MACRO]
+
+// OnceLock-named aliases over the concrete ONCE_* u64 cell facade.
+
+[MACRO] ONCE_LOCK_NEW %out_once
+    EXPAND ONCE_NEW %out_once
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_IS_READY %out_ready, %once_reg
+    EXPAND ONCE_IS_READY %out_ready, %once_reg
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_SET %out_ok, %once_reg, %value
+    EXPAND ONCE_SET %out_ok, %once_reg, %value
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_TRY_GET %out_ok, %out_value, %once_reg
+    EXPAND ONCE_TRY_GET %out_ok, %out_value, %once_reg
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_GET %out_value, %once_reg
+    EXPAND ONCE_GET %out_value, %once_reg
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_GET_OR_INIT %out_value, %once_reg, %init_fn
+    EXPAND ONCE_GET_OR_INIT %out_value, %once_reg, %init_fn
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_TAKE %out_ok, %out_value, %once_reg
+    EXPAND ONCE_TAKE %out_ok, %out_value, %once_reg
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_INTO_INNER %out_ok, %out_value, %once_reg
+    EXPAND ONCE_INTO_INNER %out_ok, %out_value, %once_reg
+[END_MACRO]
+
+[MACRO] ONCE_DEFAULT %out_once
+    EXPAND ONCE_NEW %out_once
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_DEFAULT %out_once
+    EXPAND ONCE_LOCK_NEW %out_once
+[END_MACRO]
+
+[MACRO] LAZY_LOCK_DEFAULT %out_once
+    EXPAND LAZY_LOCK_NEW %out_once
+[END_MACRO]
+
+// Rust-style call_once / call_once_force name aliases over get_or_init / publish paths.
+[MACRO] ONCE_CALL_ONCE %out_value, %once_reg, %init_fn
+    EXPAND ONCE_GET_OR_INIT %out_value, %once_reg, %init_fn
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_CALL_ONCE %out_value, %once_reg, %init_fn
+    EXPAND ONCE_LOCK_GET_OR_INIT %out_value, %once_reg, %init_fn
+[END_MACRO]
+
+// Force-style: always invoke init when not ready; same as get_or_init for concrete cell.
+[MACRO] ONCE_CALL_ONCE_FORCE %out_value, %once_reg, %init_fn
+    EXPAND ONCE_GET_OR_INIT %out_value, %once_reg, %init_fn
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_WAIT %out_value, %once_reg
+    EXPAND ONCE_LOCK_GET %out_value, %once_reg
+[END_MACRO]
+
+[MACRO] ONCE_IS_COMPLETED %out_ready, %once_reg
+    EXPAND ONCE_IS_READY %out_ready, %once_reg
+[END_MACRO]
+
+[MACRO] ONCE_LOCK_IS_COMPLETED %out_ready, %once_reg
+    EXPAND ONCE_LOCK_IS_READY %out_ready, %once_reg
+[END_MACRO]

package/sa_std/sync/once.sal

@@ -0,0 +1,31 @@
+#def Once_SIZE = 16
+#def Once_state = +0
+#def Once_value = +8
+#def Once_STATE_UNINIT = 0
+#def Once_STATE_RUNNING = 1
+#def Once_STATE_READY = 2
+
+#def OnceState_SIZE = 8
+#def OnceState_ALIGN = 4
+#def OnceState_poisoned = +0
+#def OnceState_set_state_to = +4
+#def OnceState_STATE_COMPLETE = 0
+#def OnceState_STATE_RUNNING = 1
+#def OnceState_STATE_POISONED = 2
+#def OnceState_STATE_INCOMPLETE = 3
+#def OnceState_STATE_QUEUED = 4
+#def OnceState_STATE_MASK = 3
+
+#def OnceLock_SIZE = 16
+#def OnceLock_state = +0
+#def OnceLock_value = +8
+#def ONCE_LOCK_STATE_UNINIT = Once_STATE_UNINIT
+#def ONCE_LOCK_STATE_RUNNING = Once_STATE_RUNNING
+#def ONCE_LOCK_STATE_READY = Once_STATE_READY
+
+#def LazyLock_SIZE = 16
+#def LazyLock_state = +0
+#def LazyLock_value = +8
+#def LAZY_LOCK_STATE_UNINIT = Once_STATE_UNINIT
+#def LAZY_LOCK_STATE_RUNNING = Once_STATE_RUNNING
+#def LAZY_LOCK_STATE_READY = Once_STATE_READY

package/sa_std/sync/poison.sa

@@ -0,0 +1,36 @@
+@import "poison.sal"
+
+[MACRO] POISON_ERROR_NEW %out_error, %data
+    %out_error = alloc PoisonErrorU64_SIZE
+    store %out_error+PoisonErrorU64_data, %data as u64
+[END_MACRO]
+
+[MACRO] POISON_ERROR_DATA %out_data, %error_reg
+    %out_data = load %error_reg+PoisonErrorU64_data as u64
+[END_MACRO]
+
+[MACRO] TRY_LOCK_ERROR_NEW %out_error, %kind, %data
+    %out_error = alloc TryLockErrorU64_SIZE
+    store %out_error+TryLockErrorU64_kind, %kind as u64
+    store %out_error+TryLockErrorU64_data, %data as u64
+[END_MACRO]
+
+[MACRO] TRY_LOCK_ERROR_KIND %out_kind, %error_reg
+    %out_kind = load %error_reg+TryLockErrorU64_kind as u64
+[END_MACRO]
+
+[MACRO] TRY_LOCK_ERROR_DATA %out_data, %error_reg
+    %out_data = load %error_reg+TryLockErrorU64_data as u64
+[END_MACRO]
+
+[MACRO] TRY_LOCK_ERROR_IS_POISONED %out_bool, %error_reg
+    __try_lock_error_kind_%out_bool = load %error_reg+TryLockErrorU64_kind as u64
+    %out_bool = eq __try_lock_error_kind_%out_bool, TRY_LOCK_ERROR_POISONED
+    !__try_lock_error_kind_%out_bool
+[END_MACRO]
+
+[MACRO] TRY_LOCK_ERROR_IS_WOULD_BLOCK %out_bool, %error_reg
+    __try_lock_error_kind_block_%out_bool = load %error_reg+TryLockErrorU64_kind as u64
+    %out_bool = eq __try_lock_error_kind_block_%out_bool, TRY_LOCK_ERROR_WOULD_BLOCK
+    !__try_lock_error_kind_block_%out_bool
+[END_MACRO]

package/sa_std/sync/poison.sal

@@ -0,0 +1,11 @@
+#def PoisonErrorU64_SIZE = 8
+#def PoisonErrorU64_ALIGN = 8
+#def PoisonErrorU64_data = +0
+
+#def TryLockErrorU64_SIZE = 16
+#def TryLockErrorU64_ALIGN = 8
+#def TryLockErrorU64_kind = +0
+#def TryLockErrorU64_data = +8
+#def TryLockErrorU64_poison = +8
+#def TRY_LOCK_ERROR_POISONED = 0
+#def TRY_LOCK_ERROR_WOULD_BLOCK = 1

package/sa_std/sync/prelude.sa

@@ -0,0 +1,8 @@
+@import "atomic.sa"
+@import "barrier.sa"
+@import "condvar.sa"
+@import "mpsc.sa"
+@import "mutex.sa"
+@import "once.sa"
+@import "poison.sa"
+@import "rwlock.sa"

package/sa_std/sync/prelude.sal

@@ -0,0 +1,7 @@
+@import "atomic.sal"
+@import "barrier.sal"
+@import "condvar.sal"
+@import "mpsc.sal"
+@import "mutex.sal"
+@import "once.sal"
+@import "rwlock.sal"