package core:sync
Source

⌘K
Ctrl+K
or
/

    Index

    Variables (0)

    This section is empty.

    Procedures (104)

    Types

    Atomic_Cond ¶
    Source

    Atomic_Cond :: struct {
	state: Futex,
}
     

    Atomic_Cond implements a condition variable, a rendezvous point for threads waiting for signalling the occurence of an event

    An Atomic_Cond must not be copied after first use

    Related Procedures With Parameters

    Atomic_Memory_Order ¶
    Source

    Atomic_Memory_Order :: .Atomic_Memory_Order
     

    Atomic_Memory_Order :: enum {

    Relaxed = 0, // Unordered
Consume = 1, // Monotonic
Acquire = 2,
Release = 3,
Acq_Rel = 4,
Seq_Cst = 5,

    }

    Atomic_Mutex ¶
    Source

    Atomic_Mutex :: struct {
	state: Atomic_Mutex_State,
}
     

    An Atomic_Mutex is a mutual exclusion lock The zero value for a Atomic_Mutex is an unlocked mutex

    An Atomic_Mutex must not be copied after first use

    Related Procedures With Parameters

    Atomic_Mutex_State ¶
    Source

    Atomic_Mutex_State :: enum Futex {
	Unlocked = 0, 
	Locked   = 1, 
	Waiting  = 2, 
}

    Atomic_RW_Mutex ¶
    Source

    Atomic_RW_Mutex :: struct {
	state: Atomic_RW_Mutex_State,
	mutex: Atomic_Mutex,
	sema:  Atomic_Sema,
}
     

    An Atomic_RW_Mutex is a reader/writer mutual exclusion lock The lock can be held by any arbitrary number of readers or a single writer The zero value for an Atomic_RW_Mutex is an unlocked mutex

    An Atomic_RW_Mutex must not be copied after first use

    Related Procedures With Parameters

    Atomic_RW_Mutex_State ¶
    Source

    Atomic_RW_Mutex_State :: distinct uint
    Related Constants

    Atomic_Recursive_Mutex ¶
    Source

    Atomic_Recursive_Mutex :: struct {
	owner:     int,
	recursion: int,
	mutex:     Mutex,
}
     

    An Atomic_Recursive_Mutex is a recursive mutual exclusion lock The zero value for a Recursive_Mutex is an unlocked mutex

    An Atomic_Recursive_Mutex must not be copied after first use

    Related Procedures With Parameters

    Atomic_Sema ¶
    Source

    Atomic_Sema :: struct {
	count: Futex,
}
     

    When waited upon, blocks until the internal count is greater than zero, then subtracts one. Posting to the semaphore increases the count by one, or the provided amount.

    An Atomic_Sema must not be copied after first use

    Related Procedures With Parameters

    Auto_Reset_Event ¶
    Source

    Auto_Reset_Event :: struct {
	// status ==  0: Event is reset and no threads are waiting
	// status ==  1: Event is signaled
	// status == -N: Event is reset and N threads are waiting
	status: i32,
	sema:   Sema,
}
    Related Procedures With Parameters

    Barrier ¶
    Source

    Barrier :: struct {
	mutex:         Mutex,
	cond:          Cond,
	index:         int,
	generation_id: int,
	thread_count:  int,
}
     

    A barrier enabling multiple threads to synchronize the beginning of some computation

    Example: 
    package example

import "core:fmt"
import "core:sync"
import "core:thread"

barrier := &sync.Barrier{}

main :: proc "contextless" () {
	fmt.println("Start")

	THREAD_COUNT :: 4
	threads: [THREAD_COUNT]^thread.Thread

	sync.barrier_init(barrier, THREAD_COUNT)

	for _, i in threads {
		threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
			// Same messages will be printed together but without any interleaving
			fmt.println("Getting ready!")
			sync.barrier_wait(barrier)
			fmt.println("Off their marks they go!")
		})
	}

	for t in threads {
		thread.destroy(t) // join and free thread
	}
	fmt.println("Finished")
}
    Related Procedures With Parameters

    Benaphore ¶
    Source

    Benaphore :: struct {
	counter: i32,
	sema:    Sema,
}
    Related Procedures With Parameters

    Cond ¶
    Source

    Cond :: struct {
	impl: _Cond,
}
     

    Cond implements a condition variable, a rendezvous point for threads waiting for signalling the occurence of an event

    A Cond must not be copied after first use

    Related Procedures With Parameters

    Futex ¶
    Source

    Futex :: distinct u32
     

    Futex is a fast userspace mutual exclusion lock, using a 32-bit memory address as a hint

    An Futex must not be copied after first use

    Related Procedures With Parameters

    Mutex ¶
    Source

    Mutex :: struct {
	impl: _Mutex,
}
     

    A Mutex is a mutual exclusion lock It can be used to prevent more than one thread from executing the same piece of code, and thus prevent access to same piece of memory by multiple threads, at the same time.

    A Mutex's zero value represents an initial, unlocked state.

    If another thread tries to take the lock while another thread holds it, it will pause until the lock is released. Code or memory that is "surrounded" by a mutex lock is said to be "guarded by a mutex".

    A Mutex must not be copied after first use (e.g., after locking it the first time). This is because, in order to coordinate with other threads, all threads must watch the same memory address to know when the lock has been released. Trying to use a copy of the lock at a different memory address will result in broken and unsafe behavior. For this reason, Mutexes are marked as #no_copy.

    Related Procedures With Parameters

    Once ¶
    Source

    Once :: struct {
	m:    Mutex,
	done: bool,
}
     

    Once is a data value that will perform exactly on action.

    A Once must not be copied after first use.

    Related Procedures With Parameters

    One_Shot_Event ¶
    Source

    One_Shot_Event :: struct {
	state: Futex,
}
     

    A One_Shot_Event is an associated token which is initially not present: * The one_shot_event_wait blocks the current thread until the event is made available * The one_shot_event_signal procedure automatically makes the token available if its was not already.

    Related Procedures With Parameters

    Parker ¶
    Source

    Parker :: struct {
	state: Futex,
}
     

    A Parker is an associated token which is initially not present: * The park procedure blocks the current thread unless or until the token is available, at which point the token is consumed. * The park_with_timeout procedures works the same as park but only blocks for the specified duration. * The unpark procedure automatically makes the token available if it was not already.

    Related Procedures With Parameters

    RW_Mutex ¶
    Source

    RW_Mutex :: struct {
	impl: _RW_Mutex,
}
     

    A RW_Mutex is a reader/writer mutual exclusion lock The lock can be held by any arbitrary number of readers or a single writer The zero value for a RW_Mutex is an unlocked mutex

    A RW_Mutex must not be copied after first use

    Related Procedures With Parameters

    Recursive_Benaphore ¶
    Source

    Recursive_Benaphore :: struct {
	counter:   int,
	owner:     int,
	recursion: i32,
	sema:      Sema,
}
    Related Procedures With Parameters

    Recursive_Mutex ¶
    Source

    Recursive_Mutex :: struct {
	impl: _Recursive_Mutex,
}
     

    A Recursive_Mutex is a recursive mutual exclusion lock The zero value for a Recursive_Mutex is an unlocked mutex

    A Recursive_Mutex must not be copied after first use

    Related Procedures With Parameters

    Sema ¶
    Source

    Sema :: struct {
	impl: _Sema,
}
     

    When waited upon, blocks until the internal count is greater than zero, then subtracts one. Posting to the semaphore increases the count by one, or the provided amount.

    A Sema must not be copied after first use

    Related Procedures With Parameters

    Ticket_Mutex ¶
    Source

    Ticket_Mutex :: struct {
	ticket:  uint,
	serving: uint,
}
    Related Procedures With Parameters

    Wait_Group ¶
    Source

    Wait_Group :: struct {
	counter: int,
	mutex:   Mutex,
	cond:    Cond,
}
     

    A Wait_Group waits for a collection of threads to finish

    A Wait_Group must not be copied after first use

    Related Procedures With Parameters

    Constants

    Atomic_RW_Mutex_State_Half_Width ¶
    Source

    Atomic_RW_Mutex_State_Half_Width :: size_of(Atomic_RW_Mutex_State) * 8 / 2

    Atomic_RW_Mutex_State_Is_Writing ¶
    Source

    Atomic_RW_Mutex_State_Is_Writing :: Atomic_RW_Mutex_State(1)

    Atomic_RW_Mutex_State_Reader ¶
    Source

    Atomic_RW_Mutex_State_Reader :: Atomic_RW_Mutex_State(1) << Atomic_RW_Mutex_State_Half_Width

    Atomic_RW_Mutex_State_Reader_Mask ¶
    Source

    Atomic_RW_Mutex_State_Reader_Mask :: Atomic_RW_Mutex_State(1 << (Atomic_RW_Mutex_State_Half_Width - 1) - 1) << Atomic_RW_Mutex_State_Half_Width

    Atomic_RW_Mutex_State_Writer ¶
    Source

    Atomic_RW_Mutex_State_Writer :: Atomic_RW_Mutex_State(1) << 1

    Atomic_RW_Mutex_State_Writer_Mask ¶
    Source

    Atomic_RW_Mutex_State_Writer_Mask :: Atomic_RW_Mutex_State(1 << (Atomic_RW_Mutex_State_Half_Width - 1) - 1) << 1

    Variables

    This section is empty.

    Procedures

    atomic_add ¶

    atomic_add :: intrinsics.atomic_add

    atomic_add_explicit ¶

    atomic_add_explicit :: intrinsics.atomic_add_explicit

    atomic_and ¶

    atomic_and :: intrinsics.atomic_and

    atomic_and_explicit ¶

    atomic_and_explicit :: intrinsics.atomic_and_explicit

    atomic_compare_exchange_strong ¶

    atomic_compare_exchange_strong :: intrinsics.atomic_compare_exchange_strong
     

    Returns value and optional ok boolean

    atomic_compare_exchange_strong_explicit ¶

    atomic_compare_exchange_strong_explicit :: intrinsics.atomic_compare_exchange_strong_explicit

    atomic_compare_exchange_weak ¶

    atomic_compare_exchange_weak :: intrinsics.atomic_compare_exchange_weak

    atomic_compare_exchange_weak_explicit ¶

    atomic_compare_exchange_weak_explicit :: intrinsics.atomic_compare_exchange_weak_explicit

    atomic_cond_broadcast ¶
    Source

    atomic_cond_broadcast :: proc "contextless" (c: ^Atomic_Cond) {…}

    atomic_cond_signal ¶
    Source

    atomic_cond_signal :: proc "contextless" (c: ^Atomic_Cond) {…}

    atomic_cond_wait ¶
    Source

    atomic_cond_wait :: proc "contextless" (c: ^Atomic_Cond, m: ^Atomic_Mutex) {…}

    atomic_cond_wait_with_timeout ¶
    Source

    atomic_cond_wait_with_timeout :: proc "contextless" (c: ^Atomic_Cond, m: ^Atomic_Mutex, duration: time.Duration) -> (ok: bool) {…}

    atomic_exchange ¶

    atomic_exchange :: intrinsics.atomic_exchange

    atomic_exchange_explicit ¶

    atomic_exchange_explicit :: intrinsics.atomic_exchange_explicit

    atomic_load ¶

    atomic_load :: intrinsics.atomic_load

    atomic_load_explicit ¶

    atomic_load_explicit :: intrinsics.atomic_load_explicit

    atomic_mutex_guard ¶
    Source

    atomic_mutex_guard :: proc "contextless" (m: ^Atomic_Mutex) -> bool {…}
     

    Example:

    if atomic_mutex_guard(&m) {
	...
}

    atomic_mutex_lock ¶
    Source

    atomic_mutex_lock :: proc "contextless" (m: ^Atomic_Mutex) {…}
     

    atomic_mutex_lock locks m

    atomic_mutex_try_lock ¶
    Source

    atomic_mutex_try_lock :: proc "contextless" (m: ^Atomic_Mutex) -> bool {…}
     

    atomic_mutex_try_lock tries to lock m, will return true on success, and false on failure

    atomic_mutex_unlock ¶
    Source

    atomic_mutex_unlock :: proc "contextless" (m: ^Atomic_Mutex) {…}
     

    atomic_mutex_unlock unlocks m

    atomic_nand ¶

    atomic_nand :: intrinsics.atomic_nand

    atomic_nand_explicit ¶

    atomic_nand_explicit :: intrinsics.atomic_nand_explicit

    atomic_or ¶

    atomic_or :: intrinsics.atomic_or

    atomic_or_explicit ¶

    atomic_or_explicit :: intrinsics.atomic_or_explicit

    atomic_recursive_mutex_guard ¶
    Source

    atomic_recursive_mutex_guard :: proc "contextless" (m: ^Atomic_Recursive_Mutex) -> bool {…}
     

    Example:

    if atomic_recursive_mutex_guard(&m) {
	...
}

    atomic_recursive_mutex_lock ¶
    Source

    atomic_recursive_mutex_lock :: proc "contextless" (m: ^Atomic_Recursive_Mutex) {…}

    atomic_recursive_mutex_try_lock ¶
    Source

    atomic_recursive_mutex_try_lock :: proc "contextless" (m: ^Atomic_Recursive_Mutex) -> bool {…}

    atomic_recursive_mutex_unlock ¶
    Source

    atomic_recursive_mutex_unlock :: proc "contextless" (m: ^Atomic_Recursive_Mutex) {…}

    atomic_rw_mutex_guard ¶
    Source

    atomic_rw_mutex_guard :: proc "contextless" (m: ^Atomic_RW_Mutex) -> bool {…}
     

    Example:

    if atomic_rw_mutex_guard(&m) {
	...
}

    atomic_rw_mutex_lock ¶
    Source

    atomic_rw_mutex_lock :: proc "contextless" (rw: ^Atomic_RW_Mutex) {…}
     

    atomic_rw_mutex_lock locks rw for writing (with a single writer) If the mutex is already locked for reading or writing, the mutex blocks until the mutex is available.

    atomic_rw_mutex_shared_guard ¶
    Source

    atomic_rw_mutex_shared_guard :: proc "contextless" (m: ^Atomic_RW_Mutex) -> bool {…}
     

    Example:

    if atomic_rw_mutex_shared_guard(&m) {
	...
}

    atomic_rw_mutex_shared_lock ¶
    Source

    atomic_rw_mutex_shared_lock :: proc "contextless" (rw: ^Atomic_RW_Mutex) {…}
     

    atomic_rw_mutex_shared_lock locks rw for reading (with arbitrary number of readers)

    atomic_rw_mutex_shared_unlock ¶
    Source

    atomic_rw_mutex_shared_unlock :: proc "contextless" (rw: ^Atomic_RW_Mutex) {…}
     

    atomic_rw_mutex_shared_unlock unlocks rw for reading (with arbitrary number of readers)

    atomic_rw_mutex_try_lock ¶
    Source

    atomic_rw_mutex_try_lock :: proc "contextless" (rw: ^Atomic_RW_Mutex) -> bool {…}
     

    atomic_rw_mutex_try_lock tries to lock rw for writing (with a single writer)

    atomic_rw_mutex_try_shared_lock ¶
    Source

    atomic_rw_mutex_try_shared_lock :: proc "contextless" (rw: ^Atomic_RW_Mutex) -> bool {…}
     

    atomic_rw_mutex_try_shared_lock tries to lock rw for reading (with arbitrary number of readers)

    atomic_rw_mutex_unlock ¶
    Source

    atomic_rw_mutex_unlock :: proc "contextless" (rw: ^Atomic_RW_Mutex) {…}
     

    atomic_rw_mutex_unlock unlocks rw for writing (with a single writer)

    atomic_sema_post ¶
    Source

    atomic_sema_post :: proc "contextless" (s: ^Atomic_Sema, count: int = 1) {…}

    atomic_sema_wait ¶
    Source

    atomic_sema_wait :: proc "contextless" (s: ^Atomic_Sema) {…}

    atomic_sema_wait_with_timeout ¶
    Source

    atomic_sema_wait_with_timeout :: proc "contextless" (s: ^Atomic_Sema, duration: time.Duration) -> bool {…}

    atomic_signal_fence ¶

    atomic_signal_fence :: intrinsics.atomic_signal_fence

    atomic_store ¶

    atomic_store :: intrinsics.atomic_store

    atomic_store_explicit ¶

    atomic_store_explicit :: intrinsics.atomic_store_explicit

    atomic_sub ¶

    atomic_sub :: intrinsics.atomic_sub

    atomic_sub_explicit ¶

    atomic_sub_explicit :: intrinsics.atomic_sub_explicit

    atomic_thread_fence ¶

    atomic_thread_fence :: intrinsics.atomic_thread_fence

    atomic_xor ¶

    atomic_xor :: intrinsics.atomic_xor

    atomic_xor_explicit ¶

    atomic_xor_explicit :: intrinsics.atomic_xor_explicit

    auto_reset_event_signal ¶
    Source

    auto_reset_event_signal :: proc "contextless" (e: ^Auto_Reset_Event) {…}

    auto_reset_event_wait ¶
    Source

    auto_reset_event_wait :: proc "contextless" (e: ^Auto_Reset_Event) {…}

    barrier_init ¶
    Source

    barrier_init :: proc "contextless" (b: ^Barrier, thread_count: int) {…}

    barrier_wait ¶
    Source

    barrier_wait :: proc "contextless" (b: ^Barrier) -> (is_leader: bool) {…}
     

    Block the current thread until all threads have rendezvoused Barrier can be reused after all threads rendezvoused once, and can be used continuously

    benaphore_guard ¶
    Source

    benaphore_guard :: proc "contextless" (m: ^Benaphore) -> bool {…}

    benaphore_lock ¶
    Source

    benaphore_lock :: proc "contextless" (b: ^Benaphore) {…}

    benaphore_try_lock ¶
    Source

    benaphore_try_lock :: proc "contextless" (b: ^Benaphore) -> bool {…}

    benaphore_unlock ¶
    Source

    benaphore_unlock :: proc "contextless" (b: ^Benaphore) {…}

    cond_broadcast ¶
    Source

    cond_broadcast :: proc "contextless" (c: ^Cond) {…}

    cond_signal ¶
    Source

    cond_signal :: proc "contextless" (c: ^Cond) {…}

    cond_wait ¶
    Source

    cond_wait :: proc "contextless" (c: ^Cond, m: ^Mutex) {…}

    cond_wait_with_timeout ¶
    Source

    cond_wait_with_timeout :: proc "contextless" (c: ^Cond, m: ^Mutex, duration: time.Duration) -> bool {…}

    cpu_relax ¶

    cpu_relax :: intrinsics.cpu_relax

    current_thread_id ¶
    Source

    current_thread_id :: proc "contextless" () -> int {…}

    futex_broadcast ¶
    Source

    futex_broadcast :: proc "contextless" (f: ^Futex) {…}

    futex_signal ¶
    Source

    futex_signal :: proc "contextless" (f: ^Futex) {…}

    futex_wait ¶
    Source

    futex_wait :: proc "contextless" (f: ^Futex, expected: u32) {…}

    futex_wait_with_timeout ¶
    Source

    futex_wait_with_timeout :: proc "contextless" (f: ^Futex, expected: u32, duration: time.Duration) -> bool {…}
     

    returns true if the wait happened within the duration, false if it exceeded the time duration

    mutex_guard ¶
    Source

    mutex_guard :: proc "contextless" (m: ^Mutex) -> bool {…}
     

    Example:

    if mutex_guard(&m) {
	...
}

    mutex_lock ¶
    Source

    mutex_lock :: proc "contextless" (m: ^Mutex) {…}
     

    mutex_lock locks m

    mutex_try_lock ¶
    Source

    mutex_try_lock :: proc "contextless" (m: ^Mutex) -> bool {…}
     

    mutex_try_lock tries to lock m, will return true on success, and false on failure

    mutex_unlock ¶
    Source

    mutex_unlock :: proc "contextless" (m: ^Mutex) {…}
     

    mutex_unlock unlocks m

    once_do_with_data ¶
    Source

    once_do_with_data :: proc(o: ^Once, fn: proc(data: rawptr), data: rawptr) {…}
     

    once_do_with_data calls the procedure fn if and only if once_do_with_data is being called for the first for this instance of Once.

    once_do_with_data_contextless ¶
    Source

    once_do_with_data_contextless :: proc "contextless" (o: ^Once, fn: proc "contextless" (data: rawptr), data: rawptr) {…}
     

    once_do_with_data_contextless calls the procedure fn if and only if once_do_with_data_contextless is being called for the first for this instance of Once.

    once_do_without_data ¶
    Source

    once_do_without_data :: proc(o: ^Once, fn: proc()) {…}
     

    once_do_without_data calls the procedure fn if and only if once_do_without_data is being called for the first for this instance of Once.

    once_do_without_data_contextless ¶
    Source

    once_do_without_data_contextless :: proc(o: ^Once, fn: proc "contextless" ()) {…}
     

    once_do_without_data calls the procedure fn if and only if once_do_without_data is being called for the first for this instance of Once.

    one_shot_event_signal ¶
    Source

    one_shot_event_signal :: proc "contextless" (e: ^One_Shot_Event) {…}
     

    Releases any threads that are currently blocked by this event with one_shot_event_wait.

    one_shot_event_wait ¶
    Source

    one_shot_event_wait :: proc "contextless" (e: ^One_Shot_Event) {…}
     

    Blocks the current thread until the event is made available with one_shot_event_signal.

    park ¶
    Source

    park :: proc "contextless" (p: ^Parker) {…}
     

    Blocks the current thread until the token is made available.

    Assumes this is only called by the thread that owns the Parker.

    park_with_timeout ¶
    Source

    park_with_timeout :: proc "contextless" (p: ^Parker, duration: time.Duration) {…}
     

    Blocks the current thread until the token is made available, but only for a limited duration.

    Assumes this is only called by the thread that owns the Parker

    recursive_benaphore_guard ¶
    Source

    recursive_benaphore_guard :: proc "contextless" (m: ^Recursive_Benaphore) -> bool {…}

    recursive_benaphore_lock ¶
    Source

    recursive_benaphore_lock :: proc "contextless" (b: ^Recursive_Benaphore) {…}

    recursive_benaphore_try_lock ¶
    Source

    recursive_benaphore_try_lock :: proc "contextless" (b: ^Recursive_Benaphore) -> bool {…}

    recursive_benaphore_unlock ¶
    Source

    recursive_benaphore_unlock :: proc "contextless" (b: ^Recursive_Benaphore) {…}

    recursive_mutex_guard ¶
    Source

    recursive_mutex_guard :: proc "contextless" (m: ^Recursive_Mutex) -> bool {…}
     

    Example:

    if recursive_mutex_guard(&m) {
	...
}

    recursive_mutex_lock ¶
    Source

    recursive_mutex_lock :: proc "contextless" (m: ^Recursive_Mutex) {…}

    recursive_mutex_try_lock ¶
    Source

    recursive_mutex_try_lock :: proc "contextless" (m: ^Recursive_Mutex) -> bool {…}

    recursive_mutex_unlock ¶
    Source

    recursive_mutex_unlock :: proc "contextless" (m: ^Recursive_Mutex) {…}

    rw_mutex_guard ¶
    Source

    rw_mutex_guard :: proc "contextless" (m: ^RW_Mutex) -> bool {…}
     

    Example:

    if rw_mutex_guard(&m) {
	...
}

    rw_mutex_lock ¶
    Source

    rw_mutex_lock :: proc "contextless" (rw: ^RW_Mutex) {…}
     

    rw_mutex_lock locks rw for writing (with a single writer) If the mutex is already locked for reading or writing, the mutex blocks until the mutex is available.

    rw_mutex_shared_guard ¶
    Source

    rw_mutex_shared_guard :: proc "contextless" (m: ^RW_Mutex) -> bool {…}
     

    Example:

    if rw_mutex_shared_guard(&m) {
	...
}

    rw_mutex_shared_lock ¶
    Source

    rw_mutex_shared_lock :: proc "contextless" (rw: ^RW_Mutex) {…}
     

    rw_mutex_shared_lock locks rw for reading (with arbitrary number of readers)

    rw_mutex_shared_unlock ¶
    Source

    rw_mutex_shared_unlock :: proc "contextless" (rw: ^RW_Mutex) {…}
     

    rw_mutex_shared_unlock unlocks rw for reading (with arbitrary number of readers)

    rw_mutex_try_lock ¶
    Source

    rw_mutex_try_lock :: proc "contextless" (rw: ^RW_Mutex) -> bool {…}
     

    rw_mutex_try_lock tries to lock rw for writing (with a single writer)

    rw_mutex_try_shared_lock ¶
    Source

    rw_mutex_try_shared_lock :: proc "contextless" (rw: ^RW_Mutex) -> bool {…}
     

    rw_mutex_try_shared_lock tries to lock rw for reading (with arbitrary number of readers)

    rw_mutex_unlock ¶
    Source

    rw_mutex_unlock :: proc "contextless" (rw: ^RW_Mutex) {…}
     

    rw_mutex_unlock unlocks rw for writing (with a single writer)

    sema_post ¶
    Source

    sema_post :: proc "contextless" (s: ^Sema, count: int = 1) {…}

    sema_wait ¶
    Source

    sema_wait :: proc "contextless" (s: ^Sema) {…}

    sema_wait_with_timeout ¶
    Source

    sema_wait_with_timeout :: proc "contextless" (s: ^Sema, duration: time.Duration) -> bool {…}

    ticket_mutex_guard ¶
    Source

    ticket_mutex_guard :: proc "contextless" (m: ^Ticket_Mutex) -> bool {…}

    ticket_mutex_lock ¶
    Source

    ticket_mutex_lock :: proc "contextless" (m: ^Ticket_Mutex) {…}

    ticket_mutex_unlock ¶
    Source

    ticket_mutex_unlock :: proc "contextless" (m: ^Ticket_Mutex) {…}

    unpark ¶
    Source

    unpark :: proc "contextless" (p: ^Parker) {…}
     

    Automatically makes thee token available if it was not already.

    wait_group_add ¶
    Source

    wait_group_add :: proc "contextless" (wg: ^Wait_Group, delta: int) {…}

    wait_group_done ¶
    Source

    wait_group_done :: proc "contextless" (wg: ^Wait_Group) {…}

    wait_group_wait ¶
    Source

    wait_group_wait :: proc "contextless" (wg: ^Wait_Group) {…}

    wait_group_wait_with_timeout ¶
    Source

    wait_group_wait_with_timeout :: proc "contextless" (wg: ^Wait_Group, duration: time.Duration) -> bool {…}

    Procedure Groups

    broadcast ¶
    Source

    guard ¶
    Source

     

    Example:

    if guard(&m) {
	...
}

    lock ¶
    Source

     

    lock locks m

    once_do ¶
    Source

     

    once_do calls the procedure fn if and only if once_do is being called for the first for this instance of Once.

    post ¶
    Source

    post :: proc{
	sema_post,
	atomic_sema_post,
}

    shared_guard ¶
    Source

     

    Example:

    if shared_guard(&m) {
	...
}

    shared_lock ¶
    Source

     

    shared_lock locks rw for reading (with arbitrary number of readers)

    shared_unlock ¶
    Source

     

    shared_unlock unlocks rw for reading (with arbitrary number of readers)

    signal ¶
    Source

    try_lock ¶
    Source

     

    try_lock tries to lock m, will return true on success, and false on failure

    try_shared_lock ¶
    Source

     

    try_shared_lock tries to lock rw for reading (with arbitrary number of readers)

    unlock ¶
    Source

     

    unlock locks m

    wait ¶
    Source

    wait_with_timeout ¶
    Source

    Source Files

    Generation Information

    Generated with odin version dev-2024-04 (vendor "odin") Windows_amd64 @ 2024-04-23 21:09:30.304018800 +0000 UTC