Metered concurrency
You are encouraged to solve this task according to the task description, using any language you may know.
The goal of this task is to create a counting semaphore used to control the execution of a set of concurrent units. This task intends to demonstrate coordination of active concurrent units through the use of a passive concurrent unit. The operations for a counting semaphore are acquire, release, and count. Each active concurrent unit should attempt to acquire the counting semaphore before executing its assigned duties. In this case the active concurrent unit should report that it has acquired the semaphore. It should sleep for 2 seconds and then release the semaphore.
Ada
The interface for the counting semaphore is defined in an Ada package specification:
package Semaphores is protected type Counting_Semaphore(Max : Positive) is entry Acquire; procedure Release; function Count return Natural; private Lock_Count : Natural := 0; end Counting_Semaphore; end Semaphores;
The Acquire entry has a condition associated with it. A task can only execute the Acquire entry when Lock_Count is less than Max. This is the key to making this structure behave as a counting semaphore. This condition, and all the other aspects of Counting_Semaphore are contained in the package body.
package body Semaphores is ------------------------ -- Counting_Semaphore -- ------------------------ protected body Counting_Semaphore is ------------- -- Acquire -- ------------- entry Acquire when Lock_Count < Max is begin Lock_Count := Lock_Count + 1; end Acquire; ----------- -- Count -- ----------- function Count return Natural is begin return Lock_Count; end Count; ------------- -- Release -- ------------- procedure Release is begin if Lock_Count > 0 then Lock_Count := Lock_Count - 1; end if; end Release; end Counting_Semaphore; end Semaphores;
We now need a set of tasks to properly call an instance of Counting_Semaphore.
with Semaphores; with Ada.Text_Io; use Ada.Text_Io; procedure Semaphores_Main is -- Create an instance of a Counting_Semaphore with Max set to 3 Lock : Semaphores.Counting_Semaphore(3); -- Define a task type to interact with the Lock object declared above task type Worker is entry Start (Sleep : in Duration; Id : in Positive); end Worker; task body Worker is Sleep_Time : Duration; My_Id : Positive; begin accept Start(Sleep : in Duration; Id : in Positive) do My_Id := Id; Sleep_Time := Sleep; end Start; --Acquire the lock. The task will suspend until the Acquire call completes Lock.Acquire; Put_Line("Task #" & Positive'Image(My_Id) & " acquired the lock."); -- Suspend the task for Sleep_Time seconds delay Sleep_Time; -- Release the lock. Release is unconditional and happens without suspension Lock.Release; end Worker; -- Create an array of 5 Workers type Staff is array(Positive range 1..5) of Worker; Crew : Staff; begin for I in Crew'range loop Crew(I).Start(2.0, I); end loop; end Semaphores_Main;