Re: Robert Dewar's great article about the Strengths of Ada over other langauges in multiprocessing!

[gpriv@axonx.com]

On Mar 12, 9:33 am, Maciej Sobczak <see.my.homep...@gmail.com> wrote:
> On 12 Mar, 01:32, gp...@axonx.com wrote:
>
> > VTab is virtual call table, created when class has at least one
> > virtual function. That will make it similar to tagged record.
> > Otherwise it will be similar to a plain Ada record and destructor may
> > be inlined.
>
> In C++ destructor can be inlined *always*, unless the object is
> deleted via pointer to base. In other words, objects with automatic or
> static storage duration (local, static and global) objects can have
> inlined destructors - no matter whether it is virtual or not.

Yes if compiler can make that determination at compile time.  If not
it will dispatch via VTab. My point was to compare make all the
conditions equal.  After all you may consider generic model for Ada
which eliminate all the dispatch overhead.

>
> > With C++ to be totally multicore thread safe, you need to make
> > "volatile" all the data that has any possibility to be accessed from
> > different threads.
>
> Absolutely incorrect.
> In C and C++ "volatile" has nothing to do with threads. It is neither
> necessary nor sufficient.
>
> > Otherwise, you may get incorrect readings once in a while.
>
> "volatile" does not prevent it.
>
> > Few years
> > back I spent months chasing these misreadings when moved heavily
> > mullti-threded app to multi-core.
>
> You still have some months of chasing ahead. :-)
> Start with removing all "volatile" keywords from your code. Then make
> it right.
>
> --
> Maciej Sobczak *www.msobczak.com*www.inspirel.com

Definition of volatile:

The volatile keyword is a type qualifier used to declare that an
object can be modified in the program by something such as the
operating system, the hardware, or a concurrently executing thread.



Consider the multi-core execution of two concurrent threads.  One will
modify a variable, another will read.  One will keep the variable in
the register, another will reload it from the memory.  Volatile will
force flushing to the memory. Otherwise thread 2 will read erroneous
data.