comp.lang.ada
 help / color / mirror / Atom feed
From: Jean-Pierre Rosen <rosen@adalog.fr>
Subject: Re: protected type interrupts
Date: Thu, 24 Aug 2006 17:39:28 +0200
Date: 2006-08-24T17:39:28+02:00	[thread overview]
Message-ID: <l7hkce.c61.ln@hunter.axlog.fr> (raw)
In-Reply-To: <1156430839.745932.279060@75g2000cwc.googlegroups.com>

REH a �crit :
> I am having a disagreement with a compiler vendor.  I am using a
> protected type for an interrupt handler (see below).  The handler
> simply sets a boolean to true that an entry is using as a guard.  The
> entry is called by a task.  Basically, the task is blocked until
> signaled by the interrupt to do the processing.  With newer versions of
> their compiler, the computer resets.  They say it is because they are
> calling the entry at the interrupt level, and not the task level (we
> process this in a task because we have to do things you cannot do in a
> interrupt).  They say the LRM allows them to do this.  Is that true?
C.3.1 (17) allows them to pretty much anything. Apparently, a 
ceiling_priority is in effect (either because you specified it, or by 
default), thus your task inherits the ceiling of the protected type 
(which is an interrupt_priority), and this implementation seems to 
forbid an entry to be called at an interrupt level.

A work-around could be:
   protected Relay_Object is

     procedure Isr;

     entry Process_Interrupt;

   private

     Triggered : Boolean := False;

   end Relay_Object;

   protected Interrupt_Object is

     procedure Isr;
     pragma Attach_Handler(Isr, XXX);
     pragma Interrupt_Priority(XXX);

   private

     pragma Suppress(All_Checks, On => Isr);
   end Interrupt_Object;

   protected body Relay_Object is

     procedure Isr is
     begin
       Triggered := True;
     end Isr;

     entry Process_Interrupt when Triggered is
     begin
       Triggered := False;

       -- process interrrupt
     end Process_Interrupt;

   end Relay_Object;

   protected body Interrupt_Object is

     procedure Isr is
     begin
       Relay_Object.Isr;
     end Isr;
   end Interrupt_Object;

This way, the task is not calling a PO that serves as an interrupt 
handler, thus C.3.1 (17) does not apply.
-- 
---------------------------------------------------------
            J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr



  reply	other threads:[~2006-08-24 15:39 UTC|newest]

Thread overview: 21+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2006-08-24 14:47 protected type interrupts REH
2006-08-24 15:39 ` Jean-Pierre Rosen [this message]
2006-08-24 16:23   ` REH
2006-08-24 18:15     ` Adam Beneschan
2006-08-24 19:16       ` REH
2006-08-24 21:16         ` Adam Beneschan
2006-08-24 21:39           ` REH
2006-08-25  6:45           ` Jean-Pierre Rosen
2006-08-24 23:55         ` Jeffrey R. Carter
2006-08-25  6:42         ` Jean-Pierre Rosen
2006-08-24 23:47     ` Jeffrey R. Carter
2006-08-25  6:38     ` Jean-Pierre Rosen
2006-08-24 20:11 ` Simon Wright
2006-08-24 23:50 ` Jeffrey R. Carter
2006-08-25  6:48   ` Jean-Pierre Rosen
2006-08-25 11:33     ` REH
2006-08-25 17:27       ` Jean-Pierre Rosen
2006-08-25 20:57     ` Jeffrey R. Carter
2006-08-25 23:17       ` REH
2006-08-26  6:38         ` Jeffrey R. Carter
2006-08-26 13:16           ` REH
replies disabled

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox