pragma Priority(expression);
pragma Interrupt_Priority[(expression)];Name Resolution Rules
subtype Any_Priority is Integer range implementation-defined; subtype Priority is Any_Priority range Any_Priority'First .. implementation-defined; subtype Interrupt_Priority is Any_Priority range Priority'Last+1 .. Any_Priority'Last;
Default_Priority : constant Priority := (Priority'First + Priority'Last)/2;
Syntax
pragma Task_Dispatching_Policy(policy_identifier );Legality Rules
Implementation Permissions
pragma Locking_Policy(policy_identifier);Legality Rules
Implementation Permissions
pragma Queuing_Policy(policy_identifier);Legality Rules
Implementation Permissions
with System; with Ada.Task_Identification; -- see section The Package Task_Identification. package Ada.Dynamic_Priorities is
procedure Set_Priority (Priority : in System.Any_Priority; T : in Ada.Task_Identification.Task_ID := Ada.Task_Identification.Current_Task);
function Get_Priority (T : Ada.Task_Identification.Task_ID := Ada.Task_Identification.Current_Task) return System.Any_Priority;
end Ada.Dynamic_Priorities;Dynamic Semantics
Implementation Advice
All (nonenvironment) tasks depend directly on the environment task of the partition.
Objects with controlled parts and access types that designate such objects shall be declared only at library level.
There are no abort_statements, and there are no calls on Task_Identification.Abort_Task.
There are no selective_accepts with terminate_alternatives.
There are no allocators for task types or types containing task subcomponents.
There are no operations that implicitly require heap storage allocation to be performed by the implementation. The operations that implicitly require heap storage allocation are implementation defined.
There are no semantic dependences on the package Dynamic_Priorities.
There are no semantic dependences on the package Asynchronous_Task_Control.
Specifies the maximum number of alternatives in a selective_accept.
Specifies the maximum number of entries per task. The bounds of every entry family of a task unit shall be static, or shall be defined by a discriminant of a subtype whose corresponding bound is static. A value of zero indicates that no rendezvous are possible.
Specifies the maximum number of entries per protected type. The bounds of every entry family of a protected unit shall be static, or shall be defined by a discriminant of a subtype whose corresponding bound is static.Dynamic Semantics
Specifies the maximum portion (in storage elements) of a task's Storage_Size that can be retained by a blocked task.
Specifies the maximum dynamic nesting level of asynchronous_selects. A value of zero prevents the use of any asynchronous_select.
Specifies the maximum number of task creations that may be executed over the lifetime of a partition, not counting the creation of the environment task.
package Ada.Real_Time is
type Time is private; Time_First : constant Time; Time_Last : constant Time; Time_Unit : constant := implementation-defined-real-number;
type Time_Span is private; Time_Span_First : constant Time_Span; Time_Span_Last : constant Time_Span; Time_Span_Zero : constant Time_Span; Time_Span_Unit : constant Time_Span;
Tick : constant Time_Span; function Clock return Time;
function "+" (Left : Time; Right : Time_Span) return Time; function "+" (Left : Time_Span; Right : Time) return Time; function "-" (Left : Time; Right : Time_Span) return Time; function "-" (Left : Time; Right : Time) return Time_Span;
function "<" (Left, Right : Time) return Boolean; function "<="(Left, Right : Time) return Boolean; function ">" (Left, Right : Time) return Boolean; function ">="(Left, Right : Time) return Boolean;
function "+" (Left, Right : Time_Span) return Time_Span; function "-" (Left, Right : Time_Span) return Time_Span; function "-" (Right : Time_Span) return Time_Span; function "*" (Left : Time_Span; Right : Integer) return Time_Span; function "*" (Left : Integer; Right : Time_Span) return Time_Span; function "/" (Left, Right : Time_Span) return Integer; function "/" (Left : Time_Span; Right : Integer) return Time_Span;
function "abs"(Right : Time_Span) return Time_Span;
function "<" (Left, Right : Time_Span) return Boolean; function "<="(Left, Right : Time_Span) return Boolean; function ">" (Left, Right : Time_Span) return Boolean; function ">="(Left, Right : Time_Span) return Boolean;
function To_Duration (TS : Time_Span) return Duration; function To_Time_Span (D : Duration) return Time_Span;
function Nanoseconds (NS : Integer) return Time_Span; function Microseconds (US : Integer) return Time_Span; function Milliseconds (MS : Integer) return Time_Span;
type Seconds_Count is range implementation-defined;
procedure Split(T : in Time; SC : out Seconds_Count; TS : out Time_Span); function Time_Of(SC : Seconds_Count; TS : Time_Span) return Time;
private ... -- not specified by the language end Ada.Real_Time;
An upper bound on the real-time duration of a clock tick. This is a value D such that if t1 and t2 are any real times such that t1 < t2 and Clock = Clock then t2 - t1 <= D. t1 t2
E*(1-D) <= (Clock - Clock ) <= E*(1+D) t+E t provided that: Clock + E*(1+D) <= Time_Last. t
where Clock is the value of Clock at time t, and E is a real time t time duration not less than 24 hours. The value of E used for this metric shall be reported. @end format
If C is a value of Clock read before a task executes a 1 delay_relative_statement with duration D, and C is a value of Clock 2 read after the task resumes execution following that delay_statement, then C - C >= D. 2 1
package Ada.Synchronous_Task_Control is
type Suspension_Object is limited private; procedure Set_True(S : in out Suspension_Object); procedure Set_False(S : in out Suspension_Object); function Current_State(S : Suspension_Object) return Boolean; procedure Suspend_Until_True(S : in out Suspension_Object); private ... -- not specified by the language end Ada.Synchronous_Task_Control;
with Ada.Task_Identification; package Ada.Asynchronous_Task_Control is procedure Hold(T : in Ada.Task_Identification.Task_ID); procedure Continue(T : in Ada.Task_Identification.Task_ID); function Is_Held(T : Ada.Task_Identification.Task_ID) return Boolean; end Ada.Asynchronous_Task_Control;Dynamic Semantics
protected Lock is procedure Set; function Read return Boolean; private Flag : Boolean := False; end Lock;
protected body Lock is procedure Set is begin Flag := True; end Set; function Read return Boolean Begin return Flag; end Read; end Lock;
Go to the first, previous, next, last section, table of contents.