What are the foundations of barriers and semaphores?

Barriers and semaphores in the context of parallel programming are based on synchronization mechanisms:

• Semaphores: Based on atomic operations on a counter. Main operations:

  • wait (or P, acquire): Decrements the counter. If the counter becomes negative, the thread is blocked until another thread performs signal.
  • signal (or V, release): Increments the counter. If there are blocked threads, one of them is awakened.
  • Semaphores can be binary (value 0 or 1, acting as mutexes) or counting (allowing a limited number of threads to access a resource).

• Barriers: Based on the mechanism where all participants wait. A thread reaching the barrier is blocked until all other threads involved in synchronization also reach this barrier. Once all threads have reached the barrier, they continue execution simultaneously.

In iOS/macOS development, these concepts are implemented using concurrent programming frameworks such as GCD (Grand Central Dispatch) and OperationQueue.

For example, in GCD:

// Example of using DispatchSemaphore
let semaphore = DispatchSemaphore(value: 1) // Binary semaphore

// Wait (acquire)
semaphore.wait()
// Access to critical section
semaphore.signal() // Signal (release)

Barriers in GCD are implemented using barrier tasks for concurrent queues:

let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)

// Regular tasks
concurrentQueue.async {
    // ...
}

// Barrier task - executes only when all previous regular tasks are finished
// After which no new tasks will start until it completes
concurrentQueue.async(flags: .barrier) {
    // ...
}

// Regular tasks that will start after the barrier task completes
concurrentQueue.async {
    // ...
}