Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-or-later
2 : // Copyright (C) 2013 Andrea Mazzoleni
3 :
4 : #include "internal.h"
5 : #include "gf.h"
6 : #include "cpu.h"
7 :
8 : /*
9 : * For x86 optimizations you can see:
10 : *
11 : * Software optimization resources
12 : * http://www.agner.org/optimize/
13 : *
14 : * x86, x64 Instruction Latency, Memory Latency and CPUID dumps
15 : * http://users.atw.hu/instlatx64/
16 : */
17 :
18 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
19 : /*
20 : * GEN1 (RAID5 with xor) SSE2 implementation
21 : *
22 : * Intentionally don't process more than 64 bytes because 64 is the typical
23 : * cache block, and processing 128 bytes doesn't increase performance, and in
24 : * some cases it even decreases it.
25 : */
26 314473 : void raid_gen1_sse2(int nd, size_t size, void **vv)
27 : {
28 314473 : uint8_t **v = (uint8_t **)vv;
29 : uint8_t *p;
30 : int d, l;
31 : size_t i;
32 :
33 314473 : l = nd - 1;
34 314473 : p = v[nd];
35 :
36 : raid_sse_begin();
37 :
38 25851845 : for (i = 0; i < size; i += 64) {
39 25537372 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
40 25537372 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
41 25537372 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
42 25537372 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
43 92504292 : for (d = l - 1; d >= 0; --d) {
44 66966920 : asm volatile ("pxor %0,%%xmm0" : : "m" (v[d][i]));
45 66966920 : asm volatile ("pxor %0,%%xmm1" : : "m" (v[d][i + 16]));
46 66966920 : asm volatile ("pxor %0,%%xmm2" : : "m" (v[d][i + 32]));
47 66966920 : asm volatile ("pxor %0,%%xmm3" : : "m" (v[d][i + 48]));
48 : }
49 25537372 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
50 25537372 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
51 25537372 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
52 25537372 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
53 : }
54 :
55 : raid_sse_end();
56 314473 : }
57 : #endif
58 :
59 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
60 : /*
61 : * GEN1 (RAID5 with xor) AVX2 implementation
62 : *
63 : * Intentionally don't process more than 64 bytes because 64 is the typical
64 : * cache block, and processing 128 bytes doesn't increase performance, and in
65 : * some cases it even decreases it.
66 : */
67 26 : void raid_gen1_avx2(int nd, size_t size, void **vv)
68 : {
69 26 : uint8_t **v = (uint8_t **)vv;
70 : uint8_t *p;
71 : int d, l;
72 : size_t i;
73 :
74 26 : l = nd - 1;
75 26 : p = v[nd];
76 :
77 : raid_avx_begin();
78 :
79 94246 : for (i = 0; i < size; i += 64) {
80 94220 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
81 94220 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
82 753924 : for (d = l - 1; d >= 0; --d) {
83 659704 : asm volatile ("vpxor %0,%%ymm0,%%ymm0" : : "m" (v[d][i]));
84 659704 : asm volatile ("vpxor %0,%%ymm1,%%ymm1" : : "m" (v[d][i + 32]));
85 : }
86 94220 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
87 94220 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
88 : }
89 :
90 : raid_avx_end();
91 26 : }
92 : #endif
93 :
94 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
95 : /*
96 : * GEN1 (RAID5 with xor) AVX512BW implementation
97 : *
98 : * Note that in true AVX512F would suffice, but we don't want to add
99 : * specific support for AVX512F because this would be the only function
100 : * to benefit from that.
101 : *
102 : * Intentionally don't process more than 64 bytes because 64 is the typical
103 : * cache block, and processing 128 bytes doesn't increase performance, and in
104 : * some cases it even decreases it.
105 : */
106 129 : void raid_gen1_avx512bw(int nd, size_t size, void **vv)
107 : {
108 129 : uint8_t **v = (uint8_t**)vv;
109 : uint8_t *p;
110 : int d, l;
111 : size_t i;
112 :
113 129 : l = nd - 1;
114 129 : p = v[nd];
115 :
116 : raid_avx_begin();
117 :
118 83085 : for (i = 0; i < size; i += 64) {
119 82956 : asm volatile ("vmovdqa64 %0,%%zmm0" : : "m" (v[l][i]));
120 670468 : for (d = l - 1; d >= 0; --d) {
121 587512 : asm volatile ("vpxorq %0,%%zmm0,%%zmm0" : : "m" (v[d][i]));
122 : }
123 82956 : asm volatile ("vmovntdq %%zmm0,%0" : "=m" (p[i]));
124 : }
125 :
126 : raid_avx_end();
127 129 : }
128 : #endif
129 :
130 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
131 : static const struct gfconst16 {
132 : uint8_t poly[16];
133 : uint8_t low4[16];
134 : } gfconst16 __aligned(32) = {
135 : {
136 : 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
137 : 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d
138 : },
139 : {
140 : 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
141 : 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f
142 : },
143 : };
144 : #endif
145 :
146 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
147 : /*
148 : * GEN2 (RAID6 with powers of 2) SSE2 implementation
149 : */
150 29 : void raid_gen2_sse2(int nd, size_t size, void **vv)
151 : {
152 29 : uint8_t **v = (uint8_t **)vv;
153 : uint8_t *p;
154 : uint8_t *q;
155 : int d, l;
156 : size_t i;
157 :
158 29 : l = nd - 1;
159 29 : p = v[nd];
160 29 : q = v[nd + 1];
161 :
162 : raid_sse_begin();
163 :
164 29 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
165 :
166 213045 : for (i = 0; i < size; i += 32) {
167 213016 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
168 213016 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
169 213016 : asm volatile ("movdqa %xmm0,%xmm2");
170 213016 : asm volatile ("movdqa %xmm1,%xmm3");
171 1704456 : for (d = l - 1; d >= 0; --d) {
172 1491440 : asm volatile ("pxor %xmm4,%xmm4");
173 1491440 : asm volatile ("pxor %xmm5,%xmm5");
174 1491440 : asm volatile ("pcmpgtb %xmm2,%xmm4");
175 1491440 : asm volatile ("pcmpgtb %xmm3,%xmm5");
176 1491440 : asm volatile ("paddb %xmm2,%xmm2");
177 1491440 : asm volatile ("paddb %xmm3,%xmm3");
178 1491440 : asm volatile ("pand %xmm7,%xmm4");
179 1491440 : asm volatile ("pand %xmm7,%xmm5");
180 1491440 : asm volatile ("pxor %xmm4,%xmm2");
181 1491440 : asm volatile ("pxor %xmm5,%xmm3");
182 :
183 1491440 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
184 1491440 : asm volatile ("movdqa %0,%%xmm5" : : "m" (v[d][i + 16]));
185 1491440 : asm volatile ("pxor %xmm4,%xmm0");
186 1491440 : asm volatile ("pxor %xmm5,%xmm1");
187 1491440 : asm volatile ("pxor %xmm4,%xmm2");
188 1491440 : asm volatile ("pxor %xmm5,%xmm3");
189 : }
190 213016 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
191 213016 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
192 213016 : asm volatile ("movntdq %%xmm2,%0" : "=m" (q[i]));
193 213016 : asm volatile ("movntdq %%xmm3,%0" : "=m" (q[i + 16]));
194 : }
195 :
196 : raid_sse_end();
197 29 : }
198 : #endif
199 :
200 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
201 : /*
202 : * GEN2 (RAID6 with powers of 2) AVX2 implementation
203 : */
204 19 : void raid_gen2_avx2(int nd, size_t size, void **vv)
205 : {
206 19 : uint8_t **v = (uint8_t **)vv;
207 : uint8_t *p;
208 : uint8_t *q;
209 : int d, l;
210 : size_t i;
211 :
212 19 : l = nd - 1;
213 19 : p = v[nd];
214 19 : q = v[nd + 1];
215 :
216 : raid_avx_begin();
217 :
218 19 : asm volatile ("vbroadcasti128 %0, %%ymm7" : : "m" (gfconst16.poly[0]));
219 19 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
220 :
221 65567 : for (i = 0; i < size; i += 64) {
222 65548 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
223 65548 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
224 65548 : asm volatile ("vmovdqa %ymm0,%ymm2");
225 65548 : asm volatile ("vmovdqa %ymm1,%ymm3");
226 524548 : for (d = l - 1; d >= 0; --d) {
227 459000 : asm volatile ("vpcmpgtb %ymm2,%ymm6,%ymm4");
228 459000 : asm volatile ("vpcmpgtb %ymm3,%ymm6,%ymm5");
229 459000 : asm volatile ("vpaddb %ymm2,%ymm2,%ymm2");
230 459000 : asm volatile ("vpaddb %ymm3,%ymm3,%ymm3");
231 459000 : asm volatile ("vpand %ymm7,%ymm4,%ymm4");
232 459000 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
233 459000 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
234 459000 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
235 :
236 459000 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
237 459000 : asm volatile ("vmovdqa %0,%%ymm5" : : "m" (v[d][i + 32]));
238 459000 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
239 459000 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
240 459000 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
241 459000 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
242 : }
243 65548 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
244 65548 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
245 65548 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (q[i]));
246 65548 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (q[i + 32]));
247 : }
248 :
249 : raid_avx_end();
250 19 : }
251 : #endif
252 :
253 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
254 : /*
255 : * GEN2 (RAID6 with powers of 2) AVX512BW implementation
256 : */
257 654 : void raid_gen2_avx512bw(int nd, size_t size, void **vv)
258 : {
259 654 : uint8_t **v = (uint8_t**)vv;
260 : uint8_t *p;
261 : uint8_t *q;
262 : int d, l;
263 : size_t i;
264 :
265 654 : l = nd - 1;
266 654 : p = v[nd];
267 654 : q = v[nd + 1];
268 :
269 : raid_avx_begin();
270 :
271 654 : asm volatile ("vbroadcasti32x4 %0, %%zmm14" : : "m" (gfconst16.poly[0]));
272 654 : asm volatile ("vpxorq %zmm6,%zmm6,%zmm6");
273 :
274 65370 : for (i = 0; i < size; i += 64) {
275 64716 : asm volatile ("vmovdqa64 %0,%%zmm0" : : "m" (v[l][i]));
276 64716 : asm volatile ("vmovdqa64 %zmm0,%zmm1");
277 534020 : for (d = l - 1; d >= 0; --d) {
278 469304 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
279 469304 : asm volatile ("vpmovm2b %k1,%zmm11");
280 469304 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
281 469304 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
282 469304 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
283 :
284 469304 : asm volatile ("vmovdqa64 %0,%%zmm4" : : "m" (v[d][i]));
285 469304 : asm volatile ("vpxorq %zmm4,%zmm0,%zmm0");
286 469304 : asm volatile ("vpxorq %zmm4,%zmm1,%zmm1");
287 : }
288 64716 : asm volatile ("vmovntdq %%zmm0,%0" : "=m" (p[i]));
289 64716 : asm volatile ("vmovntdq %%zmm1,%0" : "=m" (q[i]));
290 : }
291 :
292 : raid_avx_end();
293 654 : }
294 : #endif
295 :
296 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSE2)
297 : /*
298 : * GEN2 (RAID6 with powers of 2) SSE2 implementation
299 : *
300 : * Note that it uses 16 registers, meaning that x64 is required.
301 : */
302 269102 : void raid_gen2_sse2ext(int nd, size_t size, void **vv)
303 : {
304 269102 : uint8_t **v = (uint8_t **)vv;
305 : uint8_t *p;
306 : uint8_t *q;
307 : int d, l;
308 : size_t i;
309 :
310 269102 : l = nd - 1;
311 269102 : p = v[nd];
312 269102 : q = v[nd + 1];
313 :
314 : raid_sse_begin();
315 :
316 269102 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.poly[0]));
317 :
318 4778698 : for (i = 0; i < size; i += 64) {
319 4509596 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
320 4509596 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
321 4509596 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
322 4509596 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
323 4509596 : asm volatile ("movdqa %xmm0,%xmm4");
324 4509596 : asm volatile ("movdqa %xmm1,%xmm5");
325 4509596 : asm volatile ("movdqa %xmm2,%xmm6");
326 4509596 : asm volatile ("movdqa %xmm3,%xmm7");
327 27467364 : for (d = l - 1; d >= 0; --d) {
328 22957768 : asm volatile ("pxor %xmm8,%xmm8");
329 22957768 : asm volatile ("pxor %xmm9,%xmm9");
330 22957768 : asm volatile ("pxor %xmm10,%xmm10");
331 22957768 : asm volatile ("pxor %xmm11,%xmm11");
332 22957768 : asm volatile ("pcmpgtb %xmm4,%xmm8");
333 22957768 : asm volatile ("pcmpgtb %xmm5,%xmm9");
334 22957768 : asm volatile ("pcmpgtb %xmm6,%xmm10");
335 22957768 : asm volatile ("pcmpgtb %xmm7,%xmm11");
336 22957768 : asm volatile ("paddb %xmm4,%xmm4");
337 22957768 : asm volatile ("paddb %xmm5,%xmm5");
338 22957768 : asm volatile ("paddb %xmm6,%xmm6");
339 22957768 : asm volatile ("paddb %xmm7,%xmm7");
340 22957768 : asm volatile ("pand %xmm15,%xmm8");
341 22957768 : asm volatile ("pand %xmm15,%xmm9");
342 22957768 : asm volatile ("pand %xmm15,%xmm10");
343 22957768 : asm volatile ("pand %xmm15,%xmm11");
344 22957768 : asm volatile ("pxor %xmm8,%xmm4");
345 22957768 : asm volatile ("pxor %xmm9,%xmm5");
346 22957768 : asm volatile ("pxor %xmm10,%xmm6");
347 22957768 : asm volatile ("pxor %xmm11,%xmm7");
348 :
349 22957768 : asm volatile ("movdqa %0,%%xmm8" : : "m" (v[d][i]));
350 22957768 : asm volatile ("movdqa %0,%%xmm9" : : "m" (v[d][i + 16]));
351 22957768 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i + 32]));
352 22957768 : asm volatile ("movdqa %0,%%xmm11" : : "m" (v[d][i + 48]));
353 22957768 : asm volatile ("pxor %xmm8,%xmm0");
354 22957768 : asm volatile ("pxor %xmm9,%xmm1");
355 22957768 : asm volatile ("pxor %xmm10,%xmm2");
356 22957768 : asm volatile ("pxor %xmm11,%xmm3");
357 22957768 : asm volatile ("pxor %xmm8,%xmm4");
358 22957768 : asm volatile ("pxor %xmm9,%xmm5");
359 22957768 : asm volatile ("pxor %xmm10,%xmm6");
360 22957768 : asm volatile ("pxor %xmm11,%xmm7");
361 : }
362 4509596 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
363 4509596 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
364 4509596 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
365 4509596 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
366 4509596 : asm volatile ("movntdq %%xmm4,%0" : "=m" (q[i]));
367 4509596 : asm volatile ("movntdq %%xmm5,%0" : "=m" (q[i + 16]));
368 4509596 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i + 32]));
369 4509596 : asm volatile ("movntdq %%xmm7,%0" : "=m" (q[i + 48]));
370 : }
371 :
372 : raid_sse_end();
373 269102 : }
374 : #endif
375 :
376 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
377 : /*
378 : * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
379 : */
380 14 : void raid_gen3_ssse3(int nd, size_t size, void **vv)
381 : {
382 14 : uint8_t **v = (uint8_t **)vv;
383 : uint8_t *p;
384 : uint8_t *q;
385 : uint8_t *r;
386 : int d, l;
387 : size_t i;
388 :
389 14 : l = nd - 1;
390 14 : p = v[nd];
391 14 : q = v[nd + 1];
392 14 : r = v[nd + 2];
393 :
394 : /* special case with only one data disk */
395 14 : if (l == 0) {
396 4 : for (i = 0; i < 3; ++i)
397 3 : memcpy(v[1 + i], v[0], size);
398 1 : return;
399 : }
400 :
401 : raid_sse_begin();
402 :
403 : /* generic case with at least two data disks */
404 13 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
405 13 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
406 :
407 196637 : for (i = 0; i < size; i += 16) {
408 : /* last disk without the multiplication by two */
409 196624 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
410 :
411 196624 : asm volatile ("movdqa %xmm4,%xmm0");
412 196624 : asm volatile ("movdqa %xmm4,%xmm1");
413 :
414 196624 : asm volatile ("movdqa %xmm4,%xmm5");
415 196624 : asm volatile ("psrlw $4,%xmm5");
416 196624 : asm volatile ("pand %xmm7,%xmm4");
417 196624 : asm volatile ("pand %xmm7,%xmm5");
418 :
419 196624 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
420 196624 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[l][0][1][0]));
421 196624 : asm volatile ("pshufb %xmm4,%xmm2");
422 196624 : asm volatile ("pshufb %xmm5,%xmm6");
423 196624 : asm volatile ("pxor %xmm6,%xmm2");
424 :
425 : /* intermediate disks */
426 1376752 : for (d = l - 1; d > 0; --d) {
427 1180128 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
428 :
429 1180128 : asm volatile ("pxor %xmm5,%xmm5");
430 1180128 : asm volatile ("pcmpgtb %xmm1,%xmm5");
431 1180128 : asm volatile ("paddb %xmm1,%xmm1");
432 1180128 : asm volatile ("pand %xmm3,%xmm5");
433 1180128 : asm volatile ("pxor %xmm5,%xmm1");
434 :
435 1180128 : asm volatile ("pxor %xmm4,%xmm0");
436 1180128 : asm volatile ("pxor %xmm4,%xmm1");
437 :
438 1180128 : asm volatile ("movdqa %xmm4,%xmm5");
439 1180128 : asm volatile ("psrlw $4,%xmm5");
440 1180128 : asm volatile ("pand %xmm7,%xmm4");
441 1180128 : asm volatile ("pand %xmm7,%xmm5");
442 :
443 1180128 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
444 1180128 : asm volatile ("pshufb %xmm4,%xmm6");
445 1180128 : asm volatile ("pxor %xmm6,%xmm2");
446 1180128 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][1][0]));
447 1180128 : asm volatile ("pshufb %xmm5,%xmm6");
448 1180128 : asm volatile ("pxor %xmm6,%xmm2");
449 : }
450 :
451 : /* first disk with all coefficients at 1 */
452 196624 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
453 :
454 196624 : asm volatile ("pxor %xmm5,%xmm5");
455 196624 : asm volatile ("pcmpgtb %xmm1,%xmm5");
456 196624 : asm volatile ("paddb %xmm1,%xmm1");
457 196624 : asm volatile ("pand %xmm3,%xmm5");
458 196624 : asm volatile ("pxor %xmm5,%xmm1");
459 :
460 196624 : asm volatile ("pxor %xmm4,%xmm0");
461 196624 : asm volatile ("pxor %xmm4,%xmm1");
462 196624 : asm volatile ("pxor %xmm4,%xmm2");
463 :
464 196624 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
465 196624 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
466 196624 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
467 : }
468 :
469 : raid_sse_end();
470 : }
471 : #endif
472 :
473 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
474 : /*
475 : * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
476 : *
477 : * Note that it uses 16 registers, meaning that x64 is required.
478 : */
479 28231 : void raid_gen3_ssse3ext(int nd, size_t size, void **vv)
480 : {
481 28231 : uint8_t **v = (uint8_t **)vv;
482 : uint8_t *p;
483 : uint8_t *q;
484 : uint8_t *r;
485 : int d, l;
486 : size_t i;
487 :
488 28231 : l = nd - 1;
489 28231 : p = v[nd];
490 28231 : q = v[nd + 1];
491 28231 : r = v[nd + 2];
492 :
493 : /* special case with only one data disk */
494 28231 : if (l == 0) {
495 4 : for (i = 0; i < 3; ++i)
496 3 : memcpy(v[1 + i], v[0], size);
497 1 : return;
498 : }
499 :
500 : raid_sse_begin();
501 :
502 : /* generic case with at least two data disks */
503 28230 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
504 28230 : asm volatile ("movdqa %0,%%xmm11" : : "m" (gfconst16.low4[0]));
505 :
506 1160046 : for (i = 0; i < size; i += 32) {
507 : /* last disk without the by two multiplication */
508 1131816 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
509 1131816 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
510 :
511 1131816 : asm volatile ("movdqa %xmm4,%xmm0");
512 1131816 : asm volatile ("movdqa %xmm4,%xmm1");
513 1131816 : asm volatile ("movdqa %xmm12,%xmm8");
514 1131816 : asm volatile ("movdqa %xmm12,%xmm9");
515 :
516 1131816 : asm volatile ("movdqa %xmm4,%xmm5");
517 1131816 : asm volatile ("movdqa %xmm12,%xmm13");
518 1131816 : asm volatile ("psrlw $4,%xmm5");
519 1131816 : asm volatile ("psrlw $4,%xmm13");
520 1131816 : asm volatile ("pand %xmm11,%xmm4");
521 1131816 : asm volatile ("pand %xmm11,%xmm12");
522 1131816 : asm volatile ("pand %xmm11,%xmm5");
523 1131816 : asm volatile ("pand %xmm11,%xmm13");
524 :
525 1131816 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
526 1131816 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
527 1131816 : asm volatile ("movdqa %xmm2,%xmm10");
528 1131816 : asm volatile ("movdqa %xmm7,%xmm15");
529 1131816 : asm volatile ("pshufb %xmm4,%xmm2");
530 1131816 : asm volatile ("pshufb %xmm12,%xmm10");
531 1131816 : asm volatile ("pshufb %xmm5,%xmm7");
532 1131816 : asm volatile ("pshufb %xmm13,%xmm15");
533 1131816 : asm volatile ("pxor %xmm7,%xmm2");
534 1131816 : asm volatile ("pxor %xmm15,%xmm10");
535 :
536 : /* intermediate disks */
537 6118040 : for (d = l - 1; d > 0; --d) {
538 4986224 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
539 4986224 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
540 :
541 4986224 : asm volatile ("pxor %xmm5,%xmm5");
542 4986224 : asm volatile ("pxor %xmm13,%xmm13");
543 4986224 : asm volatile ("pcmpgtb %xmm1,%xmm5");
544 4986224 : asm volatile ("pcmpgtb %xmm9,%xmm13");
545 4986224 : asm volatile ("paddb %xmm1,%xmm1");
546 4986224 : asm volatile ("paddb %xmm9,%xmm9");
547 4986224 : asm volatile ("pand %xmm3,%xmm5");
548 4986224 : asm volatile ("pand %xmm3,%xmm13");
549 4986224 : asm volatile ("pxor %xmm5,%xmm1");
550 4986224 : asm volatile ("pxor %xmm13,%xmm9");
551 :
552 4986224 : asm volatile ("pxor %xmm4,%xmm0");
553 4986224 : asm volatile ("pxor %xmm4,%xmm1");
554 4986224 : asm volatile ("pxor %xmm12,%xmm8");
555 4986224 : asm volatile ("pxor %xmm12,%xmm9");
556 :
557 4986224 : asm volatile ("movdqa %xmm4,%xmm5");
558 4986224 : asm volatile ("movdqa %xmm12,%xmm13");
559 4986224 : asm volatile ("psrlw $4,%xmm5");
560 4986224 : asm volatile ("psrlw $4,%xmm13");
561 4986224 : asm volatile ("pand %xmm11,%xmm4");
562 4986224 : asm volatile ("pand %xmm11,%xmm12");
563 4986224 : asm volatile ("pand %xmm11,%xmm5");
564 4986224 : asm volatile ("pand %xmm11,%xmm13");
565 :
566 4986224 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
567 4986224 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
568 4986224 : asm volatile ("movdqa %xmm6,%xmm14");
569 4986224 : asm volatile ("movdqa %xmm7,%xmm15");
570 4986224 : asm volatile ("pshufb %xmm4,%xmm6");
571 4986224 : asm volatile ("pshufb %xmm12,%xmm14");
572 4986224 : asm volatile ("pshufb %xmm5,%xmm7");
573 4986224 : asm volatile ("pshufb %xmm13,%xmm15");
574 4986224 : asm volatile ("pxor %xmm6,%xmm2");
575 4986224 : asm volatile ("pxor %xmm14,%xmm10");
576 4986224 : asm volatile ("pxor %xmm7,%xmm2");
577 4986224 : asm volatile ("pxor %xmm15,%xmm10");
578 : }
579 :
580 : /* first disk with all coefficients at 1 */
581 1131816 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
582 1131816 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
583 :
584 1131816 : asm volatile ("pxor %xmm5,%xmm5");
585 1131816 : asm volatile ("pxor %xmm13,%xmm13");
586 1131816 : asm volatile ("pcmpgtb %xmm1,%xmm5");
587 1131816 : asm volatile ("pcmpgtb %xmm9,%xmm13");
588 1131816 : asm volatile ("paddb %xmm1,%xmm1");
589 1131816 : asm volatile ("paddb %xmm9,%xmm9");
590 1131816 : asm volatile ("pand %xmm3,%xmm5");
591 1131816 : asm volatile ("pand %xmm3,%xmm13");
592 1131816 : asm volatile ("pxor %xmm5,%xmm1");
593 1131816 : asm volatile ("pxor %xmm13,%xmm9");
594 :
595 1131816 : asm volatile ("pxor %xmm4,%xmm0");
596 1131816 : asm volatile ("pxor %xmm4,%xmm1");
597 1131816 : asm volatile ("pxor %xmm4,%xmm2");
598 1131816 : asm volatile ("pxor %xmm12,%xmm8");
599 1131816 : asm volatile ("pxor %xmm12,%xmm9");
600 1131816 : asm volatile ("pxor %xmm12,%xmm10");
601 :
602 1131816 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
603 1131816 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
604 1131816 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
605 1131816 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
606 1131816 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
607 1131816 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
608 : }
609 :
610 : raid_sse_end();
611 : }
612 : #endif
613 :
614 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
615 : /*
616 : * GEN3 (triple parity with Cauchy matrix) AVX2 implementation
617 : *
618 : * Note that it uses 16 registers, meaning that x64 is required.
619 : */
620 12 : void raid_gen3_avx2ext(int nd, size_t size, void **vv)
621 : {
622 12 : uint8_t **v = (uint8_t **)vv;
623 : uint8_t *p;
624 : uint8_t *q;
625 : uint8_t *r;
626 : int d, l;
627 : size_t i;
628 :
629 12 : l = nd - 1;
630 12 : p = v[nd];
631 12 : q = v[nd + 1];
632 12 : r = v[nd + 2];
633 :
634 : /* special case with only one data disk */
635 12 : if (l == 0) {
636 4 : for (i = 0; i < 3; ++i)
637 3 : memcpy(v[1 + i], v[0], size);
638 1 : return;
639 : }
640 :
641 : raid_avx_begin();
642 :
643 : /* generic case with at least two data disks */
644 11 : asm volatile ("vbroadcasti128 %0, %%ymm3" : : "m" (gfconst16.poly[0]));
645 11 : asm volatile ("vbroadcasti128 %0, %%ymm11" : : "m" (gfconst16.low4[0]));
646 :
647 40975 : for (i = 0; i < size; i += 64) {
648 : /* last disk without the by two multiplication */
649 40964 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
650 40964 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
651 :
652 40964 : asm volatile ("vmovdqa %ymm4,%ymm0");
653 40964 : asm volatile ("vmovdqa %ymm4,%ymm1");
654 40964 : asm volatile ("vmovdqa %ymm12,%ymm8");
655 40964 : asm volatile ("vmovdqa %ymm12,%ymm9");
656 :
657 40964 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
658 40964 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
659 40964 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
660 40964 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
661 40964 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
662 40964 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
663 :
664 40964 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
665 40964 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
666 40964 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
667 40964 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
668 40964 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
669 40964 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
670 40964 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
671 40964 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
672 :
673 : /* intermediate disks */
674 286844 : for (d = l - 1; d > 0; --d) {
675 245880 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
676 245880 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
677 :
678 245880 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
679 245880 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
680 245880 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
681 245880 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
682 245880 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
683 245880 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
684 245880 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
685 245880 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
686 245880 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
687 245880 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
688 :
689 245880 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
690 245880 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
691 245880 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
692 245880 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
693 :
694 245880 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
695 245880 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
696 245880 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
697 245880 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
698 245880 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
699 245880 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
700 :
701 245880 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
702 245880 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
703 245880 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
704 245880 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
705 245880 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
706 245880 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
707 245880 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
708 245880 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
709 245880 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
710 245880 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
711 : }
712 :
713 : /* first disk with all coefficients at 1 */
714 40964 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
715 40964 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
716 :
717 40964 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
718 40964 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
719 40964 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
720 40964 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
721 40964 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
722 40964 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
723 40964 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
724 40964 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
725 40964 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
726 40964 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
727 :
728 40964 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
729 40964 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
730 40964 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
731 40964 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
732 40964 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
733 40964 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
734 :
735 40964 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
736 40964 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
737 40964 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
738 40964 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
739 40964 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
740 40964 : asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
741 : }
742 :
743 : raid_avx_end();
744 : }
745 : #endif
746 :
747 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
748 : /*
749 : * GEN3 (triple parity with Cauchy matrix) AVX512BW implementation
750 : */
751 1476 : void raid_gen3_avx512bw(int nd, size_t size, void **vv)
752 : {
753 1476 : uint8_t **v = (uint8_t **)vv;
754 : uint8_t *p;
755 : uint8_t *q;
756 : uint8_t *r;
757 : int d, l;
758 : size_t i;
759 :
760 1476 : l = nd - 1;
761 1476 : p = v[nd];
762 1476 : q = v[nd + 1];
763 1476 : r = v[nd + 2];
764 :
765 : /* special case with only one data disk */
766 1476 : if (l == 0) {
767 4 : for (i = 0; i < 3; ++i)
768 3 : memcpy(v[1 + i], v[0], size);
769 1 : return;
770 : }
771 :
772 : raid_avx_begin();
773 :
774 : /* generic case with at least two data disks */
775 1475 : asm volatile ("vpxorq %zmm6,%zmm6,%zmm6");
776 1475 : asm volatile ("vbroadcasti32x4 %0,%%zmm14" : : "m" (gfconst16.poly[0]));
777 1475 : asm volatile ("vbroadcasti32x4 %0,%%zmm15" : : "m" (gfconst16.low4[0]));
778 :
779 40711 : for (i = 0; i < size; i += 64) {
780 : /* last disk without the by two multiplication */
781 39236 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[l][i]));
782 :
783 39236 : asm volatile ("vmovdqa64 %zmm10,%zmm0");
784 39236 : asm volatile ("vmovdqa64 %zmm10,%zmm1");
785 :
786 39236 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
787 39236 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
788 39236 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
789 :
790 39236 : asm volatile ("vbroadcasti32x4 %0,%%zmm2" : : "m" (gfgenpshufb[l][0][0][0]));
791 39236 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][0][1][0]));
792 39236 : asm volatile ("vpshufb %zmm10,%zmm2,%zmm2");
793 39236 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
794 39236 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
795 :
796 : /* intermediate disks */
797 303164 : for (d = l - 1; d > 0; --d) {
798 263928 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[d][i]));
799 :
800 263928 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
801 263928 : asm volatile ("vpmovm2b %k1,%zmm11");
802 263928 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
803 263928 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
804 263928 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
805 :
806 263928 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
807 263928 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
808 :
809 263928 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
810 263928 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
811 263928 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
812 :
813 263928 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][0][0][0]));
814 263928 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][0][1][0]));
815 263928 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
816 263928 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
817 263928 : asm volatile ("vpxorq %zmm12,%zmm2,%zmm2");
818 263928 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
819 : }
820 :
821 : /* first disk with all coefficients at 1 */
822 39236 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[0][i]));
823 :
824 39236 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
825 39236 : asm volatile ("vpmovm2b %k1,%zmm11");
826 39236 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
827 39236 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
828 39236 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
829 :
830 39236 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
831 39236 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
832 39236 : asm volatile ("vpxorq %zmm10,%zmm2,%zmm2");
833 :
834 39236 : asm volatile ("vmovntdq %%zmm0,%0" : "=m" (p[i]));
835 39236 : asm volatile ("vmovntdq %%zmm1,%0" : "=m" (q[i]));
836 39236 : asm volatile ("vmovntdq %%zmm2,%0" : "=m" (r[i]));
837 : }
838 :
839 : raid_avx_end();
840 : }
841 : #endif
842 :
843 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
844 : /*
845 : * GEN4 (quad parity with Cauchy matrix) SSSE3 implementation
846 : */
847 10 : void raid_gen4_ssse3(int nd, size_t size, void **vv)
848 : {
849 10 : uint8_t **v = (uint8_t **)vv;
850 : uint8_t *p;
851 : uint8_t *q;
852 : uint8_t *r;
853 : uint8_t *s;
854 : int d, l;
855 : size_t i;
856 :
857 10 : l = nd - 1;
858 10 : p = v[nd];
859 10 : q = v[nd + 1];
860 10 : r = v[nd + 2];
861 10 : s = v[nd + 3];
862 :
863 : /* special case with only one data disk */
864 10 : if (l == 0) {
865 5 : for (i = 0; i < 4; ++i)
866 4 : memcpy(v[1 + i], v[0], size);
867 1 : return;
868 : }
869 :
870 : raid_sse_begin();
871 :
872 : /* generic case with at least two data disks */
873 131097 : for (i = 0; i < size; i += 16) {
874 : /* last disk without the by two multiplication */
875 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
876 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
877 :
878 131088 : asm volatile ("movdqa %xmm4,%xmm0");
879 131088 : asm volatile ("movdqa %xmm4,%xmm1");
880 :
881 131088 : asm volatile ("movdqa %xmm4,%xmm5");
882 131088 : asm volatile ("psrlw $4,%xmm5");
883 131088 : asm volatile ("pand %xmm7,%xmm4");
884 131088 : asm volatile ("pand %xmm7,%xmm5");
885 :
886 131088 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
887 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
888 131088 : asm volatile ("pshufb %xmm4,%xmm2");
889 131088 : asm volatile ("pshufb %xmm5,%xmm7");
890 131088 : asm volatile ("pxor %xmm7,%xmm2");
891 :
892 131088 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
893 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
894 131088 : asm volatile ("pshufb %xmm4,%xmm3");
895 131088 : asm volatile ("pshufb %xmm5,%xmm7");
896 131088 : asm volatile ("pxor %xmm7,%xmm3");
897 :
898 : /* intermediate disks */
899 918000 : for (d = l - 1; d > 0; --d) {
900 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
901 786912 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
902 :
903 786912 : asm volatile ("pxor %xmm5,%xmm5");
904 786912 : asm volatile ("pcmpgtb %xmm1,%xmm5");
905 786912 : asm volatile ("paddb %xmm1,%xmm1");
906 786912 : asm volatile ("pand %xmm7,%xmm5");
907 786912 : asm volatile ("pxor %xmm5,%xmm1");
908 :
909 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
910 :
911 786912 : asm volatile ("pxor %xmm4,%xmm0");
912 786912 : asm volatile ("pxor %xmm4,%xmm1");
913 :
914 786912 : asm volatile ("movdqa %xmm4,%xmm5");
915 786912 : asm volatile ("psrlw $4,%xmm5");
916 786912 : asm volatile ("pand %xmm7,%xmm4");
917 786912 : asm volatile ("pand %xmm7,%xmm5");
918 :
919 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
920 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
921 786912 : asm volatile ("pshufb %xmm4,%xmm6");
922 786912 : asm volatile ("pshufb %xmm5,%xmm7");
923 786912 : asm volatile ("pxor %xmm6,%xmm2");
924 786912 : asm volatile ("pxor %xmm7,%xmm2");
925 :
926 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
927 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
928 786912 : asm volatile ("pshufb %xmm4,%xmm6");
929 786912 : asm volatile ("pshufb %xmm5,%xmm7");
930 786912 : asm volatile ("pxor %xmm6,%xmm3");
931 786912 : asm volatile ("pxor %xmm7,%xmm3");
932 : }
933 :
934 : /* first disk with all coefficients at 1 */
935 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
936 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
937 :
938 131088 : asm volatile ("pxor %xmm5,%xmm5");
939 131088 : asm volatile ("pcmpgtb %xmm1,%xmm5");
940 131088 : asm volatile ("paddb %xmm1,%xmm1");
941 131088 : asm volatile ("pand %xmm7,%xmm5");
942 131088 : asm volatile ("pxor %xmm5,%xmm1");
943 :
944 131088 : asm volatile ("pxor %xmm4,%xmm0");
945 131088 : asm volatile ("pxor %xmm4,%xmm1");
946 131088 : asm volatile ("pxor %xmm4,%xmm2");
947 131088 : asm volatile ("pxor %xmm4,%xmm3");
948 :
949 131088 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
950 131088 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
951 131088 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
952 131088 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
953 : }
954 :
955 : raid_sse_end();
956 : }
957 : #endif
958 :
959 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
960 : /*
961 : * GEN4 (quad parity with Cauchy matrix) SSSE3 implementation
962 : *
963 : * Note that it uses 16 registers, meaning that x64 is required.
964 : */
965 28342 : void raid_gen4_ssse3ext(int nd, size_t size, void **vv)
966 : {
967 28342 : uint8_t **v = (uint8_t **)vv;
968 : uint8_t *p;
969 : uint8_t *q;
970 : uint8_t *r;
971 : uint8_t *s;
972 : int d, l;
973 : size_t i;
974 :
975 28342 : l = nd - 1;
976 28342 : p = v[nd];
977 28342 : q = v[nd + 1];
978 28342 : r = v[nd + 2];
979 28342 : s = v[nd + 3];
980 :
981 : /* special case with only one data disk */
982 28342 : if (l == 0) {
983 5 : for (i = 0; i < 4; ++i)
984 4 : memcpy(v[1 + i], v[0], size);
985 1 : return;
986 : }
987 :
988 : raid_sse_begin();
989 :
990 : /* generic case with at least two data disks */
991 1041309 : for (i = 0; i < size; i += 32) {
992 : /* last disk without the by two multiplication */
993 1012968 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
994 1012968 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
995 1012968 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
996 :
997 1012968 : asm volatile ("movdqa %xmm4,%xmm0");
998 1012968 : asm volatile ("movdqa %xmm4,%xmm1");
999 1012968 : asm volatile ("movdqa %xmm12,%xmm8");
1000 1012968 : asm volatile ("movdqa %xmm12,%xmm9");
1001 :
1002 1012968 : asm volatile ("movdqa %xmm4,%xmm5");
1003 1012968 : asm volatile ("movdqa %xmm12,%xmm13");
1004 1012968 : asm volatile ("psrlw $4,%xmm5");
1005 1012968 : asm volatile ("psrlw $4,%xmm13");
1006 1012968 : asm volatile ("pand %xmm15,%xmm4");
1007 1012968 : asm volatile ("pand %xmm15,%xmm12");
1008 1012968 : asm volatile ("pand %xmm15,%xmm5");
1009 1012968 : asm volatile ("pand %xmm15,%xmm13");
1010 :
1011 1012968 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1012 1012968 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1013 1012968 : asm volatile ("movdqa %xmm2,%xmm10");
1014 1012968 : asm volatile ("movdqa %xmm7,%xmm15");
1015 1012968 : asm volatile ("pshufb %xmm4,%xmm2");
1016 1012968 : asm volatile ("pshufb %xmm12,%xmm10");
1017 1012968 : asm volatile ("pshufb %xmm5,%xmm7");
1018 1012968 : asm volatile ("pshufb %xmm13,%xmm15");
1019 1012968 : asm volatile ("pxor %xmm7,%xmm2");
1020 1012968 : asm volatile ("pxor %xmm15,%xmm10");
1021 :
1022 1012968 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1023 1012968 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1024 1012968 : asm volatile ("movdqa %xmm3,%xmm11");
1025 1012968 : asm volatile ("movdqa %xmm7,%xmm15");
1026 1012968 : asm volatile ("pshufb %xmm4,%xmm3");
1027 1012968 : asm volatile ("pshufb %xmm12,%xmm11");
1028 1012968 : asm volatile ("pshufb %xmm5,%xmm7");
1029 1012968 : asm volatile ("pshufb %xmm13,%xmm15");
1030 1012968 : asm volatile ("pxor %xmm7,%xmm3");
1031 1012968 : asm volatile ("pxor %xmm15,%xmm11");
1032 :
1033 : /* intermediate disks */
1034 5278040 : for (d = l - 1; d > 0; --d) {
1035 4265072 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1036 4265072 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1037 4265072 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1038 4265072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
1039 :
1040 4265072 : asm volatile ("pxor %xmm5,%xmm5");
1041 4265072 : asm volatile ("pxor %xmm13,%xmm13");
1042 4265072 : asm volatile ("pcmpgtb %xmm1,%xmm5");
1043 4265072 : asm volatile ("pcmpgtb %xmm9,%xmm13");
1044 4265072 : asm volatile ("paddb %xmm1,%xmm1");
1045 4265072 : asm volatile ("paddb %xmm9,%xmm9");
1046 4265072 : asm volatile ("pand %xmm7,%xmm5");
1047 4265072 : asm volatile ("pand %xmm7,%xmm13");
1048 4265072 : asm volatile ("pxor %xmm5,%xmm1");
1049 4265072 : asm volatile ("pxor %xmm13,%xmm9");
1050 :
1051 4265072 : asm volatile ("pxor %xmm4,%xmm0");
1052 4265072 : asm volatile ("pxor %xmm4,%xmm1");
1053 4265072 : asm volatile ("pxor %xmm12,%xmm8");
1054 4265072 : asm volatile ("pxor %xmm12,%xmm9");
1055 :
1056 4265072 : asm volatile ("movdqa %xmm4,%xmm5");
1057 4265072 : asm volatile ("movdqa %xmm12,%xmm13");
1058 4265072 : asm volatile ("psrlw $4,%xmm5");
1059 4265072 : asm volatile ("psrlw $4,%xmm13");
1060 4265072 : asm volatile ("pand %xmm15,%xmm4");
1061 4265072 : asm volatile ("pand %xmm15,%xmm12");
1062 4265072 : asm volatile ("pand %xmm15,%xmm5");
1063 4265072 : asm volatile ("pand %xmm15,%xmm13");
1064 :
1065 4265072 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1066 4265072 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1067 4265072 : asm volatile ("movdqa %xmm6,%xmm14");
1068 4265072 : asm volatile ("movdqa %xmm7,%xmm15");
1069 4265072 : asm volatile ("pshufb %xmm4,%xmm6");
1070 4265072 : asm volatile ("pshufb %xmm12,%xmm14");
1071 4265072 : asm volatile ("pshufb %xmm5,%xmm7");
1072 4265072 : asm volatile ("pshufb %xmm13,%xmm15");
1073 4265072 : asm volatile ("pxor %xmm6,%xmm2");
1074 4265072 : asm volatile ("pxor %xmm14,%xmm10");
1075 4265072 : asm volatile ("pxor %xmm7,%xmm2");
1076 4265072 : asm volatile ("pxor %xmm15,%xmm10");
1077 :
1078 4265072 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1079 4265072 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1080 4265072 : asm volatile ("movdqa %xmm6,%xmm14");
1081 4265072 : asm volatile ("movdqa %xmm7,%xmm15");
1082 4265072 : asm volatile ("pshufb %xmm4,%xmm6");
1083 4265072 : asm volatile ("pshufb %xmm12,%xmm14");
1084 4265072 : asm volatile ("pshufb %xmm5,%xmm7");
1085 4265072 : asm volatile ("pshufb %xmm13,%xmm15");
1086 4265072 : asm volatile ("pxor %xmm6,%xmm3");
1087 4265072 : asm volatile ("pxor %xmm14,%xmm11");
1088 4265072 : asm volatile ("pxor %xmm7,%xmm3");
1089 4265072 : asm volatile ("pxor %xmm15,%xmm11");
1090 : }
1091 :
1092 : /* first disk with all coefficients at 1 */
1093 1012968 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1094 1012968 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1095 1012968 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1096 1012968 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
1097 :
1098 1012968 : asm volatile ("pxor %xmm5,%xmm5");
1099 1012968 : asm volatile ("pxor %xmm13,%xmm13");
1100 1012968 : asm volatile ("pcmpgtb %xmm1,%xmm5");
1101 1012968 : asm volatile ("pcmpgtb %xmm9,%xmm13");
1102 1012968 : asm volatile ("paddb %xmm1,%xmm1");
1103 1012968 : asm volatile ("paddb %xmm9,%xmm9");
1104 1012968 : asm volatile ("pand %xmm7,%xmm5");
1105 1012968 : asm volatile ("pand %xmm7,%xmm13");
1106 1012968 : asm volatile ("pxor %xmm5,%xmm1");
1107 1012968 : asm volatile ("pxor %xmm13,%xmm9");
1108 :
1109 1012968 : asm volatile ("pxor %xmm4,%xmm0");
1110 1012968 : asm volatile ("pxor %xmm4,%xmm1");
1111 1012968 : asm volatile ("pxor %xmm4,%xmm2");
1112 1012968 : asm volatile ("pxor %xmm4,%xmm3");
1113 1012968 : asm volatile ("pxor %xmm12,%xmm8");
1114 1012968 : asm volatile ("pxor %xmm12,%xmm9");
1115 1012968 : asm volatile ("pxor %xmm12,%xmm10");
1116 1012968 : asm volatile ("pxor %xmm12,%xmm11");
1117 :
1118 1012968 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1119 1012968 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
1120 1012968 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1121 1012968 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
1122 1012968 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1123 1012968 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
1124 1012968 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1125 1012968 : asm volatile ("movntdq %%xmm11,%0" : "=m" (s[i + 16]));
1126 : }
1127 :
1128 : raid_sse_end();
1129 : }
1130 : #endif
1131 :
1132 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
1133 : /*
1134 : * GEN4 (quad parity with Cauchy matrix) AVX2 implementation
1135 : *
1136 : * Note that it uses 16 registers, meaning that x64 is required.
1137 : */
1138 6 : void raid_gen4_avx2ext(int nd, size_t size, void **vv)
1139 : {
1140 6 : uint8_t **v = (uint8_t **)vv;
1141 : uint8_t *p;
1142 : uint8_t *q;
1143 : uint8_t *r;
1144 : uint8_t *s;
1145 : int d, l;
1146 : size_t i;
1147 :
1148 6 : l = nd - 1;
1149 6 : p = v[nd];
1150 6 : q = v[nd + 1];
1151 6 : r = v[nd + 2];
1152 6 : s = v[nd + 3];
1153 :
1154 : /* special case with only one data disk */
1155 6 : if (l == 0) {
1156 5 : for (i = 0; i < 4; ++i)
1157 4 : memcpy(v[1 + i], v[0], size);
1158 1 : return;
1159 : }
1160 :
1161 : raid_avx_begin();
1162 :
1163 : /* generic case with at least two data disks */
1164 16393 : for (i = 0; i < size; i += 64) {
1165 : /* last disk without the by two multiplication */
1166 16388 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1167 16388 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
1168 16388 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
1169 :
1170 16388 : asm volatile ("vmovdqa %ymm4,%ymm0");
1171 16388 : asm volatile ("vmovdqa %ymm4,%ymm1");
1172 16388 : asm volatile ("vmovdqa %ymm12,%ymm8");
1173 16388 : asm volatile ("vmovdqa %ymm12,%ymm9");
1174 :
1175 16388 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
1176 16388 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
1177 16388 : asm volatile ("vpand %ymm15,%ymm4,%ymm4");
1178 16388 : asm volatile ("vpand %ymm15,%ymm12,%ymm12");
1179 16388 : asm volatile ("vpand %ymm15,%ymm5,%ymm5");
1180 16388 : asm volatile ("vpand %ymm15,%ymm13,%ymm13");
1181 :
1182 16388 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
1183 16388 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
1184 16388 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
1185 16388 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1186 16388 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
1187 16388 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1188 16388 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
1189 16388 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
1190 :
1191 16388 : asm volatile ("vbroadcasti128 %0,%%ymm11" : : "m" (gfgenpshufb[l][1][0][0]));
1192 16388 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][1][1][0]));
1193 16388 : asm volatile ("vpshufb %ymm4,%ymm11,%ymm3");
1194 16388 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1195 16388 : asm volatile ("vpshufb %ymm12,%ymm11,%ymm11");
1196 16388 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1197 16388 : asm volatile ("vpxor %ymm7,%ymm3,%ymm3");
1198 16388 : asm volatile ("vpxor %ymm15,%ymm11,%ymm11");
1199 :
1200 : /* intermediate disks */
1201 114812 : for (d = l - 1; d > 0; --d) {
1202 98424 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
1203 98424 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1204 98424 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
1205 98424 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
1206 :
1207 98424 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
1208 98424 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
1209 98424 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
1210 98424 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
1211 98424 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1212 98424 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
1213 98424 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
1214 98424 : asm volatile ("vpand %ymm7,%ymm13,%ymm13");
1215 98424 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
1216 98424 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
1217 :
1218 98424 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
1219 98424 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
1220 98424 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
1221 98424 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
1222 :
1223 98424 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
1224 98424 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
1225 98424 : asm volatile ("vpand %ymm15,%ymm4,%ymm4");
1226 98424 : asm volatile ("vpand %ymm15,%ymm12,%ymm12");
1227 98424 : asm volatile ("vpand %ymm15,%ymm5,%ymm5");
1228 98424 : asm volatile ("vpand %ymm15,%ymm13,%ymm13");
1229 :
1230 98424 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
1231 98424 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
1232 98424 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
1233 98424 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1234 98424 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
1235 98424 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1236 98424 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
1237 98424 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
1238 98424 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
1239 98424 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
1240 :
1241 98424 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][1][0][0]));
1242 98424 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][1][1][0]));
1243 98424 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
1244 98424 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1245 98424 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
1246 98424 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1247 98424 : asm volatile ("vpxor %ymm6,%ymm3,%ymm3");
1248 98424 : asm volatile ("vpxor %ymm14,%ymm11,%ymm11");
1249 98424 : asm volatile ("vpxor %ymm7,%ymm3,%ymm3");
1250 98424 : asm volatile ("vpxor %ymm15,%ymm11,%ymm11");
1251 : }
1252 :
1253 : /* first disk with all coefficients at 1 */
1254 16388 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
1255 16388 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1256 16388 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
1257 16388 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
1258 :
1259 16388 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
1260 16388 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
1261 16388 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
1262 16388 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
1263 16388 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1264 16388 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
1265 16388 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
1266 16388 : asm volatile ("vpand %ymm7,%ymm13,%ymm13");
1267 16388 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
1268 16388 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
1269 :
1270 16388 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
1271 16388 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
1272 16388 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
1273 16388 : asm volatile ("vpxor %ymm4,%ymm3,%ymm3");
1274 16388 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
1275 16388 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
1276 16388 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
1277 16388 : asm volatile ("vpxor %ymm12,%ymm11,%ymm11");
1278 :
1279 16388 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1280 16388 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
1281 16388 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1282 16388 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
1283 16388 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1284 16388 : asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
1285 16388 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1286 16388 : asm volatile ("vmovntdq %%ymm11,%0" : "=m" (s[i + 32]));
1287 : }
1288 :
1289 : raid_avx_end();
1290 : }
1291 : #endif
1292 :
1293 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
1294 : /*
1295 : * GEN4 (quad parity with Cauchy matrix) AVX512BW implementation
1296 : */
1297 5470 : void raid_gen4_avx512bw(int nd, size_t size, void **vv)
1298 : {
1299 5470 : uint8_t **v = (uint8_t **)vv;
1300 : uint8_t *p;
1301 : uint8_t *q;
1302 : uint8_t *r;
1303 : uint8_t *s;
1304 : int d, l;
1305 : size_t i;
1306 :
1307 5470 : l = nd - 1;
1308 5470 : p = v[nd];
1309 5470 : q = v[nd + 1];
1310 5470 : r = v[nd + 2];
1311 5470 : s = v[nd + 3];
1312 :
1313 : /* special case with only one data disk */
1314 5470 : if (l == 0) {
1315 5 : for (i = 0; i < 4; ++i)
1316 4 : memcpy(v[1 + i], v[0], size);
1317 1 : return;
1318 : }
1319 :
1320 : raid_avx_begin();
1321 :
1322 : /* generic case with at least two data disks */
1323 5469 : asm volatile ("vpxorq %zmm6,%zmm6,%zmm6");
1324 5469 : asm volatile ("vbroadcasti32x4 %0,%%zmm14" : : "m" (gfconst16.poly[0]));
1325 5469 : asm volatile ("vbroadcasti32x4 %0,%%zmm15" : : "m" (gfconst16.low4[0]));
1326 :
1327 35889 : for (i = 0; i < size; i += 64) {
1328 : /* last disk without the by two multiplication */
1329 30420 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[l][i]));
1330 :
1331 30420 : asm volatile ("vmovdqa64 %zmm10,%zmm0");
1332 30420 : asm volatile ("vmovdqa64 %zmm10,%zmm1");
1333 :
1334 30420 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
1335 30420 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
1336 30420 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
1337 :
1338 30420 : asm volatile ("vbroadcasti32x4 %0,%%zmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1339 30420 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1340 30420 : asm volatile ("vpshufb %zmm10,%zmm2,%zmm2");
1341 30420 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1342 30420 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
1343 :
1344 30420 : asm volatile ("vbroadcasti32x4 %0,%%zmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1345 30420 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1346 30420 : asm volatile ("vpshufb %zmm10,%zmm3,%zmm3");
1347 30420 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1348 30420 : asm volatile ("vpxorq %zmm13,%zmm3,%zmm3");
1349 :
1350 : /* intermediate disks */
1351 303468 : for (d = l - 1; d > 0; --d) {
1352 273048 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[d][i]));
1353 :
1354 273048 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
1355 273048 : asm volatile ("vpmovm2b %k1,%zmm11");
1356 273048 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
1357 273048 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
1358 273048 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
1359 :
1360 273048 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
1361 273048 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
1362 :
1363 273048 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
1364 273048 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
1365 273048 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
1366 :
1367 273048 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1368 273048 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1369 273048 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
1370 273048 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1371 273048 : asm volatile ("vpxorq %zmm12,%zmm2,%zmm2");
1372 273048 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
1373 :
1374 273048 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1375 273048 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1376 273048 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
1377 273048 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1378 273048 : asm volatile ("vpxorq %zmm12,%zmm3,%zmm3");
1379 273048 : asm volatile ("vpxorq %zmm13,%zmm3,%zmm3");
1380 : }
1381 :
1382 : /* first disk with all coefficients at 1 */
1383 30420 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[0][i]));
1384 :
1385 30420 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
1386 30420 : asm volatile ("vpmovm2b %k1,%zmm11");
1387 30420 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
1388 30420 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
1389 30420 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
1390 :
1391 30420 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
1392 30420 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
1393 30420 : asm volatile ("vpxorq %zmm10,%zmm2,%zmm2");
1394 30420 : asm volatile ("vpxorq %zmm10,%zmm3,%zmm3");
1395 :
1396 30420 : asm volatile ("vmovntdq %%zmm0,%0" : "=m" (p[i]));
1397 30420 : asm volatile ("vmovntdq %%zmm1,%0" : "=m" (q[i]));
1398 30420 : asm volatile ("vmovntdq %%zmm2,%0" : "=m" (r[i]));
1399 30420 : asm volatile ("vmovntdq %%zmm3,%0" : "=m" (s[i]));
1400 : }
1401 :
1402 : raid_avx_end();
1403 : }
1404 : #endif
1405 :
1406 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
1407 : /*
1408 : * GEN5 (penta parity with Cauchy matrix) SSSE3 implementation
1409 : */
1410 10 : void raid_gen5_ssse3(int nd, size_t size, void **vv)
1411 : {
1412 10 : uint8_t **v = (uint8_t **)vv;
1413 : uint8_t *p;
1414 : uint8_t *q;
1415 : uint8_t *r;
1416 : uint8_t *s;
1417 : uint8_t *t;
1418 : int d, l;
1419 : size_t i;
1420 : uint8_t buffer[16+16];
1421 10 : uint8_t *pd = __align_ptr(buffer, 16);
1422 :
1423 10 : l = nd - 1;
1424 10 : p = v[nd];
1425 10 : q = v[nd + 1];
1426 10 : r = v[nd + 2];
1427 10 : s = v[nd + 3];
1428 10 : t = v[nd + 4];
1429 :
1430 : /* special case with only one data disk */
1431 10 : if (l == 0) {
1432 6 : for (i = 0; i < 5; ++i)
1433 5 : memcpy(v[1 + i], v[0], size);
1434 1 : return;
1435 : }
1436 :
1437 : raid_sse_begin();
1438 :
1439 : /* generic case with at least two data disks */
1440 131097 : for (i = 0; i < size; i += 16) {
1441 : /* last disk without the by two multiplication */
1442 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1443 :
1444 131088 : asm volatile ("movdqa %xmm4,%xmm0");
1445 131088 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1446 :
1447 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1448 131088 : asm volatile ("movdqa %xmm4,%xmm5");
1449 131088 : asm volatile ("psrlw $4,%xmm5");
1450 131088 : asm volatile ("pand %xmm7,%xmm4");
1451 131088 : asm volatile ("pand %xmm7,%xmm5");
1452 :
1453 131088 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][0][0][0]));
1454 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1455 131088 : asm volatile ("pshufb %xmm4,%xmm1");
1456 131088 : asm volatile ("pshufb %xmm5,%xmm7");
1457 131088 : asm volatile ("pxor %xmm7,%xmm1");
1458 :
1459 131088 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][1][0][0]));
1460 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1461 131088 : asm volatile ("pshufb %xmm4,%xmm2");
1462 131088 : asm volatile ("pshufb %xmm5,%xmm7");
1463 131088 : asm volatile ("pxor %xmm7,%xmm2");
1464 :
1465 131088 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][2][0][0]));
1466 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1467 131088 : asm volatile ("pshufb %xmm4,%xmm3");
1468 131088 : asm volatile ("pshufb %xmm5,%xmm7");
1469 131088 : asm volatile ("pxor %xmm7,%xmm3");
1470 :
1471 : /* intermediate disks */
1472 918000 : for (d = l - 1; d > 0; --d) {
1473 786912 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1474 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1475 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1476 :
1477 786912 : asm volatile ("pxor %xmm5,%xmm5");
1478 786912 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1479 786912 : asm volatile ("paddb %xmm0,%xmm0");
1480 786912 : asm volatile ("pand %xmm7,%xmm5");
1481 786912 : asm volatile ("pxor %xmm5,%xmm0");
1482 :
1483 786912 : asm volatile ("pxor %xmm4,%xmm0");
1484 786912 : asm volatile ("pxor %xmm4,%xmm6");
1485 786912 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[0]));
1486 :
1487 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1488 786912 : asm volatile ("movdqa %xmm4,%xmm5");
1489 786912 : asm volatile ("psrlw $4,%xmm5");
1490 786912 : asm volatile ("pand %xmm7,%xmm4");
1491 786912 : asm volatile ("pand %xmm7,%xmm5");
1492 :
1493 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1494 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1495 786912 : asm volatile ("pshufb %xmm4,%xmm6");
1496 786912 : asm volatile ("pshufb %xmm5,%xmm7");
1497 786912 : asm volatile ("pxor %xmm6,%xmm1");
1498 786912 : asm volatile ("pxor %xmm7,%xmm1");
1499 :
1500 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1501 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1502 786912 : asm volatile ("pshufb %xmm4,%xmm6");
1503 786912 : asm volatile ("pshufb %xmm5,%xmm7");
1504 786912 : asm volatile ("pxor %xmm6,%xmm2");
1505 786912 : asm volatile ("pxor %xmm7,%xmm2");
1506 :
1507 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1508 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1509 786912 : asm volatile ("pshufb %xmm4,%xmm6");
1510 786912 : asm volatile ("pshufb %xmm5,%xmm7");
1511 786912 : asm volatile ("pxor %xmm6,%xmm3");
1512 786912 : asm volatile ("pxor %xmm7,%xmm3");
1513 : }
1514 :
1515 : /* first disk with all coefficients at 1 */
1516 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1517 131088 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1518 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1519 :
1520 131088 : asm volatile ("pxor %xmm5,%xmm5");
1521 131088 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1522 131088 : asm volatile ("paddb %xmm0,%xmm0");
1523 131088 : asm volatile ("pand %xmm7,%xmm5");
1524 131088 : asm volatile ("pxor %xmm5,%xmm0");
1525 :
1526 131088 : asm volatile ("pxor %xmm4,%xmm0");
1527 131088 : asm volatile ("pxor %xmm4,%xmm1");
1528 131088 : asm volatile ("pxor %xmm4,%xmm2");
1529 131088 : asm volatile ("pxor %xmm4,%xmm3");
1530 131088 : asm volatile ("pxor %xmm4,%xmm6");
1531 :
1532 131088 : asm volatile ("movntdq %%xmm6,%0" : "=m" (p[i]));
1533 131088 : asm volatile ("movntdq %%xmm0,%0" : "=m" (q[i]));
1534 131088 : asm volatile ("movntdq %%xmm1,%0" : "=m" (r[i]));
1535 131088 : asm volatile ("movntdq %%xmm2,%0" : "=m" (s[i]));
1536 131088 : asm volatile ("movntdq %%xmm3,%0" : "=m" (t[i]));
1537 : }
1538 :
1539 : raid_sse_end();
1540 : }
1541 : #endif
1542 :
1543 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
1544 : /*
1545 : * GEN5 (penta parity with Cauchy matrix) SSSE3 implementation
1546 : *
1547 : * Note that it uses 16 registers, meaning that x64 is required.
1548 : */
1549 37382 : void raid_gen5_ssse3ext(int nd, size_t size, void **vv)
1550 : {
1551 37382 : uint8_t **v = (uint8_t **)vv;
1552 : uint8_t *p;
1553 : uint8_t *q;
1554 : uint8_t *r;
1555 : uint8_t *s;
1556 : uint8_t *t;
1557 : int d, l;
1558 : size_t i;
1559 :
1560 37382 : l = nd - 1;
1561 37382 : p = v[nd];
1562 37382 : q = v[nd + 1];
1563 37382 : r = v[nd + 2];
1564 37382 : s = v[nd + 3];
1565 37382 : t = v[nd + 4];
1566 :
1567 : /* special case with only one data disk */
1568 37382 : if (l == 0) {
1569 6 : for (i = 0; i < 5; ++i)
1570 5 : memcpy(v[1 + i], v[0], size);
1571 1 : return;
1572 : }
1573 :
1574 : raid_sse_begin();
1575 :
1576 : /* generic case with at least two data disks */
1577 37381 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1578 37381 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1579 :
1580 2625557 : for (i = 0; i < size; i += 16) {
1581 : /* last disk without the by two multiplication */
1582 2588176 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1583 :
1584 2588176 : asm volatile ("movdqa %xmm10,%xmm0");
1585 2588176 : asm volatile ("movdqa %xmm10,%xmm1");
1586 :
1587 2588176 : asm volatile ("movdqa %xmm10,%xmm11");
1588 2588176 : asm volatile ("psrlw $4,%xmm11");
1589 2588176 : asm volatile ("pand %xmm15,%xmm10");
1590 2588176 : asm volatile ("pand %xmm15,%xmm11");
1591 :
1592 2588176 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1593 2588176 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1594 2588176 : asm volatile ("pshufb %xmm10,%xmm2");
1595 2588176 : asm volatile ("pshufb %xmm11,%xmm13");
1596 2588176 : asm volatile ("pxor %xmm13,%xmm2");
1597 :
1598 2588176 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1599 2588176 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1600 2588176 : asm volatile ("pshufb %xmm10,%xmm3");
1601 2588176 : asm volatile ("pshufb %xmm11,%xmm13");
1602 2588176 : asm volatile ("pxor %xmm13,%xmm3");
1603 :
1604 2588176 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1605 2588176 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1606 2588176 : asm volatile ("pshufb %xmm10,%xmm4");
1607 2588176 : asm volatile ("pshufb %xmm11,%xmm13");
1608 2588176 : asm volatile ("pxor %xmm13,%xmm4");
1609 :
1610 : /* intermediate disks */
1611 13334512 : for (d = l - 1; d > 0; --d) {
1612 10746336 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1613 :
1614 10746336 : asm volatile ("pxor %xmm11,%xmm11");
1615 10746336 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1616 10746336 : asm volatile ("paddb %xmm1,%xmm1");
1617 10746336 : asm volatile ("pand %xmm14,%xmm11");
1618 10746336 : asm volatile ("pxor %xmm11,%xmm1");
1619 :
1620 10746336 : asm volatile ("pxor %xmm10,%xmm0");
1621 10746336 : asm volatile ("pxor %xmm10,%xmm1");
1622 :
1623 10746336 : asm volatile ("movdqa %xmm10,%xmm11");
1624 10746336 : asm volatile ("psrlw $4,%xmm11");
1625 10746336 : asm volatile ("pand %xmm15,%xmm10");
1626 10746336 : asm volatile ("pand %xmm15,%xmm11");
1627 :
1628 10746336 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1629 10746336 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1630 10746336 : asm volatile ("pshufb %xmm10,%xmm12");
1631 10746336 : asm volatile ("pshufb %xmm11,%xmm13");
1632 10746336 : asm volatile ("pxor %xmm12,%xmm2");
1633 10746336 : asm volatile ("pxor %xmm13,%xmm2");
1634 :
1635 10746336 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1636 10746336 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1637 10746336 : asm volatile ("pshufb %xmm10,%xmm12");
1638 10746336 : asm volatile ("pshufb %xmm11,%xmm13");
1639 10746336 : asm volatile ("pxor %xmm12,%xmm3");
1640 10746336 : asm volatile ("pxor %xmm13,%xmm3");
1641 :
1642 10746336 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1643 10746336 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1644 10746336 : asm volatile ("pshufb %xmm10,%xmm12");
1645 10746336 : asm volatile ("pshufb %xmm11,%xmm13");
1646 10746336 : asm volatile ("pxor %xmm12,%xmm4");
1647 10746336 : asm volatile ("pxor %xmm13,%xmm4");
1648 : }
1649 :
1650 : /* first disk with all coefficients at 1 */
1651 2588176 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1652 :
1653 2588176 : asm volatile ("pxor %xmm11,%xmm11");
1654 2588176 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1655 2588176 : asm volatile ("paddb %xmm1,%xmm1");
1656 2588176 : asm volatile ("pand %xmm14,%xmm11");
1657 2588176 : asm volatile ("pxor %xmm11,%xmm1");
1658 :
1659 2588176 : asm volatile ("pxor %xmm10,%xmm0");
1660 2588176 : asm volatile ("pxor %xmm10,%xmm1");
1661 2588176 : asm volatile ("pxor %xmm10,%xmm2");
1662 2588176 : asm volatile ("pxor %xmm10,%xmm3");
1663 2588176 : asm volatile ("pxor %xmm10,%xmm4");
1664 :
1665 2588176 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1666 2588176 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1667 2588176 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1668 2588176 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1669 2588176 : asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
1670 : }
1671 :
1672 : raid_sse_end();
1673 : }
1674 : #endif
1675 :
1676 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
1677 : /*
1678 : * GEN5 (penta parity with Cauchy matrix) AVX2 implementation
1679 : *
1680 : * Note that it uses 16 registers, meaning that x64 is required.
1681 : */
1682 6 : void raid_gen5_avx2ext(int nd, size_t size, void **vv)
1683 : {
1684 6 : uint8_t **v = (uint8_t **)vv;
1685 : uint8_t *p;
1686 : uint8_t *q;
1687 : uint8_t *r;
1688 : uint8_t *s;
1689 : uint8_t *t;
1690 : int d, l;
1691 : size_t i;
1692 :
1693 6 : l = nd - 1;
1694 6 : p = v[nd];
1695 6 : q = v[nd + 1];
1696 6 : r = v[nd + 2];
1697 6 : s = v[nd + 3];
1698 6 : t = v[nd + 4];
1699 :
1700 : /* special case with only one data disk */
1701 6 : if (l == 0) {
1702 6 : for (i = 0; i < 5; ++i)
1703 5 : memcpy(v[1 + i], v[0], size);
1704 1 : return;
1705 : }
1706 :
1707 : raid_avx_begin();
1708 :
1709 : /* generic case with at least two data disks */
1710 5 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
1711 5 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
1712 5 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1713 :
1714 32781 : for (i = 0; i < size; i += 32) {
1715 : /* last disk without the by two multiplication */
1716 32776 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
1717 :
1718 32776 : asm volatile ("vmovdqa %ymm10,%ymm0");
1719 32776 : asm volatile ("vmovdqa %ymm10,%ymm1");
1720 :
1721 32776 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1722 32776 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1723 32776 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1724 :
1725 32776 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
1726 32776 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
1727 32776 : asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
1728 32776 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1729 32776 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1730 :
1731 32776 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
1732 32776 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
1733 32776 : asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
1734 32776 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1735 32776 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1736 :
1737 32776 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
1738 32776 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
1739 32776 : asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
1740 32776 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1741 32776 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1742 :
1743 : /* intermediate disks */
1744 229624 : for (d = l - 1; d > 0; --d) {
1745 196848 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
1746 :
1747 196848 : asm volatile ("vpcmpgtb %ymm1,%ymm6,%ymm11");
1748 196848 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1749 196848 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1750 196848 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1751 :
1752 196848 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1753 196848 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1754 :
1755 196848 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1756 196848 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1757 196848 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1758 :
1759 196848 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
1760 196848 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
1761 196848 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1762 196848 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1763 196848 : asm volatile ("vpxor %ymm12,%ymm2,%ymm2");
1764 196848 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1765 :
1766 196848 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
1767 196848 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
1768 196848 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1769 196848 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1770 196848 : asm volatile ("vpxor %ymm12,%ymm3,%ymm3");
1771 196848 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1772 :
1773 196848 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
1774 196848 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
1775 196848 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1776 196848 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1777 196848 : asm volatile ("vpxor %ymm12,%ymm4,%ymm4");
1778 196848 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1779 : }
1780 :
1781 : /* first disk with all coefficients at 1 */
1782 32776 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
1783 :
1784 32776 : asm volatile ("vpcmpgtb %ymm1,%ymm6,%ymm11");
1785 32776 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1786 32776 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1787 32776 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1788 :
1789 32776 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1790 32776 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1791 32776 : asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
1792 32776 : asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
1793 32776 : asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
1794 :
1795 32776 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1796 32776 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1797 32776 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1798 32776 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1799 32776 : asm volatile ("vmovntdq %%ymm4,%0" : "=m" (t[i]));
1800 : }
1801 :
1802 : raid_avx_end();
1803 : }
1804 : #endif
1805 :
1806 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
1807 : /*
1808 : * GEN5 (penta parity with Cauchy matrix) AVX512BW implementation
1809 : */
1810 17482 : void raid_gen5_avx512bw(int nd, size_t size, void **vv)
1811 : {
1812 17482 : uint8_t **v = (uint8_t **)vv;
1813 : uint8_t *p;
1814 : uint8_t *q;
1815 : uint8_t *r;
1816 : uint8_t *s;
1817 : uint8_t *t;
1818 : int d, l;
1819 : size_t i;
1820 :
1821 17482 : l = nd - 1;
1822 17482 : p = v[nd];
1823 17482 : q = v[nd + 1];
1824 17482 : r = v[nd + 2];
1825 17482 : s = v[nd + 3];
1826 17482 : t = v[nd + 4];
1827 :
1828 : /* special case with only one data disk */
1829 17482 : if (l == 0) {
1830 6 : for (i = 0; i < 5; ++i)
1831 5 : memcpy(v[1 + i], v[0], size);
1832 1 : return;
1833 : }
1834 :
1835 : raid_avx_begin();
1836 :
1837 : /* generic case with at least two data disks */
1838 17481 : asm volatile ("vpxorq %zmm6,%zmm6,%zmm6");
1839 17481 : asm volatile ("vbroadcasti32x4 %0,%%zmm14" : : "m" (gfconst16.poly[0]));
1840 17481 : asm volatile ("vbroadcasti32x4 %0,%%zmm15" : : "m" (gfconst16.low4[0]));
1841 :
1842 95949 : for (i = 0; i < size; i += 64) {
1843 : /* last disk without the by two multiplication */
1844 78468 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[l][i]));
1845 :
1846 78468 : asm volatile ("vmovdqa64 %zmm10,%zmm0");
1847 78468 : asm volatile ("vmovdqa64 %zmm10,%zmm1");
1848 :
1849 78468 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
1850 78468 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
1851 78468 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
1852 :
1853 78468 : asm volatile ("vbroadcasti32x4 %0,%%zmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1854 78468 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1855 78468 : asm volatile ("vpshufb %zmm10,%zmm2,%zmm2");
1856 78468 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1857 78468 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
1858 :
1859 78468 : asm volatile ("vbroadcasti32x4 %0,%%zmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1860 78468 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1861 78468 : asm volatile ("vpshufb %zmm10,%zmm3,%zmm3");
1862 78468 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1863 78468 : asm volatile ("vpxorq %zmm13,%zmm3,%zmm3");
1864 :
1865 78468 : asm volatile ("vbroadcasti32x4 %0,%%zmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1866 78468 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1867 78468 : asm volatile ("vpshufb %zmm10,%zmm4,%zmm4");
1868 78468 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1869 78468 : asm volatile ("vpxorq %zmm13,%zmm4,%zmm4");
1870 :
1871 : /* intermediate disks */
1872 831996 : for (d = l - 1; d > 0; --d) {
1873 753528 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[d][i]));
1874 :
1875 753528 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
1876 753528 : asm volatile ("vpmovm2b %k1,%zmm11");
1877 753528 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
1878 753528 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
1879 753528 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
1880 :
1881 753528 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
1882 753528 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
1883 :
1884 753528 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
1885 753528 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
1886 753528 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
1887 :
1888 753528 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1889 753528 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1890 753528 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
1891 753528 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1892 753528 : asm volatile ("vpxorq %zmm12,%zmm2,%zmm2");
1893 753528 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
1894 :
1895 753528 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1896 753528 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1897 753528 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
1898 753528 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1899 753528 : asm volatile ("vpxorq %zmm12,%zmm3,%zmm3");
1900 753528 : asm volatile ("vpxorq %zmm13,%zmm3,%zmm3");
1901 :
1902 753528 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1903 753528 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1904 753528 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
1905 753528 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
1906 753528 : asm volatile ("vpxorq %zmm12,%zmm4,%zmm4");
1907 753528 : asm volatile ("vpxorq %zmm13,%zmm4,%zmm4");
1908 : }
1909 :
1910 : /* first disk with all coefficients at 1 */
1911 78468 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[0][i]));
1912 :
1913 78468 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
1914 78468 : asm volatile ("vpmovm2b %k1,%zmm11");
1915 78468 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
1916 78468 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
1917 78468 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
1918 :
1919 78468 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
1920 78468 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
1921 78468 : asm volatile ("vpxorq %zmm10,%zmm2,%zmm2");
1922 78468 : asm volatile ("vpxorq %zmm10,%zmm3,%zmm3");
1923 78468 : asm volatile ("vpxorq %zmm10,%zmm4,%zmm4");
1924 :
1925 78468 : asm volatile ("vmovntdq %%zmm0,%0" : "=m" (p[i]));
1926 78468 : asm volatile ("vmovntdq %%zmm1,%0" : "=m" (q[i]));
1927 78468 : asm volatile ("vmovntdq %%zmm2,%0" : "=m" (r[i]));
1928 78468 : asm volatile ("vmovntdq %%zmm3,%0" : "=m" (s[i]));
1929 78468 : asm volatile ("vmovntdq %%zmm4,%0" : "=m" (t[i]));
1930 : }
1931 :
1932 : raid_avx_end();
1933 : }
1934 : #endif
1935 :
1936 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
1937 : /*
1938 : * GEN6 (hexa parity with Cauchy matrix) SSSE3 implementation
1939 : */
1940 10 : void raid_gen6_ssse3(int nd, size_t size, void **vv)
1941 : {
1942 10 : uint8_t **v = (uint8_t **)vv;
1943 : uint8_t *p;
1944 : uint8_t *q;
1945 : uint8_t *r;
1946 : uint8_t *s;
1947 : uint8_t *t;
1948 : uint8_t *u;
1949 : int d, l;
1950 : size_t i;
1951 : uint8_t buffer[2*16+16];
1952 10 : uint8_t *pd = __align_ptr(buffer, 16);
1953 :
1954 10 : l = nd - 1;
1955 10 : p = v[nd];
1956 10 : q = v[nd + 1];
1957 10 : r = v[nd + 2];
1958 10 : s = v[nd + 3];
1959 10 : t = v[nd + 4];
1960 10 : u = v[nd + 5];
1961 :
1962 : /* special case with only one data disk */
1963 10 : if (l == 0) {
1964 7 : for (i = 0; i < 6; ++i)
1965 6 : memcpy(v[1 + i], v[0], size);
1966 1 : return;
1967 : }
1968 :
1969 : raid_sse_begin();
1970 :
1971 : /* generic case with at least two data disks */
1972 131097 : for (i = 0; i < size; i += 16) {
1973 : /* last disk without the by two multiplication */
1974 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1975 :
1976 131088 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1977 131088 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[16]));
1978 :
1979 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1980 131088 : asm volatile ("movdqa %xmm4,%xmm5");
1981 131088 : asm volatile ("psrlw $4,%xmm5");
1982 131088 : asm volatile ("pand %xmm7,%xmm4");
1983 131088 : asm volatile ("pand %xmm7,%xmm5");
1984 :
1985 131088 : asm volatile ("movdqa %0,%%xmm0" : : "m" (gfgenpshufb[l][0][0][0]));
1986 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1987 131088 : asm volatile ("pshufb %xmm4,%xmm0");
1988 131088 : asm volatile ("pshufb %xmm5,%xmm7");
1989 131088 : asm volatile ("pxor %xmm7,%xmm0");
1990 :
1991 131088 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][1][0][0]));
1992 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1993 131088 : asm volatile ("pshufb %xmm4,%xmm1");
1994 131088 : asm volatile ("pshufb %xmm5,%xmm7");
1995 131088 : asm volatile ("pxor %xmm7,%xmm1");
1996 :
1997 131088 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][2][0][0]));
1998 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1999 131088 : asm volatile ("pshufb %xmm4,%xmm2");
2000 131088 : asm volatile ("pshufb %xmm5,%xmm7");
2001 131088 : asm volatile ("pxor %xmm7,%xmm2");
2002 :
2003 131088 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][3][0][0]));
2004 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][3][1][0]));
2005 131088 : asm volatile ("pshufb %xmm4,%xmm3");
2006 131088 : asm volatile ("pshufb %xmm5,%xmm7");
2007 131088 : asm volatile ("pxor %xmm7,%xmm3");
2008 :
2009 : /* intermediate disks */
2010 918000 : for (d = l - 1; d > 0; --d) {
2011 786912 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
2012 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
2013 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
2014 :
2015 786912 : asm volatile ("pxor %xmm4,%xmm4");
2016 786912 : asm volatile ("pcmpgtb %xmm6,%xmm4");
2017 786912 : asm volatile ("paddb %xmm6,%xmm6");
2018 786912 : asm volatile ("pand %xmm7,%xmm4");
2019 786912 : asm volatile ("pxor %xmm4,%xmm6");
2020 :
2021 786912 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
2022 :
2023 786912 : asm volatile ("pxor %xmm4,%xmm5");
2024 786912 : asm volatile ("pxor %xmm4,%xmm6");
2025 786912 : asm volatile ("movdqa %%xmm5,%0" : "=m" (pd[0]));
2026 786912 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[16]));
2027 :
2028 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2029 786912 : asm volatile ("movdqa %xmm4,%xmm5");
2030 786912 : asm volatile ("psrlw $4,%xmm5");
2031 786912 : asm volatile ("pand %xmm7,%xmm4");
2032 786912 : asm volatile ("pand %xmm7,%xmm5");
2033 :
2034 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
2035 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
2036 786912 : asm volatile ("pshufb %xmm4,%xmm6");
2037 786912 : asm volatile ("pshufb %xmm5,%xmm7");
2038 786912 : asm volatile ("pxor %xmm6,%xmm0");
2039 786912 : asm volatile ("pxor %xmm7,%xmm0");
2040 :
2041 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
2042 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
2043 786912 : asm volatile ("pshufb %xmm4,%xmm6");
2044 786912 : asm volatile ("pshufb %xmm5,%xmm7");
2045 786912 : asm volatile ("pxor %xmm6,%xmm1");
2046 786912 : asm volatile ("pxor %xmm7,%xmm1");
2047 :
2048 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
2049 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
2050 786912 : asm volatile ("pshufb %xmm4,%xmm6");
2051 786912 : asm volatile ("pshufb %xmm5,%xmm7");
2052 786912 : asm volatile ("pxor %xmm6,%xmm2");
2053 786912 : asm volatile ("pxor %xmm7,%xmm2");
2054 :
2055 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][3][0][0]));
2056 786912 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][3][1][0]));
2057 786912 : asm volatile ("pshufb %xmm4,%xmm6");
2058 786912 : asm volatile ("pshufb %xmm5,%xmm7");
2059 786912 : asm volatile ("pxor %xmm6,%xmm3");
2060 786912 : asm volatile ("pxor %xmm7,%xmm3");
2061 : }
2062 :
2063 : /* first disk with all coefficients at 1 */
2064 131088 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
2065 131088 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
2066 131088 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
2067 :
2068 131088 : asm volatile ("pxor %xmm4,%xmm4");
2069 131088 : asm volatile ("pcmpgtb %xmm6,%xmm4");
2070 131088 : asm volatile ("paddb %xmm6,%xmm6");
2071 131088 : asm volatile ("pand %xmm7,%xmm4");
2072 131088 : asm volatile ("pxor %xmm4,%xmm6");
2073 :
2074 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
2075 131088 : asm volatile ("pxor %xmm4,%xmm0");
2076 131088 : asm volatile ("pxor %xmm4,%xmm1");
2077 131088 : asm volatile ("pxor %xmm4,%xmm2");
2078 131088 : asm volatile ("pxor %xmm4,%xmm3");
2079 131088 : asm volatile ("pxor %xmm4,%xmm5");
2080 131088 : asm volatile ("pxor %xmm4,%xmm6");
2081 :
2082 131088 : asm volatile ("movntdq %%xmm5,%0" : "=m" (p[i]));
2083 131088 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i]));
2084 131088 : asm volatile ("movntdq %%xmm0,%0" : "=m" (r[i]));
2085 131088 : asm volatile ("movntdq %%xmm1,%0" : "=m" (s[i]));
2086 131088 : asm volatile ("movntdq %%xmm2,%0" : "=m" (t[i]));
2087 131088 : asm volatile ("movntdq %%xmm3,%0" : "=m" (u[i]));
2088 : }
2089 :
2090 : raid_sse_end();
2091 : }
2092 : #endif
2093 :
2094 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
2095 : /*
2096 : * GEN6 (hexa parity with Cauchy matrix) SSSE3 implementation
2097 : *
2098 : * Note that it uses 16 registers, meaning that x64 is required.
2099 : */
2100 539878 : void raid_gen6_ssse3ext(int nd, size_t size, void **vv)
2101 : {
2102 539878 : uint8_t **v = (uint8_t **)vv;
2103 : uint8_t *p;
2104 : uint8_t *q;
2105 : uint8_t *r;
2106 : uint8_t *s;
2107 : uint8_t *t;
2108 : uint8_t *u;
2109 : int d, l;
2110 : size_t i;
2111 :
2112 539878 : l = nd - 1;
2113 539878 : p = v[nd];
2114 539878 : q = v[nd + 1];
2115 539878 : r = v[nd + 2];
2116 539878 : s = v[nd + 3];
2117 539878 : t = v[nd + 4];
2118 539878 : u = v[nd + 5];
2119 :
2120 : /* special case with only one data disk */
2121 539878 : if (l == 0) {
2122 7 : for (i = 0; i < 6; ++i)
2123 6 : memcpy(v[1 + i], v[0], size);
2124 1 : return;
2125 : }
2126 :
2127 : raid_sse_begin();
2128 :
2129 : /* generic case with at least two data disks */
2130 539877 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
2131 539877 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
2132 :
2133 35287797 : for (i = 0; i < size; i += 16) {
2134 : /* last disk without the by two multiplication */
2135 34747920 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
2136 :
2137 34747920 : asm volatile ("movdqa %xmm10,%xmm0");
2138 34747920 : asm volatile ("movdqa %xmm10,%xmm1");
2139 :
2140 34747920 : asm volatile ("movdqa %xmm10,%xmm11");
2141 34747920 : asm volatile ("psrlw $4,%xmm11");
2142 34747920 : asm volatile ("pand %xmm15,%xmm10");
2143 34747920 : asm volatile ("pand %xmm15,%xmm11");
2144 :
2145 34747920 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
2146 34747920 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
2147 34747920 : asm volatile ("pshufb %xmm10,%xmm2");
2148 34747920 : asm volatile ("pshufb %xmm11,%xmm13");
2149 34747920 : asm volatile ("pxor %xmm13,%xmm2");
2150 :
2151 34747920 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
2152 34747920 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
2153 34747920 : asm volatile ("pshufb %xmm10,%xmm3");
2154 34747920 : asm volatile ("pshufb %xmm11,%xmm13");
2155 34747920 : asm volatile ("pxor %xmm13,%xmm3");
2156 :
2157 34747920 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
2158 34747920 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
2159 34747920 : asm volatile ("pshufb %xmm10,%xmm4");
2160 34747920 : asm volatile ("pshufb %xmm11,%xmm13");
2161 34747920 : asm volatile ("pxor %xmm13,%xmm4");
2162 :
2163 34747920 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfgenpshufb[l][3][0][0]));
2164 34747920 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][3][1][0]));
2165 34747920 : asm volatile ("pshufb %xmm10,%xmm5");
2166 34747920 : asm volatile ("pshufb %xmm11,%xmm13");
2167 34747920 : asm volatile ("pxor %xmm13,%xmm5");
2168 :
2169 : /* intermediate disks */
2170 174133232 : for (d = l - 1; d > 0; --d) {
2171 139385312 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
2172 :
2173 139385312 : asm volatile ("pxor %xmm11,%xmm11");
2174 139385312 : asm volatile ("pcmpgtb %xmm1,%xmm11");
2175 139385312 : asm volatile ("paddb %xmm1,%xmm1");
2176 139385312 : asm volatile ("pand %xmm14,%xmm11");
2177 139385312 : asm volatile ("pxor %xmm11,%xmm1");
2178 :
2179 139385312 : asm volatile ("pxor %xmm10,%xmm0");
2180 139385312 : asm volatile ("pxor %xmm10,%xmm1");
2181 :
2182 139385312 : asm volatile ("movdqa %xmm10,%xmm11");
2183 139385312 : asm volatile ("psrlw $4,%xmm11");
2184 139385312 : asm volatile ("pand %xmm15,%xmm10");
2185 139385312 : asm volatile ("pand %xmm15,%xmm11");
2186 :
2187 139385312 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
2188 139385312 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
2189 139385312 : asm volatile ("pshufb %xmm10,%xmm12");
2190 139385312 : asm volatile ("pshufb %xmm11,%xmm13");
2191 139385312 : asm volatile ("pxor %xmm12,%xmm2");
2192 139385312 : asm volatile ("pxor %xmm13,%xmm2");
2193 :
2194 139385312 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
2195 139385312 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
2196 139385312 : asm volatile ("pshufb %xmm10,%xmm12");
2197 139385312 : asm volatile ("pshufb %xmm11,%xmm13");
2198 139385312 : asm volatile ("pxor %xmm12,%xmm3");
2199 139385312 : asm volatile ("pxor %xmm13,%xmm3");
2200 :
2201 139385312 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
2202 139385312 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
2203 139385312 : asm volatile ("pshufb %xmm10,%xmm12");
2204 139385312 : asm volatile ("pshufb %xmm11,%xmm13");
2205 139385312 : asm volatile ("pxor %xmm12,%xmm4");
2206 139385312 : asm volatile ("pxor %xmm13,%xmm4");
2207 :
2208 139385312 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][3][0][0]));
2209 139385312 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][3][1][0]));
2210 139385312 : asm volatile ("pshufb %xmm10,%xmm12");
2211 139385312 : asm volatile ("pshufb %xmm11,%xmm13");
2212 139385312 : asm volatile ("pxor %xmm12,%xmm5");
2213 139385312 : asm volatile ("pxor %xmm13,%xmm5");
2214 : }
2215 :
2216 : /* first disk with all coefficients at 1 */
2217 34747920 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
2218 :
2219 34747920 : asm volatile ("pxor %xmm11,%xmm11");
2220 34747920 : asm volatile ("pcmpgtb %xmm1,%xmm11");
2221 34747920 : asm volatile ("paddb %xmm1,%xmm1");
2222 34747920 : asm volatile ("pand %xmm14,%xmm11");
2223 34747920 : asm volatile ("pxor %xmm11,%xmm1");
2224 :
2225 34747920 : asm volatile ("pxor %xmm10,%xmm0");
2226 34747920 : asm volatile ("pxor %xmm10,%xmm1");
2227 34747920 : asm volatile ("pxor %xmm10,%xmm2");
2228 34747920 : asm volatile ("pxor %xmm10,%xmm3");
2229 34747920 : asm volatile ("pxor %xmm10,%xmm4");
2230 34747920 : asm volatile ("pxor %xmm10,%xmm5");
2231 :
2232 34747920 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
2233 34747920 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
2234 34747920 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
2235 34747920 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
2236 34747920 : asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
2237 34747920 : asm volatile ("movntdq %%xmm5,%0" : "=m" (u[i]));
2238 : }
2239 :
2240 : raid_sse_end();
2241 : }
2242 : #endif
2243 :
2244 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
2245 : /*
2246 : * GEN6 (hexa parity with Cauchy matrix) AVX2 implementation
2247 : *
2248 : * Note that it uses 16 registers, meaning that x64 is required.
2249 : */
2250 6 : void raid_gen6_avx2ext(int nd, size_t size, void **vv)
2251 : {
2252 6 : uint8_t **v = (uint8_t **)vv;
2253 : uint8_t *p;
2254 : uint8_t *q;
2255 : uint8_t *r;
2256 : uint8_t *s;
2257 : uint8_t *t;
2258 : uint8_t *u;
2259 : int d, l;
2260 : size_t i;
2261 :
2262 6 : l = nd - 1;
2263 6 : p = v[nd];
2264 6 : q = v[nd + 1];
2265 6 : r = v[nd + 2];
2266 6 : s = v[nd + 3];
2267 6 : t = v[nd + 4];
2268 6 : u = v[nd + 5];
2269 :
2270 : /* special case with only one data disk */
2271 6 : if (l == 0) {
2272 7 : for (i = 0; i < 6; ++i)
2273 6 : memcpy(v[1 + i], v[0], size);
2274 1 : return;
2275 : }
2276 :
2277 : raid_avx_begin();
2278 :
2279 : /*
2280 : * Register mapping:
2281 : *
2282 : * 0,1,2,3,4,5 PARITY
2283 : * 6 ZERO
2284 : * 10,11 MUL BY 2
2285 : * 12,13 PSHUFB
2286 : * 14 POLY
2287 : * 15 LOW4
2288 : */
2289 :
2290 : /* generic case with at least two data disks */
2291 5 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
2292 5 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
2293 5 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
2294 :
2295 32781 : for (i = 0; i < size; i += 32) {
2296 : /* last disk without the by two multiplication */
2297 32776 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
2298 :
2299 32776 : asm volatile ("vmovdqa %ymm10,%ymm0");
2300 32776 : asm volatile ("vmovdqa %ymm10,%ymm1");
2301 :
2302 32776 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
2303 32776 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
2304 32776 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
2305 :
2306 32776 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
2307 32776 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
2308 32776 : asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
2309 32776 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2310 32776 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
2311 :
2312 32776 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
2313 32776 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
2314 32776 : asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
2315 32776 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2316 32776 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
2317 :
2318 32776 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
2319 32776 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
2320 32776 : asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
2321 32776 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2322 32776 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
2323 :
2324 32776 : asm volatile ("vbroadcasti128 %0,%%ymm5" : : "m" (gfgenpshufb[l][3][0][0]));
2325 32776 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][3][1][0]));
2326 32776 : asm volatile ("vpshufb %ymm10,%ymm5,%ymm5");
2327 32776 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2328 32776 : asm volatile ("vpxor %ymm13,%ymm5,%ymm5");
2329 :
2330 : /* intermediate disks */
2331 229624 : for (d = l - 1; d > 0; --d) {
2332 196848 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
2333 :
2334 196848 : asm volatile ("vpcmpgtb %ymm1,%ymm6,%ymm11");
2335 196848 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
2336 196848 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
2337 196848 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
2338 :
2339 196848 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
2340 196848 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
2341 :
2342 196848 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
2343 196848 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
2344 196848 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
2345 :
2346 196848 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
2347 196848 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
2348 196848 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
2349 196848 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2350 196848 : asm volatile ("vpxor %ymm12,%ymm2,%ymm2");
2351 196848 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
2352 :
2353 196848 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
2354 196848 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
2355 196848 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
2356 196848 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2357 196848 : asm volatile ("vpxor %ymm12,%ymm3,%ymm3");
2358 196848 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
2359 :
2360 196848 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
2361 196848 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
2362 196848 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
2363 196848 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2364 196848 : asm volatile ("vpxor %ymm12,%ymm4,%ymm4");
2365 196848 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
2366 :
2367 196848 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][3][0][0]));
2368 196848 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][3][1][0]));
2369 196848 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
2370 196848 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
2371 196848 : asm volatile ("vpxor %ymm12,%ymm5,%ymm5");
2372 196848 : asm volatile ("vpxor %ymm13,%ymm5,%ymm5");
2373 : }
2374 :
2375 : /* first disk with all coefficients at 1 */
2376 32776 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
2377 :
2378 32776 : asm volatile ("vpcmpgtb %ymm1,%ymm6,%ymm11");
2379 32776 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
2380 32776 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
2381 32776 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
2382 :
2383 32776 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
2384 32776 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
2385 32776 : asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
2386 32776 : asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
2387 32776 : asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
2388 32776 : asm volatile ("vpxor %ymm10,%ymm5,%ymm5");
2389 :
2390 32776 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
2391 32776 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
2392 32776 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
2393 32776 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
2394 32776 : asm volatile ("vmovntdq %%ymm4,%0" : "=m" (t[i]));
2395 32776 : asm volatile ("vmovntdq %%ymm5,%0" : "=m" (u[i]));
2396 : }
2397 :
2398 : raid_avx_end();
2399 : }
2400 : #endif
2401 :
2402 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
2403 : /*
2404 : * GEN6 (hexa parity with Cauchy matrix) AVX512BW implementation
2405 : */
2406 49514 : void raid_gen6_avx512bw(int nd, size_t size, void **vv)
2407 : {
2408 49514 : uint8_t **v = (uint8_t **)vv;
2409 : uint8_t *p;
2410 : uint8_t *q;
2411 : uint8_t *r;
2412 : uint8_t *s;
2413 : uint8_t *t;
2414 : uint8_t *u;
2415 : int d, l;
2416 : size_t i;
2417 :
2418 49514 : l = nd - 1;
2419 49514 : p = v[nd];
2420 49514 : q = v[nd + 1];
2421 49514 : r = v[nd + 2];
2422 49514 : s = v[nd + 3];
2423 49514 : t = v[nd + 4];
2424 49514 : u = v[nd + 5];
2425 :
2426 : /* special case with only one data disk */
2427 49514 : if (l == 0) {
2428 7 : for (i = 0; i < 6; ++i)
2429 6 : memcpy(v[1 + i], v[0], size);
2430 1 : return;
2431 : }
2432 :
2433 : raid_avx_begin();
2434 :
2435 : /*
2436 : * Register mapping:
2437 : *
2438 : * 0,1,2,3,4,5 PARITY
2439 : * 6 ZERO
2440 : * 10,11 MUL BY 2
2441 : * 12,13 PSHUFB
2442 : * 14 POLY
2443 : * 15 LOW4
2444 : */
2445 :
2446 : /* generic case with at least two data disks */
2447 49513 : asm volatile ("vpxorq %zmm6,%zmm6,%zmm6");
2448 49513 : asm volatile ("vbroadcasti32x4 %0,%%zmm14" : : "m" (gfconst16.poly[0]));
2449 49513 : asm volatile ("vbroadcasti32x4 %0,%%zmm15" : : "m" (gfconst16.low4[0]));
2450 :
2451 256109 : for (i = 0; i < size; i += 64) {
2452 : /* last disk without the by two multiplication */
2453 206596 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[l][i]));
2454 :
2455 206596 : asm volatile ("vmovdqa64 %zmm10,%zmm0");
2456 206596 : asm volatile ("vmovdqa64 %zmm10,%zmm1");
2457 :
2458 206596 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
2459 206596 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
2460 206596 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
2461 :
2462 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm2" : : "m" (gfgenpshufb[l][0][0][0]));
2463 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][0][1][0]));
2464 206596 : asm volatile ("vpshufb %zmm10,%zmm2,%zmm2");
2465 206596 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2466 206596 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
2467 :
2468 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm3" : : "m" (gfgenpshufb[l][1][0][0]));
2469 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][1][1][0]));
2470 206596 : asm volatile ("vpshufb %zmm10,%zmm3,%zmm3");
2471 206596 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2472 206596 : asm volatile ("vpxorq %zmm13,%zmm3,%zmm3");
2473 :
2474 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm4" : : "m" (gfgenpshufb[l][2][0][0]));
2475 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][2][1][0]));
2476 206596 : asm volatile ("vpshufb %zmm10,%zmm4,%zmm4");
2477 206596 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2478 206596 : asm volatile ("vpxorq %zmm13,%zmm4,%zmm4");
2479 :
2480 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm5" : : "m" (gfgenpshufb[l][3][0][0]));
2481 206596 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[l][3][1][0]));
2482 206596 : asm volatile ("vpshufb %zmm10,%zmm5,%zmm5");
2483 206596 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2484 206596 : asm volatile ("vpxorq %zmm13,%zmm5,%zmm5");
2485 :
2486 : /* intermediate disks */
2487 2241404 : for (d = l - 1; d > 0; --d) {
2488 2034808 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[d][i]));
2489 :
2490 2034808 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
2491 2034808 : asm volatile ("vpmovm2b %k1,%zmm11");
2492 2034808 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
2493 2034808 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
2494 2034808 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
2495 :
2496 2034808 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
2497 2034808 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
2498 :
2499 2034808 : asm volatile ("vpsrlw $4,%zmm10,%zmm11");
2500 2034808 : asm volatile ("vpandq %zmm15,%zmm10,%zmm10");
2501 2034808 : asm volatile ("vpandq %zmm15,%zmm11,%zmm11");
2502 :
2503 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][0][0][0]));
2504 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][0][1][0]));
2505 2034808 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
2506 2034808 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2507 2034808 : asm volatile ("vpxorq %zmm12,%zmm2,%zmm2");
2508 2034808 : asm volatile ("vpxorq %zmm13,%zmm2,%zmm2");
2509 :
2510 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][1][0][0]));
2511 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][1][1][0]));
2512 2034808 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
2513 2034808 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2514 2034808 : asm volatile ("vpxorq %zmm12,%zmm3,%zmm3");
2515 2034808 : asm volatile ("vpxorq %zmm13,%zmm3,%zmm3");
2516 :
2517 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][2][0][0]));
2518 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][2][1][0]));
2519 2034808 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
2520 2034808 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2521 2034808 : asm volatile ("vpxorq %zmm12,%zmm4,%zmm4");
2522 2034808 : asm volatile ("vpxorq %zmm13,%zmm4,%zmm4");
2523 :
2524 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm12" : : "m" (gfgenpshufb[d][3][0][0]));
2525 2034808 : asm volatile ("vbroadcasti32x4 %0,%%zmm13" : : "m" (gfgenpshufb[d][3][1][0]));
2526 2034808 : asm volatile ("vpshufb %zmm10,%zmm12,%zmm12");
2527 2034808 : asm volatile ("vpshufb %zmm11,%zmm13,%zmm13");
2528 2034808 : asm volatile ("vpxorq %zmm12,%zmm5,%zmm5");
2529 2034808 : asm volatile ("vpxorq %zmm13,%zmm5,%zmm5");
2530 : }
2531 :
2532 : /* first disk with all coefficients at 1 */
2533 206596 : asm volatile ("vmovdqa64 %0,%%zmm10" : : "m" (v[0][i]));
2534 :
2535 206596 : asm volatile ("vpcmpgtb %zmm1,%zmm6,%k1");
2536 206596 : asm volatile ("vpmovm2b %k1,%zmm11");
2537 206596 : asm volatile ("vpaddb %zmm1,%zmm1,%zmm1");
2538 206596 : asm volatile ("vpandq %zmm14,%zmm11,%zmm11");
2539 206596 : asm volatile ("vpxorq %zmm11,%zmm1,%zmm1");
2540 :
2541 206596 : asm volatile ("vpxorq %zmm10,%zmm0,%zmm0");
2542 206596 : asm volatile ("vpxorq %zmm10,%zmm1,%zmm1");
2543 206596 : asm volatile ("vpxorq %zmm10,%zmm2,%zmm2");
2544 206596 : asm volatile ("vpxorq %zmm10,%zmm3,%zmm3");
2545 206596 : asm volatile ("vpxorq %zmm10,%zmm4,%zmm4");
2546 206596 : asm volatile ("vpxorq %zmm10,%zmm5,%zmm5");
2547 :
2548 206596 : asm volatile ("vmovntdq %%zmm0,%0" : "=m" (p[i]));
2549 206596 : asm volatile ("vmovntdq %%zmm1,%0" : "=m" (q[i]));
2550 206596 : asm volatile ("vmovntdq %%zmm2,%0" : "=m" (r[i]));
2551 206596 : asm volatile ("vmovntdq %%zmm3,%0" : "=m" (s[i]));
2552 206596 : asm volatile ("vmovntdq %%zmm4,%0" : "=m" (t[i]));
2553 206596 : asm volatile ("vmovntdq %%zmm5,%0" : "=m" (u[i]));
2554 : }
2555 :
2556 : raid_avx_end();
2557 : }
2558 : #endif
2559 :
2560 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
2561 : /*
2562 : * RAID recovering for one disk SSSE3 implementation
2563 : */
2564 111093 : void raid_rec1_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2565 : {
2566 111093 : uint8_t **v = (uint8_t **)vv;
2567 : uint8_t *p;
2568 : uint8_t *pa;
2569 : uint8_t G;
2570 : uint8_t V;
2571 : size_t i;
2572 :
2573 : (void)nr; /* unused, it's always 1 */
2574 :
2575 : /* if it's RAID5 uses the faster function */
2576 111093 : if (ip[0] == 0) {
2577 100930 : raid_rec1of1(id, nd, size, vv);
2578 100930 : return;
2579 : }
2580 :
2581 : /* setup the coefficients matrix */
2582 10163 : G = A(ip[0], id[0]);
2583 :
2584 : /* invert it to solve the system of linear equations */
2585 10163 : V = inv(G);
2586 :
2587 : /* compute delta parity */
2588 10163 : raid_delta_gen(1, id, ip, nd, size, vv);
2589 :
2590 10163 : p = v[nd + ip[0]];
2591 10163 : pa = v[id[0]];
2592 :
2593 : raid_sse_begin();
2594 :
2595 10163 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2596 10163 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfmulpshufb[V][0][0]));
2597 10163 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfmulpshufb[V][1][0]));
2598 :
2599 934003 : for (i = 0; i < size; i += 16) {
2600 923840 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[i]));
2601 923840 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[i]));
2602 923840 : asm volatile ("movdqa %xmm4,%xmm2");
2603 923840 : asm volatile ("movdqa %xmm5,%xmm3");
2604 923840 : asm volatile ("pxor %xmm0,%xmm1");
2605 923840 : asm volatile ("movdqa %xmm1,%xmm0");
2606 923840 : asm volatile ("psrlw $4,%xmm1");
2607 923840 : asm volatile ("pand %xmm7,%xmm0");
2608 923840 : asm volatile ("pand %xmm7,%xmm1");
2609 923840 : asm volatile ("pshufb %xmm0,%xmm2");
2610 923840 : asm volatile ("pshufb %xmm1,%xmm3");
2611 923840 : asm volatile ("pxor %xmm3,%xmm2");
2612 923840 : asm volatile ("movdqa %%xmm2,%0" : "=m" (pa[i]));
2613 : }
2614 :
2615 : raid_sse_end();
2616 : }
2617 : #endif
2618 :
2619 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
2620 : /*
2621 : * RAID recovering for two disks SSSE3 implementation
2622 : */
2623 43770 : void raid_rec2_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2624 43770 : {
2625 43770 : uint8_t **v = (uint8_t **)vv;
2626 43770 : const int N = 2;
2627 43770 : uint8_t *p[N];
2628 43770 : uint8_t *pa[N];
2629 43770 : uint8_t G[N * N];
2630 43770 : uint8_t V[N * N];
2631 : size_t i;
2632 : int j, k;
2633 :
2634 : (void)nr; /* unused, it's always 2 */
2635 :
2636 : /* setup the coefficients matrix */
2637 131310 : for (j = 0; j < N; ++j)
2638 262620 : for (k = 0; k < N; ++k)
2639 350160 : G[j * N + k] = A(ip[j], id[k]);
2640 :
2641 : /* invert it to solve the system of linear equations */
2642 43770 : raid_invert(G, V, N);
2643 :
2644 : /* compute delta parity */
2645 43770 : raid_delta_gen(N, id, ip, nd, size, vv);
2646 :
2647 131310 : for (j = 0; j < N; ++j) {
2648 87540 : p[j] = v[nd + ip[j]];
2649 87540 : pa[j] = v[id[j]];
2650 : }
2651 :
2652 : raid_sse_begin();
2653 :
2654 43770 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2655 :
2656 2918586 : for (i = 0; i < size; i += 16) {
2657 2874816 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[0][i]));
2658 2874816 : asm volatile ("movdqa %0,%%xmm2" : : "m" (pa[0][i]));
2659 2874816 : asm volatile ("movdqa %0,%%xmm1" : : "m" (p[1][i]));
2660 2874816 : asm volatile ("movdqa %0,%%xmm3" : : "m" (pa[1][i]));
2661 2874816 : asm volatile ("pxor %xmm2,%xmm0");
2662 2874816 : asm volatile ("pxor %xmm3,%xmm1");
2663 :
2664 2874816 : asm volatile ("pxor %xmm6,%xmm6");
2665 :
2666 2874816 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[0]][0][0]));
2667 2874816 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[0]][1][0]));
2668 2874816 : asm volatile ("movdqa %xmm0,%xmm4");
2669 2874816 : asm volatile ("movdqa %xmm0,%xmm5");
2670 2874816 : asm volatile ("psrlw $4,%xmm5");
2671 2874816 : asm volatile ("pand %xmm7,%xmm4");
2672 2874816 : asm volatile ("pand %xmm7,%xmm5");
2673 2874816 : asm volatile ("pshufb %xmm4,%xmm2");
2674 2874816 : asm volatile ("pshufb %xmm5,%xmm3");
2675 2874816 : asm volatile ("pxor %xmm2,%xmm6");
2676 2874816 : asm volatile ("pxor %xmm3,%xmm6");
2677 :
2678 2874816 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[1]][0][0]));
2679 2874816 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[1]][1][0]));
2680 2874816 : asm volatile ("movdqa %xmm1,%xmm4");
2681 2874816 : asm volatile ("movdqa %xmm1,%xmm5");
2682 2874816 : asm volatile ("psrlw $4,%xmm5");
2683 2874816 : asm volatile ("pand %xmm7,%xmm4");
2684 2874816 : asm volatile ("pand %xmm7,%xmm5");
2685 2874816 : asm volatile ("pshufb %xmm4,%xmm2");
2686 2874816 : asm volatile ("pshufb %xmm5,%xmm3");
2687 2874816 : asm volatile ("pxor %xmm2,%xmm6");
2688 2874816 : asm volatile ("pxor %xmm3,%xmm6");
2689 :
2690 2874816 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[0][i]));
2691 :
2692 2874816 : asm volatile ("pxor %xmm6,%xmm6");
2693 :
2694 2874816 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[2]][0][0]));
2695 2874816 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[2]][1][0]));
2696 2874816 : asm volatile ("movdqa %xmm0,%xmm4");
2697 2874816 : asm volatile ("movdqa %xmm0,%xmm5");
2698 2874816 : asm volatile ("psrlw $4,%xmm5");
2699 2874816 : asm volatile ("pand %xmm7,%xmm4");
2700 2874816 : asm volatile ("pand %xmm7,%xmm5");
2701 2874816 : asm volatile ("pshufb %xmm4,%xmm2");
2702 2874816 : asm volatile ("pshufb %xmm5,%xmm3");
2703 2874816 : asm volatile ("pxor %xmm2,%xmm6");
2704 2874816 : asm volatile ("pxor %xmm3,%xmm6");
2705 :
2706 2874816 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[3]][0][0]));
2707 2874816 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[3]][1][0]));
2708 2874816 : asm volatile ("movdqa %xmm1,%xmm4");
2709 2874816 : asm volatile ("movdqa %xmm1,%xmm5");
2710 2874816 : asm volatile ("psrlw $4,%xmm5");
2711 2874816 : asm volatile ("pand %xmm7,%xmm4");
2712 2874816 : asm volatile ("pand %xmm7,%xmm5");
2713 2874816 : asm volatile ("pshufb %xmm4,%xmm2");
2714 2874816 : asm volatile ("pshufb %xmm5,%xmm3");
2715 2874816 : asm volatile ("pxor %xmm2,%xmm6");
2716 2874816 : asm volatile ("pxor %xmm3,%xmm6");
2717 :
2718 2874816 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[1][i]));
2719 : }
2720 :
2721 : raid_sse_end();
2722 43770 : }
2723 : #endif
2724 :
2725 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
2726 : /*
2727 : * RAID recovering SSSE3 implementation
2728 : */
2729 92519 : void raid_recX_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2730 : {
2731 92519 : uint8_t **v = (uint8_t **)vv;
2732 92519 : int N = nr;
2733 : uint8_t *p[RAID_PARITY_MAX];
2734 : uint8_t *pa[RAID_PARITY_MAX];
2735 : uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
2736 : uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
2737 : uint8_t buffer[RAID_PARITY_MAX*16+16];
2738 92519 : uint8_t *pd = __align_ptr(buffer, 16);
2739 : size_t i;
2740 : int j, k;
2741 :
2742 : /* setup the coefficients matrix */
2743 487519 : for (j = 0; j < N; ++j)
2744 2200562 : for (k = 0; k < N; ++k)
2745 3611124 : G[j * N + k] = A(ip[j], id[k]);
2746 :
2747 : /* invert it to solve the system of linear equations */
2748 92519 : raid_invert(G, V, N);
2749 :
2750 : /* compute delta parity */
2751 92519 : raid_delta_gen(N, id, ip, nd, size, vv);
2752 :
2753 487519 : for (j = 0; j < N; ++j) {
2754 395000 : p[j] = v[nd + ip[j]];
2755 395000 : pa[j] = v[id[j]];
2756 : }
2757 :
2758 : raid_sse_begin();
2759 :
2760 92519 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2761 :
2762 5505847 : for (i = 0; i < size; i += 16) {
2763 : /* delta */
2764 28632016 : for (j = 0; j < N; ++j) {
2765 23218688 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[j][i]));
2766 23218688 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[j][i]));
2767 23218688 : asm volatile ("pxor %xmm1,%xmm0");
2768 23218688 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pd[j*16]));
2769 : }
2770 :
2771 : /* reconstruct */
2772 28632016 : for (j = 0; j < N; ++j) {
2773 23218688 : asm volatile ("pxor %xmm0,%xmm0");
2774 23218688 : asm volatile ("pxor %xmm1,%xmm1");
2775 :
2776 130240064 : for (k = 0; k < N; ++k) {
2777 107021376 : uint8_t m = V[j * N + k];
2778 :
2779 107021376 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[m][0][0]));
2780 107021376 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[m][1][0]));
2781 107021376 : asm volatile ("movdqa %0,%%xmm4" : : "m" (pd[k*16]));
2782 107021376 : asm volatile ("movdqa %xmm4,%xmm5");
2783 107021376 : asm volatile ("psrlw $4,%xmm5");
2784 107021376 : asm volatile ("pand %xmm7,%xmm4");
2785 107021376 : asm volatile ("pand %xmm7,%xmm5");
2786 107021376 : asm volatile ("pshufb %xmm4,%xmm2");
2787 107021376 : asm volatile ("pshufb %xmm5,%xmm3");
2788 107021376 : asm volatile ("pxor %xmm2,%xmm0");
2789 107021376 : asm volatile ("pxor %xmm3,%xmm1");
2790 : }
2791 :
2792 23218688 : asm volatile ("pxor %xmm1,%xmm0");
2793 23218688 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pa[j][i]));
2794 : }
2795 : }
2796 :
2797 : raid_sse_end();
2798 92519 : }
2799 : #endif
2800 :
2801 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
2802 : /*
2803 : * RAID recovering for one disk AVX2 implementation
2804 : */
2805 114 : void raid_rec1_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2806 : {
2807 114 : uint8_t **v = (uint8_t **)vv;
2808 : uint8_t *p;
2809 : uint8_t *pa;
2810 : uint8_t G;
2811 : uint8_t V;
2812 : size_t i;
2813 :
2814 : (void)nr; /* unused, it's always 1 */
2815 :
2816 : /* if it's RAID5 uses the faster function */
2817 114 : if (ip[0] == 0) {
2818 24 : raid_rec1of1(id, nd, size, vv);
2819 24 : return;
2820 : }
2821 :
2822 : /* setup the coefficients matrix */
2823 90 : G = A(ip[0], id[0]);
2824 :
2825 : /* invert it to solve the system of linear equations */
2826 90 : V = inv(G);
2827 :
2828 : /* compute delta parity */
2829 90 : raid_delta_gen(1, id, ip, nd, size, vv);
2830 :
2831 90 : p = v[nd + ip[0]];
2832 90 : pa = v[id[0]];
2833 :
2834 : raid_avx_begin();
2835 :
2836 90 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
2837 90 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfmulpshufb[V][0][0]));
2838 90 : asm volatile ("vbroadcasti128 %0,%%ymm5" : : "m" (gfmulpshufb[V][1][0]));
2839 :
2840 49914 : for (i = 0; i < size; i += 32) {
2841 49824 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[i]));
2842 49824 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (pa[i]));
2843 49824 : asm volatile ("vpxor %ymm1,%ymm0,%ymm0");
2844 49824 : asm volatile ("vpsrlw $4,%ymm0,%ymm1");
2845 49824 : asm volatile ("vpand %ymm7,%ymm0,%ymm0");
2846 49824 : asm volatile ("vpand %ymm7,%ymm1,%ymm1");
2847 49824 : asm volatile ("vpshufb %ymm0,%ymm4,%ymm2");
2848 49824 : asm volatile ("vpshufb %ymm1,%ymm5,%ymm3");
2849 49824 : asm volatile ("vpxor %ymm3,%ymm2,%ymm2");
2850 49824 : asm volatile ("vmovdqa %%ymm2,%0" : "=m" (pa[i]));
2851 : }
2852 :
2853 : raid_avx_end();
2854 : }
2855 : #endif
2856 :
2857 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
2858 : /*
2859 : * RAID recovering for two disks AVX2 implementation
2860 : */
2861 1190 : void raid_rec2_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2862 1190 : {
2863 1190 : uint8_t **v = (uint8_t **)vv;
2864 1190 : const int N = 2;
2865 1190 : uint8_t *p[N];
2866 1190 : uint8_t *pa[N];
2867 1190 : uint8_t G[N * N];
2868 1190 : uint8_t V[N * N];
2869 : size_t i;
2870 : int j, k;
2871 :
2872 : (void)nr; /* unused, it's always 2 */
2873 :
2874 : /* setup the coefficients matrix */
2875 3570 : for (j = 0; j < N; ++j)
2876 7140 : for (k = 0; k < N; ++k)
2877 9520 : G[j * N + k] = A(ip[j], id[k]);
2878 :
2879 : /* invert it to solve the system of linear equations */
2880 1190 : raid_invert(G, V, N);
2881 :
2882 : /* compute delta parity */
2883 1190 : raid_delta_gen(N, id, ip, nd, size, vv);
2884 :
2885 3570 : for (j = 0; j < N; ++j) {
2886 2380 : p[j] = v[nd + ip[j]];
2887 2380 : pa[j] = v[id[j]];
2888 : }
2889 :
2890 : raid_avx_begin();
2891 :
2892 1190 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
2893 :
2894 27078 : for (i = 0; i < size; i += 32) {
2895 25888 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[0][i]));
2896 25888 : asm volatile ("vmovdqa %0,%%ymm2" : : "m" (pa[0][i]));
2897 25888 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (p[1][i]));
2898 25888 : asm volatile ("vmovdqa %0,%%ymm3" : : "m" (pa[1][i]));
2899 25888 : asm volatile ("vpxor %ymm2,%ymm0,%ymm0");
2900 25888 : asm volatile ("vpxor %ymm3,%ymm1,%ymm1");
2901 :
2902 25888 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
2903 :
2904 25888 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[0]][0][0]));
2905 25888 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[0]][1][0]));
2906 25888 : asm volatile ("vpsrlw $4,%ymm0,%ymm5");
2907 25888 : asm volatile ("vpand %ymm7,%ymm0,%ymm4");
2908 25888 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2909 25888 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2910 25888 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2911 25888 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2912 25888 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2913 :
2914 25888 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[1]][0][0]));
2915 25888 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[1]][1][0]));
2916 25888 : asm volatile ("vpsrlw $4,%ymm1,%ymm5");
2917 25888 : asm volatile ("vpand %ymm7,%ymm1,%ymm4");
2918 25888 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2919 25888 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2920 25888 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2921 25888 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2922 25888 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2923 :
2924 25888 : asm volatile ("vmovdqa %%ymm6,%0" : "=m" (pa[0][i]));
2925 :
2926 25888 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
2927 :
2928 25888 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[2]][0][0]));
2929 25888 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[2]][1][0]));
2930 25888 : asm volatile ("vpsrlw $4,%ymm0,%ymm5");
2931 25888 : asm volatile ("vpand %ymm7,%ymm0,%ymm4");
2932 25888 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2933 25888 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2934 25888 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2935 25888 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2936 25888 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2937 :
2938 25888 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[3]][0][0]));
2939 25888 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[3]][1][0]));
2940 25888 : asm volatile ("vpsrlw $4,%ymm1,%ymm5");
2941 25888 : asm volatile ("vpand %ymm7,%ymm1,%ymm4");
2942 25888 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2943 25888 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2944 25888 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2945 25888 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2946 25888 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2947 :
2948 25888 : asm volatile ("vmovdqa %%ymm6,%0" : "=m" (pa[1][i]));
2949 : }
2950 :
2951 : raid_avx_end();
2952 1190 : }
2953 : #endif
2954 :
2955 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
2956 : /*
2957 : * RAID recovering AVX2 implementation
2958 : */
2959 17729 : void raid_recX_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2960 : {
2961 17729 : uint8_t **v = (uint8_t **)vv;
2962 17729 : int N = nr;
2963 : uint8_t *p[RAID_PARITY_MAX];
2964 : uint8_t *pa[RAID_PARITY_MAX];
2965 : uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
2966 : uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
2967 : uint8_t buffer[RAID_PARITY_MAX*32+32];
2968 17729 : uint8_t *pd = __align_ptr(buffer, 32);
2969 : size_t i;
2970 : int j, k;
2971 :
2972 : /* setup the coefficients matrix */
2973 90629 : for (j = 0; j < N; ++j)
2974 385516 : for (k = 0; k < N; ++k)
2975 625232 : G[j * N + k] = A(ip[j], id[k]);
2976 :
2977 : /* invert it to solve the system of linear equations */
2978 17729 : raid_invert(G, V, N);
2979 :
2980 : /* compute delta parity */
2981 17729 : raid_delta_gen(N, id, ip, nd, size, vv);
2982 :
2983 90629 : for (j = 0; j < N; ++j) {
2984 72900 : p[j] = v[nd + ip[j]];
2985 72900 : pa[j] = v[id[j]];
2986 : }
2987 :
2988 : raid_avx_begin();
2989 :
2990 17729 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
2991 :
2992 225033 : for (i = 0; i < size; i += 32) {
2993 : /* delta */
2994 1085128 : for (j = 0; j < N; ++j) {
2995 877824 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[j][i]));
2996 877824 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (pa[j][i]));
2997 877824 : asm volatile ("vpxor %ymm1,%ymm0,%ymm0");
2998 877824 : asm volatile ("vmovdqa %%ymm0,%0" : "=m" (pd[j*32]));
2999 : }
3000 :
3001 : /* reconstruct */
3002 1085128 : for (j = 0; j < N; ++j) {
3003 877824 : asm volatile ("vpxor %ymm0,%ymm0,%ymm0");
3004 877824 : asm volatile ("vpxor %ymm1,%ymm1,%ymm1");
3005 :
3006 4786400 : for (k = 0; k < N; ++k) {
3007 3908576 : uint8_t m = V[j * N + k];
3008 :
3009 3908576 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[m][0][0]));
3010 3908576 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[m][1][0]));
3011 3908576 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (pd[k*32]));
3012 3908576 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
3013 3908576 : asm volatile ("vpand %ymm7,%ymm4,%ymm4");
3014 3908576 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
3015 3908576 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
3016 3908576 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
3017 3908576 : asm volatile ("vpxor %ymm2,%ymm0,%ymm0");
3018 3908576 : asm volatile ("vpxor %ymm3,%ymm1,%ymm1");
3019 : }
3020 :
3021 877824 : asm volatile ("vpxor %ymm1,%ymm0,%ymm0");
3022 877824 : asm volatile ("vmovdqa %%ymm0,%0" : "=m" (pa[j][i]));
3023 : }
3024 : }
3025 :
3026 : raid_avx_end();
3027 17729 : }
3028 : #endif
3029 :
3030 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
3031 : /*
3032 : * RAID recovering for one disk AVX512BW implementation
3033 : */
3034 121 : void raid_rec1_avx512bw(int nr, int *id, int *ip, int nd, size_t size, void **vv)
3035 : {
3036 121 : uint8_t **v = (uint8_t **)vv;
3037 : uint8_t *p, *pa;
3038 : uint8_t G, V;
3039 : size_t i;
3040 :
3041 : (void)nr;
3042 :
3043 121 : if (ip[0] == 0) {
3044 30 : raid_rec1of1(id, nd, size, vv);
3045 30 : return;
3046 : }
3047 :
3048 91 : G = A(ip[0], id[0]);
3049 91 : V = inv(G);
3050 :
3051 91 : raid_delta_gen(1, id, ip, nd, size, vv);
3052 :
3053 91 : p = v[nd + ip[0]];
3054 91 : pa = v[id[0]];
3055 :
3056 : raid_avx_begin();
3057 :
3058 91 : asm volatile ("vbroadcasti32x4 %0,%%zmm7" : : "m" (gfconst16.low4[0]));
3059 91 : asm volatile ("vbroadcasti32x4 %0,%%zmm4" : : "m" (gfmulpshufb[V][0][0]));
3060 91 : asm volatile ("vbroadcasti32x4 %0,%%zmm5" : : "m" (gfmulpshufb[V][1][0]));
3061 :
3062 12971 : for (i = 0; i < size; i += 64) {
3063 12880 : asm volatile ("vmovdqa64 %0,%%zmm0" : : "m" (p[i]));
3064 12880 : asm volatile ("vmovdqa64 %0,%%zmm1" : : "m" (pa[i]));
3065 12880 : asm volatile ("vpxord %zmm1,%zmm0,%zmm0");
3066 12880 : asm volatile ("vpsrlw $4,%zmm0,%zmm1");
3067 12880 : asm volatile ("vpandd %zmm7,%zmm0,%zmm0");
3068 12880 : asm volatile ("vpandd %zmm7,%zmm1,%zmm1");
3069 12880 : asm volatile ("vpshufb %zmm0,%zmm4,%zmm2");
3070 12880 : asm volatile ("vpshufb %zmm1,%zmm5,%zmm3");
3071 12880 : asm volatile ("vpxord %zmm3,%zmm2,%zmm2");
3072 12880 : asm volatile ("vmovdqa64 %%zmm2, %0" : "=m" (pa[i]));
3073 : }
3074 :
3075 : raid_avx_end();
3076 : }
3077 : #endif
3078 :
3079 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
3080 : /*
3081 : * RAID recovering for two disks AVX512BW implementation
3082 : */
3083 1199 : void raid_rec2_avx512bw(int nr, int *id, int *ip, int nd, size_t size, void **vv)
3084 1199 : {
3085 1199 : uint8_t **v = (uint8_t **)vv;
3086 1199 : const int N = 2;
3087 1199 : uint8_t *p[N], *pa[N];
3088 1199 : uint8_t G[N * N], V[N * N];
3089 : size_t i;
3090 : int j, k;
3091 :
3092 : (void)nr;
3093 :
3094 3597 : for (j = 0; j < N; ++j)
3095 7194 : for (k = 0; k < N; ++k)
3096 9592 : G[j * N + k] = A(ip[j], id[k]);
3097 :
3098 1199 : raid_invert(G, V, N);
3099 1199 : raid_delta_gen(N, id, ip, nd, size, vv);
3100 :
3101 3597 : for (j = 0; j < N; ++j) {
3102 2398 : p[j] = v[nd + ip[j]];
3103 2398 : pa[j] = v[id[j]];
3104 : }
3105 :
3106 : raid_avx_begin();
3107 :
3108 1199 : asm volatile ("vbroadcasti32x4 %0,%%zmm7" : : "m" (gfconst16.low4[0]));
3109 :
3110 10687 : for (i = 0; i < size; i += 64) {
3111 9488 : asm volatile ("vmovdqa64 %0,%%zmm0" : : "m" (p[0][i]));
3112 9488 : asm volatile ("vmovdqa64 %0,%%zmm2" : : "m" (pa[0][i]));
3113 9488 : asm volatile ("vmovdqa64 %0,%%zmm1" : : "m" (p[1][i]));
3114 9488 : asm volatile ("vmovdqa64 %0,%%zmm3" : : "m" (pa[1][i]));
3115 9488 : asm volatile ("vpxord %zmm2,%zmm0,%zmm0");
3116 9488 : asm volatile ("vpxord %zmm3,%zmm1,%zmm1");
3117 :
3118 9488 : asm volatile ("vpxord %zmm6,%zmm6,%zmm6");
3119 :
3120 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm2" : : "m" (gfmulpshufb[V[0]][0][0]));
3121 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm3" : : "m" (gfmulpshufb[V[0]][1][0]));
3122 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm10" : : "m" (gfmulpshufb[V[1]][0][0]));
3123 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm11" : : "m" (gfmulpshufb[V[1]][1][0]));
3124 9488 : asm volatile ("vpsrlw $4,%zmm0,%zmm5");
3125 9488 : asm volatile ("vpsrlw $4,%zmm1,%zmm13");
3126 9488 : asm volatile ("vpandd %zmm7,%zmm0,%zmm4");
3127 9488 : asm volatile ("vpandd %zmm7,%zmm5,%zmm5");
3128 9488 : asm volatile ("vpandd %zmm7,%zmm1,%zmm12");
3129 9488 : asm volatile ("vpandd %zmm7,%zmm13,%zmm13");
3130 9488 : asm volatile ("vpshufb %zmm4,%zmm2,%zmm2");
3131 9488 : asm volatile ("vpshufb %zmm5,%zmm3,%zmm3");
3132 9488 : asm volatile ("vpshufb %zmm12,%zmm10,%zmm10");
3133 9488 : asm volatile ("vpshufb %zmm13,%zmm11,%zmm11");
3134 9488 : asm volatile ("vpxord %zmm2,%zmm6,%zmm6");
3135 9488 : asm volatile ("vpxord %zmm3,%zmm6,%zmm6");
3136 9488 : asm volatile ("vpxord %zmm10,%zmm6,%zmm6");
3137 9488 : asm volatile ("vpxord %zmm11,%zmm6,%zmm6");
3138 :
3139 9488 : asm volatile ("vmovdqa64 %%zmm6,%0" : "=m" (pa[0][i]));
3140 :
3141 9488 : asm volatile ("vpxord %zmm6,%zmm6,%zmm6");
3142 :
3143 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm2" : : "m" (gfmulpshufb[V[2]][0][0]));
3144 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm3" : : "m" (gfmulpshufb[V[2]][1][0]));
3145 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm10" : : "m" (gfmulpshufb[V[3]][0][0]));
3146 9488 : asm volatile ("vbroadcasti32x4 %0,%%zmm11" : : "m" (gfmulpshufb[V[3]][1][0]));
3147 9488 : asm volatile ("vpsrlw $4,%zmm0,%zmm5");
3148 9488 : asm volatile ("vpsrlw $4,%zmm1,%zmm13");
3149 9488 : asm volatile ("vpandd %zmm7,%zmm0,%zmm4");
3150 9488 : asm volatile ("vpandd %zmm7,%zmm5,%zmm5");
3151 9488 : asm volatile ("vpandd %zmm7,%zmm1,%zmm12");
3152 9488 : asm volatile ("vpandd %zmm7,%zmm13,%zmm13");
3153 9488 : asm volatile ("vpshufb %zmm4,%zmm2,%zmm2");
3154 9488 : asm volatile ("vpshufb %zmm5,%zmm3,%zmm3");
3155 9488 : asm volatile ("vpshufb %zmm12,%zmm10,%zmm10");
3156 9488 : asm volatile ("vpshufb %zmm13,%zmm11,%zmm11");
3157 9488 : asm volatile ("vpxord %zmm2,%zmm6,%zmm6");
3158 9488 : asm volatile ("vpxord %zmm3,%zmm6,%zmm6");
3159 9488 : asm volatile ("vpxord %zmm10,%zmm6,%zmm6");
3160 9488 : asm volatile ("vpxord %zmm11,%zmm6,%zmm6");
3161 :
3162 9488 : asm volatile ("vmovdqa64 %%zmm6,%0" : "=m" (pa[1][i]));
3163 : }
3164 :
3165 : raid_avx_end();
3166 1199 : }
3167 : #endif
3168 :
3169 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX512BW)
3170 : /*
3171 : * RAID recovering AVX512BW implementation
3172 : */
3173 17737 : void raid_recX_avx512bw(int nr, int *id, int *ip, int nd, size_t size, void **vv)
3174 : {
3175 17737 : uint8_t **v = (uint8_t **)vv;
3176 17737 : int N = nr;
3177 : uint8_t *p[RAID_PARITY_MAX];
3178 : uint8_t *pa[RAID_PARITY_MAX];
3179 : uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
3180 : uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
3181 : uint8_t buffer[RAID_PARITY_MAX*64+64];
3182 17737 : uint8_t *pd = __align_ptr(buffer, 64);
3183 : size_t i;
3184 : int j, k;
3185 :
3186 : /* setup the coefficients matrix */
3187 90667 : for (j = 0; j < N; ++j)
3188 385668 : for (k = 0; k < N; ++k)
3189 625476 : G[j * N + k] = A(ip[j], id[k]);
3190 :
3191 : /* invert it to solve the system of linear equations */
3192 17737 : raid_invert(G, V, N);
3193 :
3194 : /* compute delta parity */
3195 17737 : raid_delta_gen(N, id, ip, nd, size, vv);
3196 :
3197 90667 : for (j = 0; j < N; ++j) {
3198 72930 : p[j] = v[nd + ip[j]];
3199 72930 : pa[j] = v[id[j]];
3200 : }
3201 :
3202 : raid_avx_begin();
3203 :
3204 17737 : asm volatile ("vbroadcasti32x4 %0,%%zmm7" : : "m" (gfconst16.low4[0]));
3205 :
3206 105773 : for (i = 0; i < size; i += 64) {
3207 : /* delta */
3208 456292 : for (j = 0; j < N; ++j) {
3209 368256 : asm volatile ("vmovdqa64 %0,%%zmm0" : : "m" (p[j][i]));
3210 368256 : asm volatile ("vmovdqa64 %0,%%zmm1" : : "m" (pa[j][i]));
3211 368256 : asm volatile ("vpxorq %zmm1,%zmm0,%zmm0");
3212 368256 : asm volatile ("vmovdqa64 %%zmm0,%0" : "=m" (pd[j*64]));
3213 : }
3214 : /* reconstruct */
3215 456292 : for (j = 0; j < N; ++j) {
3216 368256 : asm volatile ("vpxorq %zmm0,%zmm0,%zmm0");
3217 368256 : asm volatile ("vpxorq %zmm1,%zmm1,%zmm1");
3218 1983600 : for (k = 0; k < N; ++k) {
3219 1615344 : uint8_t m = V[j * N + k];
3220 1615344 : asm volatile ("vbroadcasti32x4 %0,%%zmm2" : : "m" (gfmulpshufb[m][0][0]));
3221 1615344 : asm volatile ("vbroadcasti32x4 %0,%%zmm3" : : "m" (gfmulpshufb[m][1][0]));
3222 1615344 : asm volatile ("vmovdqa64 %0,%%zmm4" : : "m" (pd[k*64]));
3223 1615344 : asm volatile ("vpsrlw $4,%zmm4,%zmm5");
3224 1615344 : asm volatile ("vpandq %zmm7,%zmm4,%zmm4");
3225 1615344 : asm volatile ("vpandq %zmm7,%zmm5,%zmm5");
3226 1615344 : asm volatile ("vpshufb %zmm4,%zmm2,%zmm2");
3227 1615344 : asm volatile ("vpshufb %zmm5,%zmm3,%zmm3");
3228 1615344 : asm volatile ("vpxorq %zmm2,%zmm0,%zmm0");
3229 1615344 : asm volatile ("vpxorq %zmm3,%zmm1,%zmm1");
3230 : }
3231 368256 : asm volatile ("vpxorq %zmm1,%zmm0,%zmm0");
3232 368256 : asm volatile ("vmovdqa64 %%zmm0,%0" : "=m" (pa[j][i]));
3233 : }
3234 : }
3235 :
3236 : raid_avx_end();
3237 17737 : }
3238 : #endif
3239 :
3240 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
3241 322 : void raid_register_x86(void)
3242 : {
3243 : #ifdef CONFIG_SSE2
3244 322 : if (raid_cpu_has_sse2()) {
3245 322 : raid_gen_register(RAID_ALGO_CAUCHY_PAR1, "sse2", raid_gen1_sse2);
3246 322 : raid_gen_register(RAID_ALGO_CAUCHY_PAR2, "sse2", raid_gen2_sse2);
3247 : #ifdef CONFIG_X86_64
3248 322 : if (!raid_cpu_has_slowextendedreg())
3249 322 : raid_gen_register(RAID_ALGO_CAUCHY_PAR2, "sse2e", raid_gen2_sse2ext);
3250 : /* note that raid_cpu_has_slowextendedreg() doesn't affect vandermonde */
3251 322 : raid_gen_register(RAID_ALGO_VANDERMONDE_PAR3, "sse2e", raid_genz_sse2ext);
3252 : #else
3253 : raid_gen_register(RAID_ALGO_VANDERMONDE_PAR3, "sse2", raid_genz_sse2);
3254 : #endif
3255 : }
3256 : #endif
3257 :
3258 : #ifdef CONFIG_SSSE3
3259 322 : if (raid_cpu_has_ssse3()) {
3260 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR3, "ssse3", raid_gen3_ssse3);
3261 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR4, "ssse3", raid_gen4_ssse3);
3262 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR5, "ssse3", raid_gen5_ssse3);
3263 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR6, "ssse3", raid_gen6_ssse3);
3264 : #ifdef CONFIG_X86_64
3265 321 : if (!raid_cpu_has_slowextendedreg()) {
3266 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR3, "ssse3e", raid_gen3_ssse3ext);
3267 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR4, "ssse3e", raid_gen4_ssse3ext);
3268 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR5, "ssse3e", raid_gen5_ssse3ext);
3269 321 : raid_gen_register(RAID_ALGO_CAUCHY_PAR6, "ssse3e", raid_gen6_ssse3ext);
3270 : }
3271 : #endif
3272 :
3273 321 : raid_rec_register(RAID_ALGO_CAUCHY_PAR1, "ssse3", raid_rec1_ssse3);
3274 321 : raid_rec_register(RAID_ALGO_CAUCHY_PAR2, "ssse3", raid_rec2_ssse3);
3275 321 : raid_rec_register(RAID_ALGO_CAUCHY_PAR3, "ssse3", raid_recX_ssse3);
3276 321 : raid_rec_register(RAID_ALGO_CAUCHY_PAR4, "ssse3", raid_recX_ssse3);
3277 321 : raid_rec_register(RAID_ALGO_CAUCHY_PAR5, "ssse3", raid_recX_ssse3);
3278 321 : raid_rec_register(RAID_ALGO_CAUCHY_PAR6, "ssse3", raid_recX_ssse3);
3279 : }
3280 : #endif
3281 :
3282 : #ifdef CONFIG_AVX2
3283 322 : if (raid_cpu_has_avx2()) {
3284 3 : raid_gen_register(RAID_ALGO_CAUCHY_PAR1, "avx2", raid_gen1_avx2);
3285 3 : raid_gen_register(RAID_ALGO_CAUCHY_PAR2, "avx2", raid_gen2_avx2);
3286 : #ifdef CONFIG_X86_64
3287 3 : raid_gen_register(RAID_ALGO_CAUCHY_PAR3, "avx2e", raid_gen3_avx2ext);
3288 3 : raid_gen_register(RAID_ALGO_CAUCHY_PAR4, "avx2e", raid_gen4_avx2ext);
3289 3 : raid_gen_register(RAID_ALGO_CAUCHY_PAR5, "avx2e", raid_gen5_avx2ext);
3290 3 : raid_gen_register(RAID_ALGO_CAUCHY_PAR6, "avx2e", raid_gen6_avx2ext);
3291 3 : raid_gen_register(RAID_ALGO_VANDERMONDE_PAR3, "avx2e", raid_genz_avx2ext);
3292 : #endif
3293 :
3294 3 : raid_rec_register(RAID_ALGO_CAUCHY_PAR1, "avx2", raid_rec1_avx2);
3295 3 : raid_rec_register(RAID_ALGO_CAUCHY_PAR2, "avx2", raid_rec2_avx2);
3296 3 : raid_rec_register(RAID_ALGO_CAUCHY_PAR3, "avx2", raid_recX_avx2);
3297 3 : raid_rec_register(RAID_ALGO_CAUCHY_PAR4, "avx2", raid_recX_avx2);
3298 3 : raid_rec_register(RAID_ALGO_CAUCHY_PAR5, "avx2", raid_recX_avx2);
3299 3 : raid_rec_register(RAID_ALGO_CAUCHY_PAR6, "avx2", raid_recX_avx2);
3300 : }
3301 : #endif
3302 :
3303 : #ifdef CONFIG_AVX512BW
3304 : #ifdef CONFIG_X86_64
3305 322 : if (raid_cpu_has_avx512bw()) {
3306 2 : raid_gen_register(RAID_ALGO_CAUCHY_PAR1, "avx512", raid_gen1_avx512bw);
3307 2 : raid_gen_register(RAID_ALGO_CAUCHY_PAR2, "avx512", raid_gen2_avx512bw);
3308 2 : raid_gen_register(RAID_ALGO_CAUCHY_PAR3, "avx512", raid_gen3_avx512bw);
3309 2 : raid_gen_register(RAID_ALGO_CAUCHY_PAR4, "avx512", raid_gen4_avx512bw);
3310 2 : raid_gen_register(RAID_ALGO_CAUCHY_PAR5, "avx512", raid_gen5_avx512bw);
3311 2 : raid_gen_register(RAID_ALGO_CAUCHY_PAR6, "avx512", raid_gen6_avx512bw);
3312 :
3313 2 : raid_rec_register(RAID_ALGO_CAUCHY_PAR1, "avx512", raid_rec1_avx512bw);
3314 2 : raid_rec_register(RAID_ALGO_CAUCHY_PAR2, "avx512", raid_rec2_avx512bw);
3315 2 : raid_rec_register(RAID_ALGO_CAUCHY_PAR3, "avx512", raid_recX_avx512bw);
3316 2 : raid_rec_register(RAID_ALGO_CAUCHY_PAR4, "avx512", raid_recX_avx512bw);
3317 2 : raid_rec_register(RAID_ALGO_CAUCHY_PAR5, "avx512", raid_recX_avx512bw);
3318 2 : raid_rec_register(RAID_ALGO_CAUCHY_PAR6, "avx512", raid_recX_avx512bw);
3319 : }
3320 : #endif
3321 : #endif
3322 322 : }
3323 : #endif
|
