Re: Threading in new C++ standard

On Apr 28, 8:42 pm, "Boehm, Hans" <hans.bo...@hp.com> wrote:

Let me put forward that all your problems are coming from the facts
that in C++0x:

(1) you are still going to solve multi-threading at the library level;
and

(2) your only concern is the tuning of the OPTIMISATION of the
compilers which is developed for the SEQUENTIAL execution in the first
place.


You are right: If the adjustments are just made for the shake of
changing the *sequential* optimisation rules of the compiler that
supports the language, it is not very adequate. In that case no matter
how hard you try to adjust, it will always remain to be a sequential
language, i.e. until you address concurrency at the language level.

You say it depends on the concurrent language. Well, a concurrent
language must contain language elements for issues coming from the
concurrent, i.e. simultaneous execution of some parts of the program.
These are:

1) Defining and starting the threads of computation

2) Separating the shared resources and the resources local to a single
process

3) Synchronisation and communication of the simultaneously executed
parts
   3.a) Must provide means for mutual exclusion at the language level
   3.b) Must handle non-determinism at the language level

Item (1): In a procedural language this can be a kind of a parallel
statement, e.g.

parallel S;
else (int i=0..pmax) P(i);
else {Q; L;}
end

In object-oriented languages the threads of computation can be
combined with objects resulting in some form of active objects, see
for instance the language proposal Distributed Processes.
http://brinch-hansen.net/papers/1978a.pdf

If the process is marked at the language level, the compiler can check
whether the process accesses local and shared resources properly.

Item (2): In a procedural language a single keyword like `shared' or
`resource' may help as a property to the types. In object-oriented
languages the natural unit of marking with the shared property is the
class.

If the shared variables are marked, the compiler can check whether the
processes access the shared resources properly, i.e. excluding each
other.

Item (3): In a well designed concurrent language most probably you can
find an adapted form of Dijkstra's Guarded Commands to deal with non-
determinism (see:
http://www.cs.utexas.edu/users/EWD/transcriptions/EWD04xx/EWD418.html)
GC has been already adapted to message communication (see
Communicating Sequential Processes and its language realisation OCCAM)
as well as to shared memory communication (see Edison or Distributed
Processes).
http://brinch-hansen.net/papers/1981b.pdf
http://brinch-hansen.net/papers/1978a.pdf

You can find GC adapted in Ada too.

In an object-oriented language, Guarded Commands could be combined
with classes and Conditional Critical Regions (C. A. R. Hoare, Towards
a Theory of Parallel Programming, 1971), something like this:

shared class A {
  int i, k;
public:
  A() i(0), k(0) {}
  void foo() {
    when (i>10) {
      S;
    }
    else (i > k) {
      P;
    }
    else (k > i) {
      Q;
    }
  }
  ...
};

Class A being a shared class means that private members `i' and `k'
are shared variables and public methods are Critical Regions already.
So without classes, in a C-like language it would look something like
this:

shared int i=0, k=0;
void foo() {
  with (i,k) {
    when (i>10) {
      S;
    }
    else (i > k) {
      P;
    }
    else (k > i) {
      Q;
    }
  }
}

Note that if some notations like the ones shown above are used, the
compiler can easily check whether a shared variable is accessed in a
wrong way or in a proper way.

The compiler can also optimise how it translates a Conditional
Critical Region the most optimal way on a given platform. This is,
however, not sequential optimisation any more. Neither is it about
suppressing sequential optimisations here and there. However,
sequential optimisations can be used unrestricted in parts of the
processes which parts are working on local variables only. In a
concurrent language it is clear to the compiler what parts these are.

What I have shown above are just examples how concurrency can be
addressed at the language level. I am not claiming that you should
exactly include these elements into C++0x. However, I do claim that
you should address concurrent programming at the language level in C+
+0x otherwise C++ will lag behind in concurrent programming.

Now, as you can see:

Concurrency library + adjusted sequential language != concurrent
language

Quod erat demonstrandum

Best Regards,
Szabolcs