Parallel procedures

Overview

This page describes how to run single procedures in parallel using the MTProcs unit. Parallel procedures and methods are often found in parallel algorithms and some languages provide built-in support for them (e.g. OpenMP in gcc). See here for the plans adding such language features to FPC. This page describes parallel procedures using the unit MTProcs, which simplifies running procedures in parallel.

First example

Here is a short example:

<Delphi> program Test;

{$mode objfpc}{$H+}

uses

 {$IFDEF UNIX}
 cthreads, cmem,
 {$ENDIF}
 MTProcs;

// a simple parallel procedure procedure DoSomethingParallel(Index: PtrInt; Data: Pointer; Item: TMultiThreadProcItem); var

 i: Integer;

begin

 writeln(Index);
 for i:=1 to Index*1000000 do ; // do some work

end;

begin

 ProcThreadPool.DoParallel(@DoSomethingParallel,1,10,nil); // address, startindex, endindex, optional data

end. </Delphi>

The output will be something like this:

2
3
1
4
5

Features

Running a procedure in parallel means:

• a procedure or method is executed with an Index running from an arbitrary StartIndex to an arbitrary EndIndex.
• One or more threads execute these index' in parallel. For example if the Index runs from 1 to 10, then 3 threads will run three different index at the same time. Every time a thread finishes one call (one index) it allocates the next index and runs it. The result may be: Thread 1 executes index 0,5,7, thread 2 executes 1,3,8,9 and thread 3 runs 2,4,10.
• The number of threads may vary during run and there is no guarantee for a minimum of threads. In the worst case all index will be executed by one thread.
• The maximum number of threads is initialized with a good guess for the current system and can be set via

 ProcThreadPool.MaxThreadCount:=8;

• You can set the maximum threads for each procedure.
• A parallel procedure (method) can call recursively parallel procedures (methods).
• Threads are reused, that means they are not destroyed and created for each index or for each procedure, but there is a global pool of threads. On a today common dual core processor there will be two threads doing all the work.