Re: Pragma Atomic

[Robert Dewar <robert_dewar@my-deja.com>]

In article <93g48c$ehk$1@nnrp1.deja.com>,
  Adam Beneschan <adam@irvine.com> wrote:
> It wouldn't make sense to declare a scalar object, whose size
> is a natural size on the processor, to be Atomic, since the
> processor's reads and writes of
> such an object would automatically be indivisible anyway.

AARGH! It is this kind of thinking that leads to casually
non-portable code. Just think about what you are saying, you
are saying that if you write

   type x is mod 2 ** 64;
   v : x;

and you know that you are operating on a 64-bit machine where
64-bit reads and writes are indivisible, and further more you
happen to know that the compiler uses these instructions for
reading and writing v, then you need not delare v Atomic
because it is not needed!

The whole point of Atomic is to *check* that your assumption
that reads and writes are atomic is correct. It is not unusual
in an Ada compiler for pragma Atomic to have no effect on the
code that pragma Volatile would not have. THe difference is
that you are asking the compiler to check that on the target
you are using, you will indeed get Atomic access.

So please declare v Atomic in the code above. It will have no
effect on your 64-bit machine, but it will cause your code to
be considered illegal when you port it to a 32-bit machine that
does not support your expectations.

> Atomic replaces Ada 83's pragma Shared. The name 'Shared' was
> confusing, because the pragma was not used to mark variables
> as shared."  I'm not sure how the previous Shared pragma had
> anything to do with indivisiblity or atomicity,

Pleaes read the Ada 83 RM which makes this quite clear.

> however, so I don't see how Atomic
> replaces it.

Because pragma Atomic in Ada 95 means EXACTLY the same
think as pragma Shared in Ada 83. The name change was to
avoid the confusing name (which certainly confused you :-)


Sent via Deja.com
http://www.deja.com/