Re: Safety of unprotected concurrent operations on constant objects

[Natasha Kerensikova <lithiumcat@instinctive.eu>]

On 2014-05-05, Brad Moore <brad.moore@shaw.ca> wrote:
>   The implementation shall ensure that each language-defined subprogram 
> is reentrant in the sense that concurrent calls on any language-defined 
> subprogram perform as specified, so long as all parameters that could be 
> passed by reference denote nonoverlapping objects.

OK, so any concurrent access of an object through standard subprograms
is unsafe.

> Another relevant RM paragraph is;
>
> RM 9.10(11-15) which starts;
>
> "Given an action of assigning to an object, and an action of reading or 
> updating a part of the same object (or of a neighboring object if the 
> two are not independently addressable), then the execution of the 
> actions is erroneous unless the actions are sequential."

And any write makes anything else unsafe on the same object.


Now the question is, what about the rest?

Does it mean any concurrent reads of the same object, without involving
any subprogram call, is safe?

At least RM 9.10 strongly implies that array indexing is task-safe.

But what about dereferencing an access value? Is it safe to concurrently
dereference the same access value from multiple tasks?

It's hard to imagine dereferencing a pointer to be unsafe, but as we all
know access are more than mere pointers, with accessibility checks and
custom storage pools and what not.

By the way, are implicit subprograms calls, like the storage pool thing
on dereference, also covered by the non-guarantee of concurrent read safety?