SSE/de: what changed

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

Old	New		Line
1	1		## SSE
2	2
3	3		Mit der SSE-Erweiterung der Modernen CPUs, kann bis zu 8-9fache Geschwindigkeitssteigerung erzielen, gegenüber klassischen FPU-Operationen.
4	4
5	5		Am besten werden 4x Vektoren und 4x4 Matrizen unterstützt, dies wird sehr viel bei OpenGL gebraucht.
6	6
7	7		Die Assembler-Blöcke sind so angepasst, das sie auf 32Bit und 64Bit CPU laufen, vorausgesetzt, sie sind Intel kompatibel ARM (Raspberry) geht nicht, die haben einen anderen Befehlssatz.
8	8
9	9		Folgende Beispiele sollten alle ab Intel-Core laufen.
10	10
11	11		Teilweise, kann Lazarus von Haus auf SSE und AVX verwenden, dafür muss folgendes unter "Projekt --\> Projekteinstellungen... --\> Benutzerdefinierte Einstellungen" ergänzt werden:
12	12
13	13		-al
14	14		-CfAVX2
15	15		-CpCOREAVX2
16	16		-O3
17	17		-Sv
18	18		-OpCOREAVX2
19	19		-OoFASTMATH
20	20
21	21		Dies hat auf die direkten Assembler Funktionen keinen Einfluss.
22	22
23	23		### Hilfs- Deklarationen und Funktionen
24	24
25	25		``` pascal
26	26		{$asmmode intel}
27	27
28	28		type
29	29		TVector4f = array[0..3] of Single;
30	30		TMatrix = array[0..3] of TVector4f;
31	31
32	32		var
33	33		a: TVector4f = (1.0, 2.0, 3.0, 4.0);
34	34		b: TVector4f = (5.0, 6.0, 7.0, 8.0);
35	35		c: TVector4f;
36	36		f: single = 2.0;
37	37
38	38		procedure WriteVector(v: TVector4f);
39	39		begin
40	40		WriteLn(v[0]: 8: 4, ' ', v[1]: 8: 4, ' ', v[2]: 8: 4, ' ', v[3]: 8: 4);
41	41		end;
42	42		```
43	43
44	44		### Die wichtigsten Vektor-Operationen
45	45
46	46		#### Vektoren Addieren
47	47
48	48		Klassisch:
49	49
50	50		``` pascal
51	51		Result[0] := v0[0] + v1[0];
52	52		Result[1] := v0[1] + v1[1];
53	53		Result[2] := v0[2] + v1[2];
54	54		Result[3] := v0[3] + v1[3];
55	55		```
56	56
57	57		SSE beschleunigt:
58	58
59	59		``` pascal
60	60		function Vec_Add(const v0, v1: TVector4f): TVector4f; assembler; nostackframe; register;
61	61		asm
62	62		Movups Xmm0, [v0]
63	63		Movups Xmm1, [v1]
64	64		Addps Xmm1, Xmm0
65	65		Movups [Result], Xmm1
66	66		end;
67	67		```
68	68
69	69		#### Vektoren Subtrahieren
70	70
71	71		Klassisch:
72	72
73	73		``` pascal
74	74		Result[0] := v0[0] - v1[0];
75	75		Result[1] := v0[1] - v1[1];
76	76		Result[2] := v0[2] - v1[2];
77	77		Result[3] := v0[3] - v1[3];
78	78		```
79	79
80	80		SSE beschleunigt:
81	81
82	82		``` pascal
83	83		function Vec_Add(const v0, v1: TVector4f): TVector4f; assembler; nostackframe; register;
84	84		asm
85	85		Movups Xmm0, [v0]
86	86		Movups Xmm1, [v1]
87	87		Subps Xmm1, Xmm0
88	88		Movups [Result], Xmm1
89	89		end;
90	90		```
91	91
92	92		#### Vektoren Multiplizieren
93	93
94	94		Klassisch:
95	95
96	96		``` pascal
97	97		Result[0] := v0[0] * v1[0];
98	98		Result[1] := v0[1] * v1[1];
99	99		Result[2] := v0[2] * v1[2];
100	100		Result[3] := v0[3] * v1[3];
101	101		```
102	102
103	103		SSE beschleunigt:
104	104
105	105		\<syntaxhighlight lang="pascal\> function Vec_Add(const v0, v1: TVector4f): TVector4f; assembler; nostackframe; register; asm
106	106
107	107		` Movups Xmm0, [v0]`\
108	108		` Movups Xmm1, [v1]`\
109	109		` Mulps Xmm1, Xmm0`\
110	110		` Movups [Result], Xmm1 `
111	111
112	112		end;
113	113
114		-	~~</syntaxhighlight>~~
115		-
116	114		#### Vektoren Dividieren
117	115
118	116		Klassisch:
119	117
120	118		``` pascal
121	119		Result[0] := v0[0] / v1[0];
122	120		Result[1] := v0[1] / v1[1];
123	121		Result[2] := v0[2] / v1[2];
124	122		Result[3] := v0[3] / v1[3];
125	123		```
126	124
127	125		SSE beschleunigt:
128	126
129	127		``` pascal
130	128		function Vec_Add(const v0, v1: TVector4f): TVector4f; assembler; nostackframe; register;
131	129		asm
132	130		Movups Xmm0, [v0]
133	131		Movups Xmm1, [v1]
134	132		Divps Xmm1, Xmm0
135	133		Movups [Result], Xmm1
136	134		end;
137	135		```
138	136
139	137		#### Vektoren Tauschen
140	138
141	139		Klassisch:
142	140
143	141		``` pascal
144	142		Result[0] := v[3];
145	143		Result[1] := v[2];
146	144		Result[2] := v[1];
147	145		Result[3] := v[0];
148	146		```
149	147
150	148		SSE beschleunigt:
151	149
152	150		``` pascal
153	151		function Vec_Swap(const v: TVector4f): TVector4f; assembler; nostackframe; register;
154	152		asm
155	153		Movups Xmm0, [v]
156	154		Pshufd Xmm1,Xmm0, $1b
157	155		Movups [Result], Xmm1
158	156		end;
159	157		```
160	158
161	159		#### Vektoren Skalieren
162	160
163	161		Klassisch:
164	162
165	163		``` pascal
166	164		Result[0] := v[0] * f;
167	165		Result[1] := v[1] * f;
168	166		Result[2] := v[2] * f;
169	167		Result[3] := v[3] * f;
170	168		```
171	169
172	170		SSE beschleunigt:
173	171
174	172		``` pascal
175	173		function Vec_Multiply_All(const v: TVector4f; f: Single): TVector4f; assembler; nostackframe; register;
176	174		asm
177	175		Movss Xmm0, f
178	176		Pshufd Xmm0, Xmm0, $00
179	177		Movups Xmm1, [v]
180	178		Mulps Xmm1,Xmm0
181	179		Movups [Result], Xmm1
182	180		end;
183	181		```
184	182
185	183		### Beispiele
186	184
187	185		``` pascal
188	186		procedure TForm1.Button1Click(Sender: TObject);
189	187		var
190	188		a: TVector4f = (1.0, 2.0, 3.0, 4.0);
191	189		b: TVector4f = (5.0, 6.0, 7.0, 8.0);
192	190		c: TVector4f;
193	191
194	192		f: single = 2.0;
195	193
196	194		begin
197	195		WriteLn('Addieren');
198	196		c := Vec_Add(a, b);
199	197		WriteVector(c);
200	198		WriteLn();
201	199
202	200		WriteLn('Subtrahieren');
203	201		c := Vec_Sub(b, a);
204	202		WriteVector(c);
205	203		WriteLn();
206	204
207	205		WriteLn('Multipizieren');
208	206		c := Vec_Multiply(b, a);
209	207		WriteVector(c);
210	208		WriteLn();
211	209
212	210		WriteLn('Dividieren');
213	211		c := Vec_Divide(b, a);
214	212		WriteVector(c);
215	213		WriteLn();
216	214
217	215		WriteLn('Vertauschen');
218	216		c := Vec_Swap(a);
219	217		WriteVector(c);
220	218		WriteLn();
221	219
222	220		WriteLn('Alle Multipizieren');
223	221		f := 2.2;
224	222		c:=Vec_Multiply_All(a, f);
225	223		WriteVector(c);
226	224		WriteLn();
227	225
228	226		end;
229	227		```
230	228
231	229		### Vektoren multiplizieren
232	230
233	231		Vektor mit einer Matrix multiplizieren.
234	232
235	233		``` pascal
236	234
237	235		{$asmmode intel}
238	236
239	237		function VectorMultiplySSE(const mat: TMatrix; const vec: TVector4f): TVector4f; assembler; nostackframe; register;
240	238		asm
241	239		Movups Xmm4, [mat + $00]
242	240		Movups Xmm5, [mat + $10]
243	241		Movups Xmm6, [mat + $20]
244	242		Movups Xmm7, [mat + $30]
245	243		Movups Xmm2, [vec]
246	244
247	245		// Zeile 0
248	246		Pshufd Xmm0, Xmm2, 00000000b
249	247		Mulps Xmm0, Xmm4
250	248
251	249		// Zeile 1
252	250		Pshufd Xmm1, Xmm2, 01010101b
253	251		Mulps Xmm1, Xmm5
254	252		Addps Xmm0, Xmm1
255	253
256	254		// Zeile 2
257	255		Pshufd Xmm1, Xmm2, 10101010b
258	256		Mulps Xmm1, Xmm6
259	257		Addps Xmm0, Xmm1
260	258
261	259		// Zeile 3
262	260		Pshufd Xmm1, Xmm2, 11111111b
263	261		Mulps Xmm1, Xmm7
264	262		Addps Xmm0, Xmm1
265	263
266	264		Movups [Result], Xmm0
267	265		end;
268	266		```
269	267
270	268		### Matrizen multiplizieren
271	269
272	270		2 Matrizen mutiplizieren.
273	271
274	272		Für eine Matrix-Multiplikation, hat man mit SSE etwa 8-9fache Geschwindigkeitssteigerung, gegenüber klassichen Single-Multiplikationen.
275	273
276	274		``` pascal
277	275
278	276		{$asmmode intel}
279	277
280	278		function MatrixMultiplySSE(const M0, M1: TMatrix): TMatrix; assembler; nostackframe; register;
281	279		asm
282	280		Movups Xmm4, [M0 + $00]
283	281		Movups Xmm5, [M0 + $10]
284	282		Movups Xmm6, [M0 + $20]
285	283		Movups Xmm7, [M0 + $30]
286	284
287	285		// Spalte 0
288	286		Movups Xmm2, [M1 + $00]
289	287
290	288		Pshufd Xmm0, Xmm2, 00000000b
291	289		Mulps Xmm0, Xmm4
292	290
293	291		Pshufd Xmm1, Xmm2, 01010101b
294	292		Mulps Xmm1, Xmm5
295	293		Addps Xmm0, Xmm1
296	294
297	295		Pshufd Xmm1, Xmm2, 10101010b
298	296		Mulps Xmm1, Xmm6
299	297		Addps Xmm0, Xmm1
300	298
301	299		Pshufd Xmm1, Xmm2, 11111111b
302	300		Mulps Xmm1, Xmm7
303	301		Addps Xmm0, Xmm1
304	302
305	303		Movups [Result + $00], Xmm0
306	304
307	305		// Spalte 1
308	306		Movups Xmm2, [M1 + $10]
309	307
310	308		Pshufd Xmm0, Xmm2, 00000000b
311	309		Mulps Xmm0, Xmm4
312	310
313	311		Pshufd Xmm1, Xmm2, 01010101b
314	312		Mulps Xmm1, Xmm5
315	313		Addps Xmm0, Xmm1
316	314
317	315		Pshufd Xmm1, Xmm2, 10101010b
318	316		Mulps Xmm1, Xmm6
319	317		Addps Xmm0, Xmm1
320	318
321	319		Pshufd Xmm1, Xmm2, 11111111b
322	320		Mulps Xmm1, Xmm7
323	321		Addps Xmm0, Xmm1
324	322
325	323		Movups [Result + $10], Xmm0
326	324
327	325		// Spalte 2
328	326		Movups Xmm2, [M1 + $20]
329	327
330	328		Pshufd Xmm0, Xmm2, 00000000b
331	329		Mulps Xmm0, Xmm4
332	330
333	331		Pshufd Xmm1, Xmm2, 01010101b
334	332		Mulps Xmm1, Xmm5
335	333		Addps Xmm0, Xmm1
336	334
337	335		Pshufd Xmm1, Xmm2, 10101010b
338	336		Mulps Xmm1, Xmm6
339	337		Addps Xmm0, Xmm1
340	338
341	339		Pshufd Xmm1, Xmm2, 11111111b
342	340		Mulps Xmm1, Xmm7
343	341		Addps Xmm0, Xmm1
344	342
345	343		Movups [Result + $20], Xmm0
346	344
347	345		// Spalte 3
348	346		Movups Xmm2, [M1 + $30]
349	347
350	348		Pshufd Xmm0, Xmm2, 00000000b
351	349		Mulps Xmm0, Xmm4
352	350
353	351		Pshufd Xmm1, Xmm2, 01010101b
354	352		Mulps Xmm1, Xmm5
355	353		Addps Xmm0, Xmm1
356	354
357	355		Pshufd Xmm1, Xmm2, 10101010b
358	356		Mulps Xmm1, Xmm6
359	357		Addps Xmm0, Xmm1
360	358
361	359		Pshufd Xmm1, Xmm2, 11111111b
362	360		Mulps Xmm1, Xmm7
363	361		Addps Xmm0, Xmm1
364	362
365	363		Movups [Result + $30], Xmm0
366	364		end;
367	365		```
368	366
369	367		Autor: Mathias
370	368
371	369		---
372	370		From the Free Pascal wiki, page "SSE/de", as it stood on 2020-01-19 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).
373	371		Category: Deutsch
374	372		Category: Free Pascal Programmers Guide/de

Back to history