Parallel procedures/de: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Übersicht
2	2
3	3		Diese Seite beschreibt, wie man eine einzelne Prozedur parallel laufen lässt unter Benutzung der MTProcs Unit, die das parallel laufen lassen und die Implementierung von parallelen Algorithmen vereinfacht.
4	4
5	5		Parallele Prozeduren und Methoden werden oft in parallele Algorithmen gefunden und einige Programmiersprachen haben einen eingebauten Support für sie (z.B. OpenMP im gcc). Siehe auch [[OpenMP support\|hier]] für die Planung der Hinzufügung dieser Sprachfeatures im FPC. Einbetten dieser Sachen in die Sprache kann zur Reduzierung von Eingaben führen und erlaubt dem Compiler Code zu erzeugen, der weniger Overhead hat. Auf der anderen Seite ist hier kein einfacher Algorithmus, um Code parallel laufen zu lassen. Tatsächlich machen einfache Versuche oft den Code langsamer. Um gute Resultate zu erhalten, muss man einige Parameter spezifizieren, die der Compiler nicht voraussagen kann. Als Beispiel kann man sich die unermessliche Anzahl an Einstellungen und Diskussionen auf [OpenMP](http://openmp.org/wp/) ansehen. Man benötigt parallele Algorithmen. MTProcs hilft bei der Implementierung von parallelen Algorithmen.
6	6
7	7		## MTProcs erhalten
8	8
9	9		Die Unit mtprocs.pas ist ein Teil des multithreadprocslaz.lpk Paket, das mittels svn von
10	10
11	11		svn co https://lazarus-ccr.svn.sourceforge.net/svnroot/lazarus-ccr/components/multithreadprocs multithreadprocs
12	12
13	13		heruntergeladen werden kann.
14	14
15	15		Wie immer: Öffne das Paket multithreadprocslaz.lpk einmal in der IDE, so das es die Pfade lernt. Um das Paket in deinem Projekt zu verwenden: Benutze IDE Menu / Package / Open recent package / .../multithreadprocslaz.lpk / More / add to project um es in deinem aktuellen Projekt zu verwenden. Oder füge mittels des Projekt Inspektors hinzu.
16	16
17	17		## Einfaches Beispiel
18	18
19	19		Hier ist ein einfaches Beispiel, das nichts wirklich sinnvolles macht, um zu zeigen, wie parallele Prozeduren aussehen und wie sie aufgerufen werden:
20	20
21	21		``` pascal
22	22		program Test;
23	23
24	24		{$mode objfpc}{$H+}
25	25
26	26		uses
27	27		{$IFDEF UNIX}
28	28		cthreads, cmem,
29	29		{$ENDIF}
30	30		MTProcs;
31	31
32	32		// a simple parallel procedure
33	33		procedure DoSomethingParallel(Index: PtrInt; Data: Pointer; Item: TMultiThreadProcItem);
34	34		var
35	35		i: Integer;
36	36		begin
37	37		WriteLn(Index);
38	38		for i := 1 to Index * 1000000 do ; // do some work
39	39		end;
40	40
41	41		begin
42	42		ProcThreadPool.DoParallel(@DoSomethingParallel, 1, 5, nil); // address, startindex, endindex, optional data
43	43		end.
44	44		```
45	45
46	46		Die Ausgabe wird ähnlich wie folgendes sein:
47	47
48	48		2
49	49		3
50	50		1
51	51		4
52	52		5
53	53
54	54		Hier einige kurze Anmerkungen. Die Details folgen später
55	55
56	56		- Multithreading benötigt unter Unix die Unit cthreads wie im [[Multithreaded Application Tutorial/de]] erklärt.
57	57		- Aus Geschwindigkeitsgründen wird der cmem Heapmanager empfohlen, aber hier für dieses Beispiel macht es keinen Unterschied.
58	58		- Die parallele Procedure DoSomethingParallelerhält einige fixe und vordefinierte Parameter.
59	59		- Index definiert, welcher Teil der Arbeit in diesem Aufruf gemacht werden soll.
60	60		- Data ist ein Zeiger, der ProcThreadPool.DoParallel als vierter Parameter übergeben wird. Er ist optional und man ist frei, ob man ihn für irgendwas benutzt.
61	61		- Item kann für den Zugriff auf mehr verfeinerte Features des Threadpools verwendet werden.
62	62		- ProcThreadPool.DoParallel arbeitet wie ein normaler Proceduraufruf. Er kommt zurück, wenn er komplett abgearbeitet wurde - das heißt, alle Threads haben ihre Arbeit beendet.
63	63		- Die Ausgabe zeigt den typischen multithreading Fall: Die Reihenfolge der Aufrufe ist nicht vorhersehbar. Verschieden Läufe können Ergebnisse in unterschiedlicher Reihenfolge haben.
64	64
65	65		## Features
66	66
67	67		Running a procedure in parallel means:
68	68
69	69		- a procedure or method is executed with an Index running from an arbitrary StartIndex to an arbitrary EndIndex.
70	70		- One or more threads execute these index' in parallel. For example if the Index runs from 1 to 10 and there are 3 threads available in the pool, 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 3,5,7, thread 2 executes 1,6,8,9 and thread 3 runs 2,4,10.
71	71		- 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 thread itself.
72	72		- The maximum number of threads is initialized with a good guess for the current system. It can be manually set at any time via
73	73
74		-	~~` ProcThreadPool.MaxThreadCount:=8;`~~
	74	+	``` pascal
	75	+	ProcThreadPool.MaxThreadCount:=8;
	76	+	```
75	77
76	78		- You can set the maximum threads for each procedure.
77	79		- A parallel procedure (or method) can call recursively parallel procedures (or methods).
78	80		- Threads are reused, that means they are not destroyed and created for each index, but there is a global pool of threads. On a dual core processor there will be two threads doing all the work - the main thread and one extra thread in the pool.
79	81
80	82		## Overhead, slow down
81	83
82	84		The overhead heavily depends on the system (number and types of cores, type of shared memory, speed of critical sections, cache size). Here are some general hints:
83	85
84	86		- Each chunk of work (index) should take at least some milliseconds.
85	87		- The overhead is independent of recursive levels of parallel procedures.
86	88
87	89		Multi threading overhead, which is independent of the MTProcs units, but simply results from todays computer architectures:
88	90
89	91		- As soon as one thread is created your program becomes multi threaded and the memory managers must use critical sections, which slows down. So even if you do nothing with the thread your program might become slower.
90	92		- The cmem heap manager is on some systems much faster for multi threading. In my benchmarks especially on intel systems and especially under OS X the speed difference can be more than 10 times.
91	93		- Strings and interfaces are globally reference counted. Each access needs a critical section. Processing strings in multiple threads will therefore hardly give any speed up. Use PChars instead.
92	94		- Each chunk of work (index) should work on a disjunctive part of memory to avoid cross cache updates.
93	95		- Do not work on vast amounts of memory. On some systems one thread alone is fast enough to fill the memory bus speed. When the memory bus maximum speed is reached, any further thread will slow down instead of making it faster.
94	96
95	97		## Setting the maximum number of threads for a procedure
96	98
97	99		You can specify the maximum number of threads for a procedure as the fifth parameter.
98	100
99	101		``` pascal
100	102		begin
101	103		ProcThreadPool.DoParallel(@DoSomethingParallel, 1, 10, nil, 2); // address, startindex, endindex,
102	104		// optional: data (here: nil), optional: maximum number of threads (here: 2)
103	105		end.
104	106		```
105	107
106	108		This can be useful, when the threads work on the same data, and a too many threads will create so many cache conflicts, that they slow down each other. Or when the algorithm uses a lot of WaitForIndex, so that only a few threads can actually work. Then the threads can be used for other tasks.
107	109
108	110		## Wait for index / executing in order
109	111
110	112		Sometimes an Index depends on the result of a former Index. For example a common task is to first compute chunk 5 and then combine the result with the result of chunk 3. Use the WaitForIndex method for that:
111	113
112	114		``` pascal
113	115		procedure DoSomethingParallel(Index: PtrInt; Data: Pointer; Item: TMultiThreadProcItem);
114	116		begin
115	117		... compute chunk number 'Index' ...
116	118		if Index = 5 then begin
117	119		if not Item.WaitForIndex(3) then exit;
118	120		... compute ...
119	121		end;
120	122		end;
121	123		```
122	124
123	125		WaitForIndex takes as an argument an Index that is lower than the current Index or a range. If it returns true, everything worked as expected. If it returns false, then an exception happened in one of the other threads.
124	126
125	127		## Exceptions
126	128
127	129		If an exception occur in one of the threads, the other threads will finish normally, but will not start a new Index. The pool waits for all threads to finish and will then raise the exception. That's why you can use try..except like always:
128	130
129	131		``` pascal
130	132		try
131	133		...
132	134		ProcThreadPool.DoParallel(...);
133	135		...
134	136		except
135	137		On E: Exception do ...
136	138		end;
137	139		```
138	140
139	141		If there are multiple exceptions, only the first exception will be raised. To handle all exceptions, add a try..except inside your parallel method.
140	142
141	143		---
142	144		From the Free Pascal wiki, page "Parallel procedures/de", as it stood on 2020-02-23 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history