C.3.1 Protected Procedure Handlers
For a parameterless
protected procedure, the following language-defined representation aspects
may be specified:
The type of aspect Interrupt_Handler is Boolean. If directly specified,
the aspect_definition shall be a static expression. This aspect is never
inherited; if not directly specified, the aspect is False.
The aspect Attach_Handler is an expression
which shall be of type Interrupts.Interrupt_Id. This aspect is never
If either the Attach_Handler or Interrupt_Handler
aspect are specified for a protected procedure, the corresponding protected_type_declaration
shall be a library-level declaration and shall not be declared within
a generic body.
In addition to the places where Legality
Rules normally apply (see 12.3
), this rule
also applies in the private part of an instance of a generic unit.
This paragraph was
If the Interrupt_Handler aspect of a protected procedure
is True, then the procedure may be attached dynamically, as a handler,
to interrupts (see C.3.2
). Such procedures
are allowed to be attached to multiple interrupts.
specified for the Attach_Handler aspect of a protected procedure P
is evaluated as part of the creation of the protected object that contains
. The value of the expression
identifies an interrupt. As part of the initialization of that object,
procedure) is attached to the identified
A check is made that
the corresponding interrupt is not reserved.
is raised if the check fails, and the existing treatment for the interrupt
is not affected.
the Ceiling_Locking policy (see D.3
) is in
effect, then upon the initialization of a protected object that contains
a protected procedure for which either the Attach_Handler aspect is specified
or the Interrupt_Handler aspect is True, a check is made that the initial
ceiling priority of the object is in the range of System.Interrupt_Priority.
If the check fails, Program_Error is raised.
When a protected object is finalized,
for any of its procedures that are attached to interrupts, the handler
is detached. If the handler was attached by a procedure in the Interrupts
package or if no user handler was previously attached to the interrupt,
the default treatment is restored. If the Attach_Handler aspect was specified
and the most recently attached handler for the same interrupt is the
same as the one that was attached at the time the protected object was
initialized, the previous handler is restored.
When a handler is attached to an interrupt, the interrupt
is blocked (subject to the Implementation Permission in C.3
during the execution of every protected action on the protected object
containing the handler.
If restriction No_Dynamic_Attachment is in effect,
then a check is made that the interrupt identified by an Attach_Handler
aspect does not appear in any previously elaborated Attach_Handler aspect;
Program_Error is raised if this check fails.
If the Ceiling_Locking policy
) is in effect and an interrupt is
delivered to a handler, and the interrupt hardware priority is higher
than the ceiling priority of the corresponding protected object, the
execution of the program is erroneous.
If the handlers for a given
interrupt attached via aspect Attach_Handler are not attached and detached
in a stack-like (LIFO) order, program execution is erroneous. In particular,
when a protected object is finalized, the execution is erroneous if any
of the procedures of the protected object are attached to interrupts
via aspect Attach_Handler and the most recently attached handler for
the same interrupt is not the same as the one that was attached at the
time the protected object was initialized.
The following metric
shall be documented by the implementation:
The worst-case overhead for an interrupt handler
that is a parameterless protected procedure, in clock cycles. This is
the execution time not directly attributable to the handler procedure
or the interrupted execution. It is estimated as C – (A+B), where
A is how long it takes to complete a given sequence of instructions without
any interrupt, B is how long it takes to complete a normal call to a
given protected procedure, and C is how long it takes to complete the
same sequence of instructions when it is interrupted by one execution
of the same procedure called via an interrupt.
When the aspects Attach_Handler or Interrupt_Handler
are specified for a protected procedure, the implementation is allowed
to impose implementation-defined restrictions on the corresponding protected_type_declaration
An implementation may use a different mechanism for
invoking a protected procedure in response to a hardware interrupt than
is used for a call to that protected procedure from a task.
Notwithstanding what this subclause
says elsewhere, the Attach_Handler and Interrupt_Handler aspects are
allowed to be used for other, implementation defined, forms of interrupt
Whenever possible, the implementation should allow
interrupt handlers to be called directly by the hardware.
Whenever practical, the implementation should detect
violations of any implementation-defined restrictions before run time.
NOTE 1 The Attach_Handler aspect
can provide static attachment of handlers to interrupts if the implementation
supports preelaboration of protected objects. (See C.4
NOTE 2 For a protected object that
has a (protected) procedure attached to an interrupt, the correct ceiling
priority is at least as high as the highest processor priority at which
that interrupt will ever be delivered.
NOTE 3 Protected procedures can also
be attached dynamically to interrupts via operations declared in the
predefined package Interrupts.
NOTE 4 An example of a possible implementation-defined
restriction is disallowing the use of the standard storage pools within
the body of a protected procedure that is an interrupt handler.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe