Ada Constructs Revisited 21 Oct. 2002

Constructs to be Expanded Generics Tasking Elaboration

Generics Generic units are used to make Ada’s strong types less painful —Possible to create general unit once, but use it for many different declared types —Has types, variables, subprograms, and packages as parameters —When each instance is made of a generic unit, it might be a separate copy, or it might share code

Non-Generic Version package Complex_Numbers is type Complex is private;... function Construct (Real : Float; Imaginary : Float) return Complex; function “+” (X, Y: Complex) return Complex;... private type Complex is record Real_Part : Float; Imaginary_Part : Float; end record; end;

Non-Generic Body package body Complex_Numbers is... function Construct (Real : Float; Imaginary : Float) return Complex is begin return Complex’(Real, Imaginary); end Construct; function “+” (X, Y: Complex) return Complex is begin return Complex’( (X.Real_Part + Y.Real_Part), (X.Imaginary_Part + Y.Imaginary_Part) ); end “+”;... end Complex_Numbers;

Generic Example generic type My_Float is digits <>; package Generic_Complex_Numbers is type Complex is private;... function Construct (Real : My_Float; Imaginary : My_Float) return Complex; function “+” (X, Y: Complex) return Complex;... private type Complex is record Real_Part : My_Float; Imaginary_Part : My_Float; end record; end;

Generic Body – Almost Identical to Non-Generic package body Generic_Complex_Numbers is... function Construct (Real : My_Float; Imaginary : My_Float) return Complex is begin return Complex’(Real, Imaginary); end Construct; function “+” (X, Y: Complex) return Complex is begin return Complex’( (X.Real_Part + Y.Real_Part), (X.Imaginary_Part + Y.Imaginary_Part) ); end “+”;... end Generic_Complex_Numbers;

Instantiating a Generic with Generic_Complex_Numbers; procedure Test is type Small_Float_type is digits 6; type Large_Float_type is digits 14; package Small_Complex is new Generic_Complex_Numbers (Small_Float_type); use Small_Complex; package Large_Complex is new Generic_Complex_Numbers (Large_Float_type); use Large_Complex; Small_Real_Part : Small_Float_type := 1.234_567; Small_Imaginary_Part : Small_Float_type := 2.345_678; Large_Real_Part : Large_Float_type := 3.456_789_101_112; Large_Imaginary_Part : Large_Float_type := 4.567_891_011_121_3; Small_Complex_Number : Small_Complex.Complex := Construct (Small_Real_Part, Small_Imaginary_Part); Large_complex_Number : Large_Complex.Complex := Construct (Large_Real_part, Large_Imaginary_Part); begin Small_Complex_Number := Small_Complex_Number + Small_Complex_Number; Large_Complex_Number := Large_Complex_Number + Large_Complex_Number; end Test;

Tasking Multitasking (what UNIX people call Threads) is built in to the Ada language —Model is parallel activities —Easily implemented to use multiple processors —Implementation can use any scheduling mechanism »Time slicing, where each task (of the same priority) gets a bit of time, then the next task runs »One task runs until it hits a blocking point, then the next task (of the same priority or lower) runs —Priority can be used (if supported) to force the system to run tasks in a certain order (if running on a single processor system)

The rendezvous “two people meet, perform a transaction and then go on independently” Between two tasks: one task calls an entry declared in another. Task Specification task T is entry E( … ); end; Some other Task T.E( … ); Task Body accept E( … ) do --sequence of statements end E;

Simple mechanism to create critical sections: section of code that must be executed by only one task at a time task type Semaphore is entry P; -- Dijkstra’s terminology entry V; -- Passeren (lock) end Semaphore; -- Vrimajken (unlock) task body Semaphore is begin loop accept P; accept V; -- will not accept another P until a caller asks for V end loop; end Semaphore; Example: semaphore

Using a semaphore A task that needs exclusive access to the critical section executes: Semaphore.P; … -- critical section code Semaphore.V; If in the meantime another task calls Semaphore.P, it blocks, because the semaphore does not accept a call to P until after the next call to V : the other task is blocked until the current one releases by making an entry call to V. Programming hazards: –someone else may call V : race condition –no one calls V: other callers are deadlocked –Starvation is possible if the queue is not a FIFO queue

Timing and scheduling Time slicing Priorities Real-Time Systems annex (Annex D) Task can be held up of different reasons —Waiting for: »a partner in a rendezvous »dependent task to terminate —delay 3.0; Seconds: constant duration := 1.0; Minutes: constant Duration := 60.0; Hours: constant Duration := ; delay 2*Hours+40*Minutes;

Example loop delay 5*Minutes; Action; end loop; Want cyclic execution. Any problems with this solution?

Same, but different … declare use Calendar; Interval: constant Duration := 5*Minutes; Next_Time: Time := First_Time; begin loop delay until Next_Time; Action; Next_Time := Next_Time + Interval; end loop; end;

“Protected Variable” Protect a variable V from uncontrolled access. package Protected_Variable is procedure Read(X: out Item); procedure Write(X: in Item); end; package body Protected_Variable is V: Item := initial value; procedure Read(X: out Item) is begin X := V; end; procedure Write(X: in Item) is begin V := X; end; end Protected_Variable; type Item is record X_Coord: Float; Y_Coord: Float; end record; Any problems?

Protected Object Example package Variable is type My_Type is...; protected P_Variable is function Read return My_Type; -- Many callers procedure Write ( -- One caller X : in My_Type ); private V : My_Type := 0; end P_Variable; end Variable; Any number of tasks may call protected functions at the same time Protected functions can not write to protected objects Not possible for a task to call Write while another calls Read (the second will block)

Bounded buffer IJ N: constant := 8; type Index is mod N; type Item_Array is array (Index) of Item; protected type Buffering is entry Put(X: in Item); entry Get(X: out Item); private A: Item_Array; I,J: Index := 0; Count: Integer range 0..N := 0; end Buffering; protected body Buffering is entry Put(X: in Item) when Count < N is begin A(I) := X; I := I+1; Count := Count + 1; end Put; entry Get(X: out Item) when Count >0 is begin X := A(J); J := J + 1; Count := Count – 1; end Get; end Buffering; My_Buffer : Buffering; … My_Buffer.Put(X);

Elaboration Ada programs perform work before the first executable statement after the “begin” of the main procedure is run —“Elaboration” code is executed first »Gives data initial values (which might call functions) »Creates objects (if dynamic) »Runs package initialization code To be completely precise, the whole program is one big elaboration —Package specifications are elaborated before their bodies —Package bodies are elaborated before any of their subprograms can be called —Package bodies can have task bodies, which start running after the package body has been elaborated —When all packages have been elaborated, the main procedure runs

Elaboration Example with Ada.Text_IO; procedure Elab_Test is package Random_Pack is -- Elaboration of this is first type My_Type is digits 6 range ; function Random return My_Type; end Random_Pack; package body Random_Pack is -- Elaboration of this is second Seed : My_Type; function Random return My_Type is task My_Task; task body My_Task is X : My_Type := Random; begin Ada.Text_IO.Put ("Made it"); end My_Task; begin return Seed; -- For now, return a constant end Random; begin Seed := 0.5; -- Need this before Random can be called end Random_Pack; -- After last statement after "begin", My_Task can run use Random_Pack; Z : My_Type := Random; -- Executes the Random function begin null; end Elab_Test;

Watch Out for Circular Dependencies package My_Pack is type My_type is range 1_ _000_000; procedure Do_Something (Parameter : in out My_type); end My_Pack; package Other_Pack is type Other_type is range 0.. 1_000; function Do_Something_Else return Other_type; end Other_Pack; with Other_Pack; pragma Elaborate (Other_Pack); package body My_Pack is X : Other_Pack.Other_type := Do_Something_Else; -- Needs Other_Pack body elab... end My_Pack; with My_Pack; package body Other_Pack is X : My_Pack.My_type;... end Other_Pack;