by Jim Rogers
This is part five (of five) of this article. Click here to return to part four, or click here to return to the article’s table of contents.Concurrent Programming
Ada provides an extensive set of capabilities for creating programs with concurrent code modules. Java achieves many of the same results using the Thread class. An Ada concurrent code module is called a task.
Tasks and Task Types
When you create a task you can choose to make a one of a kind task, or a task type which can be used to create many identical tasks. Tasks andtask types are defined in two parts. The first part defines the public interface to the task, specifying any entry calls. The second part contains the implementation of the task code. Ada tasks can communicate with each other directly using the rendezvous mechanism. A rendezvous creates a synchronization or meeting point between the task calliing another task’s entry and the called task. The first task to the rendezvous will suspend until another task gets to the same rendezvous.
Task Definition
task Simple_Task is
entry Start(Num : in Integer);
entry Report(Num : out Integer);
end Simple_Task;
task body Simple_Task is
Local_Num : Integer;
begin
accept Start(Num : in Integer) do
Local_Num := Num;
end Start;
Local_Num := Local_Num * 2;
accept Report(Num : out Integer) do
> Num := Local_Num;
end Report;
end Simple_Task;
The task Simple_Task is declared to have two entries: Start and Report. Another task can communicate with Simple_Task by calling Start and passing in an Integer, or by calling Report and passing out an Integer. Simple_Task starts executing as soon as the program starts, but it does not get very far. It encounters the accept Start statement as its first executable statement. Simple_Task suspends at that accept statement until some other task calls its Start entry. During the Start entry Simple_Task assigns the value in the formal parameter Num to the local variable Local_Num . This assignment is necessary because the Num parameter is only in scope between the do and done statements. Upon completion of this rendezvous Simple_Task continues executing until it encounters another accept statement. Simple_Task again suspends if no other task has yet called its Report entry. When another task does call the Report entry the value of Local_Num is copied to the parameter Num. Upon completion of the Rendezvous the calling task has the value from Local_Num and Simple_Task completes because there are no more statements to execute.
The example of Simple_Task shown above has one major limitation. It is a one time definition of a single task. If you want to make many instances of this task you need to create a task type. The only difference in syntax is the addition of the word type in the task interface code.
task type Simple_Task is
entry Start(Num : in Integer);
entry Report(Num : out Integer);
end Simple_Task;
task body Simple_Task is
Local_Num : Integer;
begin
accept Start(Num : in Integer) do
Local_Num := Num;
end Start;
Local_Num := Local_Num * 2;
accept Report(Num : out Integer) do
Num := Local_Num;
end Report;
end Simple_Task;
With the creation of a task type we have the opportunity of making as many instances as we need.
type Task_Pool is array(Positive range 1..10) of Simple_Task; My_Pool : Task_Pool;
Declaration of the array type does not create any tasks. Declaration of the array instance creates 10 instances of Simple_Task. All this can be put together in a small program.
with Ada.Text_IO; use Ada.Text_Io;
procedure Test_Simple is
task type Simple_Task is
entry Start(Num : in Integer);
entry Report(Num : out Integer);
end Simple_Task;
task body Simple_Task is
Local_Num : Integer;
begin
accept Start(Num : in Integer) do
Local_Num := Num;
end Start;
Local_Num := Local_Num * 2;
accept Report(Num : out Integer) do
Num := Local_Num;
end Report;
end Simple_Task;
type Task_Pool is array(Positive range 1..10) of Simple_Task;
My_Pool : Task_Pool;
The_Value : Integer;
begin
for num in My_Pool'Range loop
My_Pool(num).Start(num);
end loop;
for num in My_Pool'Range loop
My_Pool(num).Report(The_Value);
Put_Line("Task" & Integer'Image(num) & " reports"
& Integer'Image(The_Value));
end loop;
end Test_Simple;
The Ada rendezvous mechanisim is useful but there are many designs that require a more asynchronous behavior between tasks. Ada provides an elegant and powerful approach to creating objects that can be shared between tasks. Those object are called Protected Objects. Just as with tasks, you can make a single version or a Protected Type, which allows you to create many instances of the same kind of shared memory object. Protected objects are protected from inappropriate mutual access by tasks.
Selective Acceptance of Entry Calls
A task may need to respond to one of many entry calls each time through its major control loop. A task may need to check if an entry has been called, but proceed immediately if it has not. Alternatively a task may need to wait for an entry call, but no more than a specified amount of time. Ada provides forms of selective accept calls for this purpose.
Selective Accept
loop
select
accept Stop;
exit;
else
Put_Line ("Not stopped yet");
end select;
delay 0.01;
end loop;
This example shows an infinite loop. Each time through the loop the code selectively accepts the Stop entry for this task. If the entry is accepted the exit command is executed, terminating the loop. If no task has called the Stop entry the code prints Not stopped yet then delays (suspends) for 0.01 seconds.
loop
select
accept Stop;
exit;
or
delay 0.01;
end select;
Put_Line ("Not stopped yet");
end loop;
The syntax of this example is slightly different from the previous example. The example still has an infinite loop that checks if the Stop entry has been called each time through the loop. In this example the task will simultaneously start a delay timer. If the delay expires before the Stop entry is called the string Not stopped yet is printed. If the Stop entry is called before the timer expires the timer is cancelled and the exit command is executed, terminating the loop.
loop
select
accept Stop;
exit;
or
accept Put(Item : in Integer) do
Local_Item := Item;
end Put;
Local_Item := Local_Item * 2;
else
Put_Line("No entry calls this time");
end select;
delay 0.01;
end loop;
Each time through this loop the task checks to see if either Stop or Put has been called. If Stop has been called the exit command is executed, terminating the loop. If Put has been called Local_Item is assigned the value of Item, then that value is multiplied by 2. If neither entry has been called the task prints No entry calls this time. If the loop has not been terminated the task delays for 0.01 seconds and repeats the loop. A selective accept may have several accept alternatives.
Protected Objects and Protected Types
There are three kinds of operations on protected objects.
- Procedures are used to unconditionally changes the state of the protected object. Procecures must have exclusive access to the protected object. The good news about that requirement is that the compiler generates all the code required to make exclusive access happen.
- Entries are also used to change the state of the protected object. The difference between entries and procedures is that entries have a boundary condition. They can only be executed when the boundary condition is true. If a task calls a protected entry when the boundary condition is false the call will be placed in an entry queue, and only executed when the boundary condition becomes true.
- Functions are used to report the state of a protected object. Since functions do not change the state of the protected object it is legal for several tasks to simultaneously access a protected object through function calls.
The following protected object implements a counting semaphore. It allows up to 5 tasks to simultaneously hold the semaphore.
protected type Counting_Semaphore is
entry Acuire;
procedure Release;
function Count return Natural;
private
Holding_Count : Natural := 0;
end Counting_Semaphore;
protected body Counting_Semaphore is
entry Acquire when Holding_Count < 5 is
begin
Holding_Count := Holding_Count + 1;
end Acquire;
procedure Release is
begin
if Holding_Count > 0 then
Holding_Count := Holding_Count - 1;
end if;
end Release;
function Count return Natural is
begin
return Holding_Count;
end Count;
end Counting_Semaphore;
This example demonstrates the use of all three protected operations. Protected types allow you to define any necessary shared memory design.
Selective Entry Calls
When a task calls an entry, that call may be queued up due to a closed boundary condition. The calling task may not be able to suspend indefinitely due to strict timing requirements. If this is the case the calling task can use a selective entry call. This can either be a timed entry call, supplying a timeout, or a conditional entry call, providing an immediate alternative.
select
Semaphore.Acquire;
Acquired := True;
or
delay 0.15;
Acquired := False;
end select;
This shows how a task could try to acquire a counting semaphore as shown above, but wait no more than 0.15 seconds for success.
select
Semaphore.Acquire;
else
raise Resources_Blocked;
end select;
This example attempts to immediately acquire the semaphore. If the semaphore is not immediately available the exception Resources_Blocked is raised.
Generics
Ada allows generic programming, similar to C++ templates. You can define any compilation unit to be generic. This allows you to define an algorithm independent of the data type it must be used with. If you want to create a generic package or procedure and allow the use of any non-limited type then you must delcare the formal generic parameter to be private.
generic
type Element_Type is private;
procedure Swap(Left, Right : in out Element_Type) is
Temp : Element_Type := Left;
begin
Left := Right;
Right := Temp;
end Swap;
This procedure must be instantiated for a specific type to be used.
with Swap;
procedure Swap_Test is
procedure Exchange is new Swap(Integer);
A : Integer := 6;
B : Integer := -19;
begin
Exchange(A, B);
end Swap_Test;
In this example procedure Exchange is instantiated as a version of Swap taking Integer values as parameters. The generic procedure is instantiated in the declarative region of procedure Swap_Test . Exchange is called in the body of the procedure. After the call to Exchange, A will contain -19 and B will contain 6. Generic instantiation is performed at compile time. This allows the compiler to perform all parameter type checks on the call.
Generics are very useful when defining protected objects containing a buffer.
generic
type Buffer_Type is private;
package Generic_Buffer is
protected type Buffer is
entry Get(Item : out Buffer_Type);
procedure Put(Item : in Buffer_Type);
private
Internal : Buffer_Type;
Is_New : Boolean := False;
end Buffer;
end Generic_Buffer;
package body Generic_Buffer is
protected body Buffer is
entry Get(Item : out Buffer_Type) when Is_New is
begin
Item := Internal;
Is_New := False;
end Get;
procedure Put(Item : in Buffer_Type) is
begin
Internal := Item;
Is_New := True;
end Put;
end Buffer;
end Generic_Buffer;
This generic buffer allows the writing task to write to the buffer unconditionally. The reading task can only read new data. It cannot read uninitialized data nor data it has already read. This buffer pattern is used to allow the reader to sample the output of the writer at any rate equal to or less than the rate the writer writes to the buffer. In other words, the reader will be no faster than the writer.
Conclusion
Ada is an effective language for the economical creation of correct software. Along with fairly common features such as modularity and the ability to program by extension, Ada adds a sophisticated set of tools for concurrent programming and a very rich type system that allows you to create your own customized primitive types. The compiler can then use those customizations to determine coding errors. The compiler will also, as a default behavior, automatically produce safety and correctness checks for run time error detection.
The cost of Ada compilers ranges from free to expensive. The free compilers are very robust and complete, but come with no support. The commercial compilers come with enhanced development environments and very strong support. Most of the support offered comes in the form of training in the Ada language. Every Ada compiler currently on the market has passed the compiler correctness test suite. This ensures that Ada programs are highly portable across compilers as well as across operating systems.
Ada has established itself as the world’s premier language for safety critical applications. It has also been shown to be among the most economical languages to use for serious programming efforts.
Click here to return to the start of this article, or here to return to the table of contents.
