Maximum Number Of Tasks?

Maximum Number Of Tasks?

[FritzVonBraun]

I was wondering about the maximum number of tasks in Ada but I couldnt 
find any info. The question is, is a task in Ada technically similar to 
a thread in Windows under the hood? Threads are restricted by the stack 
size that each thread has reserved, so in practice the maximum number of 
threads is about 2000.

The reason I'm asking is that I wonder if Ada provides a more 
comfortable solution to the thread pool problem. In C++ for example I 
create a number of threads roughly equal to the number of processor 
cores and then have a number of Jobs that are distributed over the 
threads and which implement a time sharing system by returning control 
to the thread which then assigns time to another Job.

Would I have to do the same in Ada or are tasks meant to be "micro 
objects' of which many can be created and the Ada runtime does 
effectively what my threadpool system does in C++

Thanks for any info

Re: Maximum Number Of Tasks?

[Jacob Sparre Andersen]

FritzVonBraun wrote:

> I was wondering about the maximum number of tasks in Ada but I couldnt
> find any info.

Probably because it is both compiler, hardware and operating system
dependent.

> The question is, is a task in Ada technically similar to a thread in
> Windows under the hood?

That depends on which compiler you use.  Some (most?) versions of GNAT
use operating system threads to implement tasks.  Janus/Ada implements
tasks in its own run-time system.

> Threads are restricted by the stack size that each thread has
> reserved, so in practice the maximum number of threads is about 2000.

I just made a quick test on my laptop.  It appears that I can create
32041 tasks before I have to do something special to avoid problems.

The test was done on a Debian 7.2 system with the GNAT 4.6 compiler
distributed with Debian.

The test program:

with Ada.Text_IO; use Ada.Text_IO;

procedure Task_Demo is
   task type Demo_Task (Index : Positive) is
      entry Stop;
   end Demo_Task;
   type Demo_Task_Reference is access Demo_Task;

   task body Demo_Task is
   begin
      Put_Line (Positive'Image (Index) & " launched.");
      accept Stop;
      Put_Line (Positive'Image (Index) & " stopping.");
   exception
      when others =>
         Put_Line (Positive'Image (Index) & " terminated by an exception.");
   end Demo_Task;

   Collection : array (1 .. 32_041) of Demo_Task_Reference;
begin
   for I in Collection'Range loop
      Collection (I) := new Demo_Task (Index => I);
   end loop;

   delay 1.0;

   for I in Collection'Range loop
      Collection (I).Stop;
   end loop;
end Task_Demo;

Reducing the stack size for the individual tasks does not seem to make a
difference.

> The reason I'm asking is that I wonder if Ada provides a more
> comfortable solution to the thread pool problem. In C++ for example I
> create a number of threads roughly equal to the number of processor
> cores and then have a number of Jobs that are distributed over the
> threads and which implement a time sharing system by returning control
> to the thread which then assigns time to another Job.
>
> Would I have to do the same in Ada or are tasks meant to be "micro
> objects' of which many can be created and the Ada runtime does
> effectively what my threadpool system does in C++

That depends on your compiler.

Greetings,

Jacob
-- 
"Two silk worms had a race. They ended up in a tie."

Re: Maximum Number Of Tasks?

[Georg Bauhaus]

On 12.11.13 10:53, FritzVonBraun wrote:
> I was wondering about the maximum number of tasks in Ada but I couldnt find
> any info. The question is, is a task in Ada technically similar to a thread in
> Windows under the hood? Threads are restricted by the stack size that each
> thread has reserved, so in practice the maximum number of threads is about 2000.
> 
> The reason I'm asking is that I wonder if Ada provides a more comfortable
> solution to the thread pool problem. In C++ for example I create a number of
> threads roughly equal to the number of processor cores and then have a number
> of Jobs that are distributed over the threads and which implement a time
> sharing system by returning control to the thread which then assigns time to
> another Job.

If you have jobs that do not require intermittent communication among
them, then in particular, I'd be sure to have a look at the Paraffin
library. http://paraffin.sourceforge.net/

As an example of a different setup, I have seen a program that had
the number of tasks be about 4x that of processors; all ran at the
"same" time and the number of tasks was suggested by the program's
logic, not by either hardware or OS.
Load distribution seemed very well handled (GNAT on GNU/Linux in this
case), 4 x #CPU was a sweet spot regarding the number of tasks.

Re: Maximum Number Of Tasks?

[mockturtle]

On Tuesday, November 12, 2013 10:53:53 AM UTC+1, FritzVonBraun wrote:
> I was wondering about the maximum number of tasks in Ada but I couldnt 
> find any info. The question is, is a task in Ada technically similar to 
> a thread in Windows under the hood? Threads are restricted by the stack 
> size that each thread has reserved, so in practice the maximum number of 
> threads is about 2000.
> 

I remember that I saw at FOSDEM 2013 in the "Ada Developer Room" a demo that plotted a Mandelbrot set by using a matrix of tasks.  A participant asked then "can you do that with 10_000 tasks?"  The size of the matrix was changed to 100 x 100 and everything worked smoothly; so, in that case you could create at least 10_000 tasks.  The PC was a laptop running some kind of Linux + GNAT, if I remember correctly.

Riccardo

Re: Maximum Number Of Tasks?

[Jeffrey Carter]

On 11/12/2013 02:53 AM, FritzVonBraun wrote:
>
> Would I have to do the same in Ada or are tasks meant to be "micro objects' of
> which many can be created and the Ada runtime does effectively what my
> threadpool system does in C++

Tasks should reflect inherent concurrency in the problem space, not some aspect 
of the hardware or OS. I have never encountered any problem following this rule, 
whether it was 60-70 Ada-83 tasks on a 640 KB DOS system in the 1980s or 
hundreds of tasks on Linux this year.

-- 
Jeff Carter
"We call your door-opening request a silly thing."
Monty Python & the Holy Grail
17

Re: Maximum Number Of Tasks?

[Dmitry A. Kazakov]

On Tue, 12 Nov 2013 08:54:18 -0700, Jeffrey Carter wrote:

> On 11/12/2013 02:53 AM, FritzVonBraun wrote:
>>
>> Would I have to do the same in Ada or are tasks meant to be "micro objects' of
>> which many can be created and the Ada runtime does effectively what my
>> threadpool system does in C++

If you have native tasking then tasks are as fat as threads. If you have
tasking implemented within one thread (rare), tasks can be "micro", but
then they most likely will be unable to perform I/O concurrently.

> Tasks should reflect inherent concurrency in the problem space, not some aspect 
> of the hardware or OS.

It is not that simple. The problem space may encompass the hardware, e.g.
in the case of communication and services. Which is typically the case when
worker tasks pool comes in question.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Maximum Number Of Tasks?

[Ludovic Brenta]

mockturtle writes:
> On Tuesday, November 12, 2013 10:53:53 AM UTC+1, FritzVonBraun wrote:
>> I was wondering about the maximum number of tasks in Ada but I couldnt 
>> find any info. The question is, is a task in Ada technically similar to 
>> a thread in Windows under the hood? Threads are restricted by the stack 
>> size that each thread has reserved, so in practice the maximum number of 
>> threads is about 2000.
>> 
>
> I remember that I saw at FOSDEM 2013 in the "Ada Developer Room" a
> demo that plotted a Mandelbrot set by using a matrix of tasks.  A
> participant asked then "can you do that with 10_000 tasks?"  The size
> of the matrix was changed to 100 x 100 and everything worked smoothly;
> so, in that case you could create at least 10_000 tasks.  The PC was a
> laptop running some kind of Linux + GNAT, if I remember correctly.
>
> Riccardo

Yes, you remember correctly; I was the one doing that demo :)

That's because the Linux kernel allocates virtual address space to each
task but does not allocate any physical memory (RAM or swap) unless and
until the task writes to memory (i.e. creates variables on its stack).
Even then, Linux only allocates the pages actually written to, not the
full 2 MiB (or whatever the default is) per task.

After the demo, I re-ran the program at home and saw it allocate 19.8
GiB of virtual address space (I re-checked just now) and thought: gosh
am I lucky I've been running 64-bit Linux since 2006 :)

-- 
Ludovic Brenta.

Re: Maximum Number Of Tasks?

[Ludovic Brenta]

Ludovic Brenta <ludovic@ludovic-brenta.org> writes:

> mockturtle writes:
>> On Tuesday, November 12, 2013 10:53:53 AM UTC+1, FritzVonBraun wrote:
>>> I was wondering about the maximum number of tasks in Ada but I couldnt 
>>> find any info. The question is, is a task in Ada technically similar to 
>>> a thread in Windows under the hood? Threads are restricted by the stack 
>>> size that each thread has reserved, so in practice the maximum number of 
>>> threads is about 2000.
>>> 
>>
>> I remember that I saw at FOSDEM 2013 in the "Ada Developer Room" a
>> demo that plotted a Mandelbrot set by using a matrix of tasks.  A
>> participant asked then "can you do that with 10_000 tasks?"  The size
>> of the matrix was changed to 100 x 100 and everything worked smoothly;
>> so, in that case you could create at least 10_000 tasks.  The PC was a
>> laptop running some kind of Linux + GNAT, if I remember correctly.
>>
>> Riccardo
>
> Yes, you remember correctly; I was the one doing that demo :)
>
> That's because the Linux kernel allocates virtual address space to each
> task but does not allocate any physical memory (RAM or swap) unless and
> until the task writes to memory (i.e. creates variables on its stack).
> Even then, Linux only allocates the pages actually written to, not the
> full 2 MiB (or whatever the default is) per task.
>
> After the demo, I re-ran the program at home and saw it allocate 19.8
> GiB of virtual address space (I re-checked just now) and thought: gosh
> am I lucky I've been running 64-bit Linux since 2006 :)

Oh and by the way, I will introduce task pools in my demo at FOSDEM 2014
:)

-- 
Ludovic Brenta.

Re: Maximum Number Of Tasks?

[Marius Amado-Alves]

Ada has a pragma to define the memory size associated with a task.
I've used this to good effect with GNAT on Windows and Macs.

Re: Maximum Number Of Tasks?

[Brad Moore]

On 12/11/2013 5:52 AM, Georg Bauhaus wrote:
> On 12.11.13 10:53, FritzVonBraun wrote:
>> I was wondering about the maximum number of tasks in Ada but I couldnt find
>> any info. The question is, is a task in Ada technically similar to a thread in
>> Windows under the hood? Threads are restricted by the stack size that each
>> thread has reserved, so in practice the maximum number of threads is about 2000.
>>
>> The reason I'm asking is that I wonder if Ada provides a more comfortable
>> solution to the thread pool problem. In C++ for example I create a number of
>> threads roughly equal to the number of processor cores and then have a number
>> of Jobs that are distributed over the threads and which implement a time
>> sharing system by returning control to the thread which then assigns time to
>> another Job.
>
> If you have jobs that do not require intermittent communication among
> them, then in particular, I'd be sure to have a look at the Paraffin
> library. http://paraffin.sourceforge.net/
>

Paraffin has had several flavours of task pools implemented for some 
time now. You can do as you suggest and have a task pool that has the 
same number of tasks as there are cores in your system, and distribute 
work across these tasks.

There are three main "flavours" of task pool.

1) No pool at all, just allocate workers on the fly and distribute work 
across the set of workers
2) A task pool that can be dynamically (or statically) created that 
contains a bounded (or unbounded) number of workers that can be applied 
to any number of parallelism opportunities. These task pools allow a 
worker to migrate to cores, if the OS supports migration (eg. Windows 
and Linux)
3) A Ravenscar compliant task pool that is more suitable for real time, 
where the workers must be statically allocated to cores, and cannot migrate.

To see a demo of these task pools, you could try running the
test_parallel_loops or test_parallel_recursion executables that are 
included with the source for Paraffin.

To see the Ravenscar version of these task pools, you would need to
execute the test_ravenscar_parallel_loops and 
test_ravenscar_parallel_recursion examples.

Rather surprisingly, there is not a significant difference between these 
three task pool models. In general using a task pool will give
a slight edge in performance over creating workers on the fly, but the 
difference is barely noticeable in these examples.

Also, intermittent communication between the workers is OK, as long as
the communication has the necessary safeguards.

For instance you could have several workers performing some lengthy 
calculation, that briefly writes some value to an IO port. If the
IO port was wrapped in a protected object, it may make sense to allow
the multiple workers to access this protected object to perform I/O.

Brad.