Re: Reducing the cost of real-time software through a cyclic task abstraction for Ada

[Simon Wright <simon@pushface.org>]

guyclaude.burger@gmail.com writes:

> That paper is huge, no wonder no one (seems to) dares to review
> it. Could you make a summary, or a short exposé on why "loop delay
> until ..." or similar statements are not enough to implement neatly
> the desired semantic ?

Not that big for a thesis, though it does seem a bit repetitive. The pix
seemed a bit OTT, I guess I'm just old-fashioned. And English.

He made criticisms of the -sfp- RTSs which don't apply to the -full-
versions; e.g. no memory allocation, no inheritance (and, by the way,
the -sfp- version *does* provide memory allocation, just not
deallocation). We have to remember that it takes a lot of time to work
to a doctorate, and keeping up with AdaCore improvements wouldn't add a
lot.

The problem with implementing the desired task paradigms with 'delay
until' etc is that although you could do it with a lot of distributed
effort (including use of tasking libraries as in GNATCOLL) it wouldn't
be easy to work out whether the system would meet its deadlines, with a
tool or by hand. And there'd be lots of opportunity for mistakes.

Another point I noticed was that he doesn't like the way an entry
released by an interrupt handler runs in the context of the task that
happened to be running at the time of the interrupt. I can't get too
excited about that, the interrupt had to be handled, and the code in the
entry shouldn't(*) be lengthy.

He says (p.158) "running a protected procedure handler in response to an
interrupt [...] invokes a context switch" which is not true.

My personal view of the AdaCore BB RTS is that it's fiendishly
complicated. I suppose that to meet all the ARM requirements it has to
be. Some of this appears to be for portability. The package call graph
is deeply nested.

I ws interested to see the claim that AdaCore BB RTS won't allow an MCU
to enter a low-power mode. I've not had occasion to try it out, but
FreeRTOS (which my Cortex GNAT RTS[1] runs on) does support this.

(*) not a good position to be in if your system is severely CPU-bound;
but in that case, would you believe the theoretical calculations anyway?

[1] https://github.com/simonjwright/cortex-gnat-rts