Synchronization on XWOS

Semaphore

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The semaphore is a relatively low-level synchronization mechanism in operating systems. It is a counter with a wait queue.

The semaphore contains an integer counter:

When the semaphore value equals 0, threads wait in the wait queue for the value to become greater than 0;
When the semaphore value is greater than 0, a waiting thread can be awakened. The awakened thread takes one unit of value, reducing the semaphore count by 1;
When the semaphore value is less than 0, the semaphore is in a frozen state. This state does not exist in theoretical semaphores; it is an extension of XWOS.

Any context can increase the value of the semaphore; this operation is called post.

Condition Variable

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The condition variable is a relatively low-level synchronization mechanism in operating systems that can simultaneously block multiple threads. When the condition is met, the condition variable can wake up one or all waiting threads.

Operating systems or language libraries provide condition variable functionality, for example:

POSIX pthread_cond_t
C++ std::condition_variable
Java java.util.concurrent.locks.Condition
Python threading.Condition
Rust std::sync::condvar

A thread must hold a mutex before waiting on a condition variable. When the condition variable blocks the thread, it synchronously releases the mutex. When the condition is met and the thread is awakened, the condition variable automatically re-locks the mutex. When an error occurs while waiting on the condition variable, the condition variable also automatically re-locks the mutex before returning.

Event Flag

Mon, 01 Jan 0001 00:00:00 +0000

Overview

When the system needs to handle many events, if each event is bound to a specific condition variable, and each condition variable is waited on by a thread, the system would require a large amount of memory to create condition variables and threads.

The event flag uses a bitmap to manage a group of events. Each bit in the bitmap represents an event. When one or more event states change, the corresponding bits change and wake up the waiting threads. Once awakened, the thread can retrieve the event states from the event bitmap.

Thread Barrier

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The XWOS thread barrier is a synchronization mechanism used to coordinate parallel work among multiple threads.

When creating a thread barrier, you specify how many thread slots it has. When a thread reaches the thread barrier, it will block and wait until the specified number of threads have all reached the barrier, at which point all threads are awakened simultaneously.

Thread Barrier Object and Object Descriptor

The thread barrier object is a derived class of XWOS Object struct xwos_object. Similarly, thread barrier objects also use the thread barrier object descriptor xwos_br_d to solve the problems of validity and identity legitimacy.

Signal Selector

Mon, 01 Jan 0001 00:00:00 +0000

Overview

The signal selector is similar to event flags, using a bitmap to manage a group of synchronization objects. This allows a single thread to wait on multiple synchronization objects simultaneously.

Each synchronization object is bound to a specific bit in the signal selector bitmap.

When these synchronization objects send a select signal, the specific bit in the signal selector bitmap is set to 1, and the thread waiting on the signal selector is awakened. After waking up, the thread can check which bits are set to 1 to determine which synchronization objects sent the select signal.