Re: Ada-Comment proposals (version 3)

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

On 14-07-13 21:16 , Simon Clubley wrote:
> On 2014-07-13, Niklas Holsti <niklas.holsti@tidorum.invalid> wrote:
>> On 14-07-13 19:54 , Simon Clubley wrote:

>>> For an Atomic record, the compiler would generate a Read-Modify-Write
>>> sequence
>>
>> I'm afraid that saying "Read-Modify-Write" may be misunderstood to mean
>> a fully atomic update, ...
> 
> This was one of the things which was discussed with Randy a few days
> ago. At that time, it was made clear by Randy that Atomic, as applied
> to Ada, only ever meant the read was atomic and the write was atomic.
> The overall sequence itself is never considered to be an atomic
> operation.

Exactly, so it is not "read-modify-write" as Wikipedia defines this term
(and as I, too, understand it).

> I'll see about tweaking the language to make that more clearer however.

Good.

>> This brings to mind an interesting question: if the processor has some
>> fully atomic read-modify-write instructions, and the semantics of one of
>> these instructions matches the way the record variable is updated with a
>> partial aggregate, is the compiler allowed to use that read-modify-write
>> instruction? I don't know if such instructions always work with
>> memory-mapped peripheral registers -- for example, their timing in terms
>> of clocks between the read and the write may be different.
>>
> 
> We would have to be _very_ careful here that we didn't introduce
> behaviour which could be platform specific.

I should have been clearer in my comment -- I did not really mean that
this question should be added to this Ada-Comment, rather I meant to ask
if someone knows of examples of peripheral registers for which
read-modify-write instructions do not work.

> For example, we would not want people to write code which didn't
> consider what happens during an interrupt simply because that wasn't
> an issue on the original platform due to the generated code emitted
> by the compiler.

Does this mean that you want to forbid Ada compilers from using
read-modify-write instructions?

It is always possible to write platform-specific code, intentionally or
accidentally. In particular, the execution timing and therefore the
locations of preemptions and interrupts is platform specific. For
example, a shared but unprotected variable may work reliably on one
platform but fail due to race conditions on another. Therefore, I would
let the compiler use read-modify-write instructions if it wants to, and
as long as the ARM is obeyed. I don't see it as an important problem
that this would make the some updates fully atomic on some platforms,
while the same source code result in a non-atomic update on another
platform.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .