Re: Waiver question

[bobduff@world.std.com (Robert A Duff)]

In article <5kb8ol$18o@bcrkh13.bnr.ca>,
Kaz Kylheku <kaz@vision.crest.nt.com> wrote:
>Because you may wish to code an interrupt service routine for an embedded
>system without dropping down to the assembly language level. In that case
>it becomes important to know that you can modify some variable atomically;
>you suddenly care how the access is compiled into machine code. It's not
>practical or desirable to write interrupt service routines in assembly
>language.
>
>If access to that object is not atomic, the process that was interrupted could
>have been in the middle of trying to read that variable. 

No, I don't buy that.  If you want to modify variables atomically in
Ada, then you use pragma Atomic.  And it's no big deal if that causes an
8-bit thing to take up 32 bits.

The real answer to my question, as Robert Dewar e-mailed to me
privately, is that variables (including components) are independently
addressable by multiple tasks, unless they're part of a pragma-packed
type.  If you have a record containing three booleans, then on a
Pentium, it will fit in three bytes, whereas on an Alpha (early
versions), it will need 12 bytes.  Unless there's a pragma Pack (in
which case it will be three *bits* on both machines).  If task 1 refers
to X.Y, and task 2 refers to X.Z, that's supposed to be OK, unless the
type of X has a pragma Pack.

Strange semantics, IMHO.  Pragma Pack is all about time-vs-space
trade-offs, but it has this weird side-effect on tasking semantics.  We
should have a way to *declare* things independently adressable, but the
default should be that things are not.  Instead of forcing the compiler
to assume that *everything* is independently addressable.

- Bob