D.12 Other Optimizations and Determinism Rules
[This clause describes various requirements for improving
the response and determinism in a real-time system.]
Implementation Requirements
If the implementation blocks interrupts (see
C.3)
not as a result of direct user action (e.g. an execution of a protected
action) there shall be an upper bound on the duration of this blocking.
Ramification: The implementation shall
not allow itself to be interrupted when it is in a state where it is
unable to support all the language-defined operations permitted in the
execution of interrupt handlers. (see
9.5.1).
The implementation shall recognize entry-less protected
types. The overhead of acquiring the execution resource of an object
of such a type (see
9.5.1) shall be minimized.
In particular, there should not be any overhead due to evaluating
entry_barrier
conditions.
Implementation Note: Ideally the overhead
should just be a spin-lock.
Unchecked_Deallocation shall be supported for terminated
tasks that are designated by access types, and shall have the effect
of releasing all the storage associated with the task. This includes
any run-time system or heap storage that has been implicitly allocated
for the task by the implementation.
Documentation Requirements
The implementation shall document the upper bound
on the duration of interrupt blocking caused by the implementation. If
this is different for different interrupts or interrupt priority levels,
it should be documented for each case.
This paragraph
was deleted.
Documentation Requirement: The upper
bound on the duration of interrupt blocking caused by the implementation.
Metrics
The implementation
shall document the following metric:
The overhead associated with obtaining a mutual-exclusive
access to an entry-less protected object. This shall be measured in the
following way:
For a protected
object of the form:
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;
The execution time, in processor clock
cycles, of a call to Set. This shall be measured between the point just
before issuing the call, and the point just after the call completes.
The function Read shall be called later to verify that Set was indeed
called (and not optimized away). The calling task shall have sufficiently
high priority as to not be preempted during the measurement period. The
protected object shall have sufficiently high ceiling priority to allow
the task to call Set.
For a multiprocessor, if supported, the
metric shall be reported for the case where no contention (on the execution
resource) exists [from tasks executing on other processors].
Documentation Requirement: The metrics
for entry-less protected objects.
Sponsored by Ada-Europe