Re: GNAT and Tasklets

[vincent.diemunsch@gmail.com]

> >> 
> > What is a "physical task" and a "logical task" ?
> > For me :
> > - a task is a "logical task", because it is a concept of the Ada langage.
> > - a thread is what you call a "physical task", because it is an OS feature.
> 
> RM mingles task and thread:
> 
> "The execution of an Ada program consists of the execution of one or more
> tasks. Each task represents a separate thread of control that proceeds
> independently and concurrently between the points where it interacts with
> other tasks." RM 9(1)
> 
> Your "thread" is an implementation of a task.
> 

I agree that a thread is an implementation of the logical concept of a task, and
that is how I understand the above sentence of the RM that you quote. But, there are different threads :

- a kernel thread is created and scheduled by the kernel, with great power and also great cost (kernel memory and high overhead for context switch). But it allows the use of different CPU (multicore) and the use of concurrent processes even by time slicing. Basically this is an abstraction of a CPU.
 
- a user-level thread is created and scheduled inside the process by the runtime, it is much faster and lighter, but is less powerful : typically time slicing is not supported and threads need to cooperate more. User-level threads are often multiplexed on one or more kernel threads.

- finaly jobs, executed on a pool of workers (kernel threads) provide very lightweight threads.

All are threads, each class of them corresponding to a level of complexity of an Ada task : Library level, permanent tasks are typically kernel threads, Library level dynamic tasks created on demand are typically user-level threads, and little local task, needed for a parallel computation are often simple jobs.

And if the compiler chose only one implementation, like always a kernel thread for a task, which is the case now, I have to say that it is not a mature implementation of tasking.

Finaly, I really hope that the new version of the langage will keep Ada simple and add "intelligence" in compilers and not add different new features with :
- tasks for kernel threads
- coroutines or tasklets for user-level threads
- jobs for lightweight threads,
because this would be a major conceptual regression. I believe that aspects on tasks could be an inelegant but decent way to solve the problem.

Regards,

Vincent