Re: question about tasks, multithreading and multi-cpu machines

[Maciej Sobczak <no.spam@no.spam.com>]

Dmitry A. Kazakov wrote:

> Hmm, if task type is a type [...]

Why *should* it be a type in the first place? :)

> What could be an alternative?

The difference between sequential and paraller execution of two 
instructions (or blocks of instructions, but that's obvious) should be 
addressed at the level of control structures, not types (nor objects).
This means that if I want to have these:

A := 7;
B := 8;

executed sequentially, then I write them sequentially - just like above 
(I already see posts claiming that the compiler or CPU can reorder these 
instructions, but that's not the point; if the instructions have 
side-effects, then the sequence is really a sequence and I'm talking 
about expressing the programmer's intents here).
Executing those two instructions in paraller should not require from me 
to define new types, allocate new objects, nor any other thing like 
this. Think about it in terms of UML activity diagrams. The difference 
between sequential and paraller execution is just a plain syntax issue, 
without introducing any additional and dedicated entities. The same 
should be possible on the level of source code - especially if we take 
into account that diagrams and source code should be just two ways to 
say the same thing.

I have no serious thoughts about Ada in this aspect - for the simple 
reason that I'm learning Ada and I don't know where my reasoning could 
possibly break. However, for your amusement, you might take a look at 
the small article that I wrote about the same thing but w.r.t. C++:

http://www.msobczak.com/prog/articles/threadscpp.html

Just changing curly brackets to "begin" and "end" might not be enough, 
but you should get the idea.

In short, the point is that concurrency should be handled at the level 
of control statements, without requiring any additional entities (type, 
object, etc.) for reasons other than communication and synchronization.

Only then I'm ready to admit that the given language has a *built-in* 
support for concurrency. :)


-- 
Maciej Sobczak : http://www.msobczak.com/
Programming    : http://www.msobczak.com/prog/