Safety of unprotected concurrent operations on constant objects

[Natasha Kerensikova <lithiumcat@instinctive.eu>]

Hello,

sorry to bother you again, but I got lost again in the RM looking for
what I thought was a simple answer to a simple question:

Is it safe to have many tasks performing operations concurrently on
constant objects?


The RM seems only to say things about operations on shared variables
(e.g. in 9.10), which are understandably unsafe (but the guarantee of
safe access to non-overlapping shared variables is a nice once). But
what about concurrent private (presumably read) operations on constants?

It seems obvious that there should be no harm in concurrent reading of
memory, and therefore on concurrent operations on "simple" values, like
scalars or untagged records.

But are there any guarantee on the safety of hidden mechanisms, like tag
checks or dispatching or the implementation of standard containers?
Or could a conforming implementation use internally a splay tree and
make it so that operations on objects declared constant, and indeed
semantically constant, are task-unsafe?


Thanks again for your help,
Natasha