Line data Source code
1 : /*
2 : * Copyright (C) 2013 Andrea Mazzoleni
3 : *
4 : * This program is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 2 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * This program is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : */
14 :
15 : #include "internal.h"
16 : #include "gf.h"
17 :
18 : /*
19 : * For x86 optimizations you can see:
20 : *
21 : * Software optimization resources
22 : * http://www.agner.org/optimize/
23 : *
24 : * x86, x64 Instruction Latency, Memory Latency and CPUID dumps
25 : * http://users.atw.hu/instlatx64/
26 : */
27 :
28 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
29 : /*
30 : * GEN1 (RAID5 with xor) SSE2 implementation
31 : *
32 : * Intentionally don't process more than 64 bytes because 64 is the typical
33 : * cache block, and processing 128 bytes doesn't increase performance, and in
34 : * some cases it even decreases it.
35 : */
36 288948 : void raid_gen1_sse2(int nd, size_t size, void **vv)
37 : {
38 288948 : uint8_t **v = (uint8_t **)vv;
39 : uint8_t *p;
40 : int d, l;
41 : size_t i;
42 :
43 288948 : l = nd - 1;
44 288948 : p = v[nd];
45 :
46 : raid_sse_begin();
47 :
48 6140160 : for (i = 0; i < size; i += 64) {
49 5851212 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
50 5851212 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
51 5851212 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
52 5851212 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
53 37573252 : for (d = l - 1; d >= 0; --d) {
54 31722040 : asm volatile ("pxor %0,%%xmm0" : : "m" (v[d][i]));
55 31722040 : asm volatile ("pxor %0,%%xmm1" : : "m" (v[d][i + 16]));
56 31722040 : asm volatile ("pxor %0,%%xmm2" : : "m" (v[d][i + 32]));
57 31722040 : asm volatile ("pxor %0,%%xmm3" : : "m" (v[d][i + 48]));
58 : }
59 5851212 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
60 5851212 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
61 5851212 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
62 5851212 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
63 : }
64 :
65 : raid_sse_end();
66 288948 : }
67 : #endif
68 :
69 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
70 : /*
71 : * GEN1 (RAID5 with xor) AVX2 implementation
72 : *
73 : * Intentionally don't process more than 64 bytes because 64 is the typical
74 : * cache block, and processing 128 bytes doesn't increase performance, and in
75 : * some cases it even decreases it.
76 : */
77 97 : void raid_gen1_avx2(int nd, size_t size, void **vv)
78 : {
79 97 : uint8_t **v = (uint8_t **)vv;
80 : uint8_t *p;
81 : int d, l;
82 : size_t i;
83 :
84 97 : l = nd - 1;
85 97 : p = v[nd];
86 :
87 : raid_avx_begin();
88 :
89 50189 : for (i = 0; i < size; i += 64) {
90 50092 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
91 50092 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
92 407172 : for (d = l - 1; d >= 0; --d) {
93 357080 : asm volatile ("vpxor %0,%%ymm0,%%ymm0" : : "m" (v[d][i]));
94 357080 : asm volatile ("vpxor %0,%%ymm1,%%ymm1" : : "m" (v[d][i + 32]));
95 : }
96 50092 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
97 50092 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
98 : }
99 :
100 : raid_avx_end();
101 97 : }
102 : #endif
103 :
104 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
105 : static const struct gfconst16 {
106 : uint8_t poly[16];
107 : uint8_t low4[16];
108 : } gfconst16 __aligned(32) = {
109 : {
110 : 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
111 : 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d
112 : },
113 : {
114 : 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
115 : 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f
116 : },
117 : };
118 : #endif
119 :
120 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
121 : /*
122 : * GEN2 (RAID6 with powers of 2) SSE2 implementation
123 : */
124 268716 : void raid_gen2_sse2(int nd, size_t size, void **vv)
125 : {
126 268716 : uint8_t **v = (uint8_t **)vv;
127 : uint8_t *p;
128 : uint8_t *q;
129 : int d, l;
130 : size_t i;
131 :
132 268716 : l = nd - 1;
133 268716 : p = v[nd];
134 268716 : q = v[nd + 1];
135 :
136 : raid_sse_begin();
137 :
138 268716 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
139 :
140 10785156 : for (i = 0; i < size; i += 32) {
141 10516440 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
142 10516440 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
143 10516440 : asm volatile ("movdqa %xmm0,%xmm2");
144 10516440 : asm volatile ("movdqa %xmm1,%xmm3");
145 66949256 : for (d = l - 1; d >= 0; --d) {
146 56432816 : asm volatile ("pxor %xmm4,%xmm4");
147 56432816 : asm volatile ("pxor %xmm5,%xmm5");
148 56432816 : asm volatile ("pcmpgtb %xmm2,%xmm4");
149 56432816 : asm volatile ("pcmpgtb %xmm3,%xmm5");
150 56432816 : asm volatile ("paddb %xmm2,%xmm2");
151 56432816 : asm volatile ("paddb %xmm3,%xmm3");
152 56432816 : asm volatile ("pand %xmm7,%xmm4");
153 56432816 : asm volatile ("pand %xmm7,%xmm5");
154 56432816 : asm volatile ("pxor %xmm4,%xmm2");
155 56432816 : asm volatile ("pxor %xmm5,%xmm3");
156 :
157 56432816 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
158 56432816 : asm volatile ("movdqa %0,%%xmm5" : : "m" (v[d][i + 16]));
159 56432816 : asm volatile ("pxor %xmm4,%xmm0");
160 56432816 : asm volatile ("pxor %xmm5,%xmm1");
161 56432816 : asm volatile ("pxor %xmm4,%xmm2");
162 56432816 : asm volatile ("pxor %xmm5,%xmm3");
163 : }
164 10516440 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
165 10516440 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
166 10516440 : asm volatile ("movntdq %%xmm2,%0" : "=m" (q[i]));
167 10516440 : asm volatile ("movntdq %%xmm3,%0" : "=m" (q[i + 16]));
168 : }
169 :
170 : raid_sse_end();
171 268716 : }
172 : #endif
173 :
174 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
175 : /*
176 : * GEN2 (RAID6 with powers of 2) AVX2 implementation
177 : */
178 510 : void raid_gen2_avx2(int nd, size_t size, void **vv)
179 : {
180 510 : uint8_t **v = (uint8_t **)vv;
181 : uint8_t *p;
182 : uint8_t *q;
183 : int d, l;
184 : size_t i;
185 :
186 510 : l = nd - 1;
187 510 : p = v[nd];
188 510 : q = v[nd + 1];
189 :
190 : raid_avx_begin();
191 :
192 510 : asm volatile ("vbroadcasti128 %0, %%ymm7" : : "m" (gfconst16.poly[0]));
193 510 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
194 :
195 113754 : for (i = 0; i < size; i += 64) {
196 113244 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
197 113244 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
198 113244 : asm volatile ("vmovdqa %ymm0,%ymm2");
199 113244 : asm volatile ("vmovdqa %ymm1,%ymm3");
200 919748 : for (d = l - 1; d >= 0; --d) {
201 806504 : asm volatile ("vpcmpgtb %ymm2,%ymm6,%ymm4");
202 806504 : asm volatile ("vpcmpgtb %ymm3,%ymm6,%ymm5");
203 806504 : asm volatile ("vpaddb %ymm2,%ymm2,%ymm2");
204 806504 : asm volatile ("vpaddb %ymm3,%ymm3,%ymm3");
205 806504 : asm volatile ("vpand %ymm7,%ymm4,%ymm4");
206 806504 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
207 806504 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
208 806504 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
209 :
210 806504 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
211 806504 : asm volatile ("vmovdqa %0,%%ymm5" : : "m" (v[d][i + 32]));
212 806504 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
213 806504 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
214 806504 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
215 806504 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
216 : }
217 113244 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
218 113244 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
219 113244 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (q[i]));
220 113244 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (q[i + 32]));
221 : }
222 :
223 : raid_avx_end();
224 510 : }
225 : #endif
226 :
227 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSE2)
228 : /*
229 : * GEN2 (RAID6 with powers of 2) SSE2 implementation
230 : *
231 : * Note that it uses 16 registers, meaning that x64 is required.
232 : */
233 : void raid_gen2_sse2ext(int nd, size_t size, void **vv)
234 : {
235 : uint8_t **v = (uint8_t **)vv;
236 : uint8_t *p;
237 : uint8_t *q;
238 : int d, l;
239 : size_t i;
240 :
241 : l = nd - 1;
242 : p = v[nd];
243 : q = v[nd + 1];
244 :
245 : raid_sse_begin();
246 :
247 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.poly[0]));
248 :
249 : for (i = 0; i < size; i += 64) {
250 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
251 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
252 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
253 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
254 : asm volatile ("movdqa %xmm0,%xmm4");
255 : asm volatile ("movdqa %xmm1,%xmm5");
256 : asm volatile ("movdqa %xmm2,%xmm6");
257 : asm volatile ("movdqa %xmm3,%xmm7");
258 : for (d = l - 1; d >= 0; --d) {
259 : asm volatile ("pxor %xmm8,%xmm8");
260 : asm volatile ("pxor %xmm9,%xmm9");
261 : asm volatile ("pxor %xmm10,%xmm10");
262 : asm volatile ("pxor %xmm11,%xmm11");
263 : asm volatile ("pcmpgtb %xmm4,%xmm8");
264 : asm volatile ("pcmpgtb %xmm5,%xmm9");
265 : asm volatile ("pcmpgtb %xmm6,%xmm10");
266 : asm volatile ("pcmpgtb %xmm7,%xmm11");
267 : asm volatile ("paddb %xmm4,%xmm4");
268 : asm volatile ("paddb %xmm5,%xmm5");
269 : asm volatile ("paddb %xmm6,%xmm6");
270 : asm volatile ("paddb %xmm7,%xmm7");
271 : asm volatile ("pand %xmm15,%xmm8");
272 : asm volatile ("pand %xmm15,%xmm9");
273 : asm volatile ("pand %xmm15,%xmm10");
274 : asm volatile ("pand %xmm15,%xmm11");
275 : asm volatile ("pxor %xmm8,%xmm4");
276 : asm volatile ("pxor %xmm9,%xmm5");
277 : asm volatile ("pxor %xmm10,%xmm6");
278 : asm volatile ("pxor %xmm11,%xmm7");
279 :
280 : asm volatile ("movdqa %0,%%xmm8" : : "m" (v[d][i]));
281 : asm volatile ("movdqa %0,%%xmm9" : : "m" (v[d][i + 16]));
282 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i + 32]));
283 : asm volatile ("movdqa %0,%%xmm11" : : "m" (v[d][i + 48]));
284 : asm volatile ("pxor %xmm8,%xmm0");
285 : asm volatile ("pxor %xmm9,%xmm1");
286 : asm volatile ("pxor %xmm10,%xmm2");
287 : asm volatile ("pxor %xmm11,%xmm3");
288 : asm volatile ("pxor %xmm8,%xmm4");
289 : asm volatile ("pxor %xmm9,%xmm5");
290 : asm volatile ("pxor %xmm10,%xmm6");
291 : asm volatile ("pxor %xmm11,%xmm7");
292 : }
293 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
294 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
295 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
296 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
297 : asm volatile ("movntdq %%xmm4,%0" : "=m" (q[i]));
298 : asm volatile ("movntdq %%xmm5,%0" : "=m" (q[i + 16]));
299 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i + 32]));
300 : asm volatile ("movntdq %%xmm7,%0" : "=m" (q[i + 48]));
301 : }
302 :
303 : raid_sse_end();
304 : }
305 : #endif
306 :
307 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
308 : /*
309 : * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
310 : */
311 29542 : void raid_gen3_ssse3(int nd, size_t size, void **vv)
312 : {
313 29542 : uint8_t **v = (uint8_t **)vv;
314 : uint8_t *p;
315 : uint8_t *q;
316 : uint8_t *r;
317 : int d, l;
318 : size_t i;
319 :
320 29542 : l = nd - 1;
321 29542 : p = v[nd];
322 29542 : q = v[nd + 1];
323 29542 : r = v[nd + 2];
324 :
325 : /* special case with only one data disk */
326 29542 : if (l == 0) {
327 4 : for (i = 0; i < 3; ++i)
328 3 : memcpy(v[1 + i], v[0], size);
329 29543 : return;
330 : }
331 :
332 : raid_sse_begin();
333 :
334 : /* generic case with at least two data disks */
335 29541 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
336 29541 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
337 :
338 4888821 : for (i = 0; i < size; i += 16) {
339 : /* last disk without the by two multiplication */
340 4859280 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
341 :
342 4859280 : asm volatile ("movdqa %xmm4,%xmm0");
343 4859280 : asm volatile ("movdqa %xmm4,%xmm1");
344 :
345 4859280 : asm volatile ("movdqa %xmm4,%xmm5");
346 4859280 : asm volatile ("psrlw $4,%xmm5");
347 4859280 : asm volatile ("pand %xmm7,%xmm4");
348 4859280 : asm volatile ("pand %xmm7,%xmm5");
349 :
350 4859280 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
351 4859280 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[l][0][1][0]));
352 4859280 : asm volatile ("pshufb %xmm4,%xmm2");
353 4859280 : asm volatile ("pshufb %xmm5,%xmm6");
354 4859280 : asm volatile ("pxor %xmm6,%xmm2");
355 :
356 : /* intermediate disks */
357 30489328 : for (d = l - 1; d > 0; --d) {
358 25630048 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
359 :
360 25630048 : asm volatile ("pxor %xmm5,%xmm5");
361 25630048 : asm volatile ("pcmpgtb %xmm1,%xmm5");
362 25630048 : asm volatile ("paddb %xmm1,%xmm1");
363 25630048 : asm volatile ("pand %xmm3,%xmm5");
364 25630048 : asm volatile ("pxor %xmm5,%xmm1");
365 :
366 25630048 : asm volatile ("pxor %xmm4,%xmm0");
367 25630048 : asm volatile ("pxor %xmm4,%xmm1");
368 :
369 25630048 : asm volatile ("movdqa %xmm4,%xmm5");
370 25630048 : asm volatile ("psrlw $4,%xmm5");
371 25630048 : asm volatile ("pand %xmm7,%xmm4");
372 25630048 : asm volatile ("pand %xmm7,%xmm5");
373 :
374 25630048 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
375 25630048 : asm volatile ("pshufb %xmm4,%xmm6");
376 25630048 : asm volatile ("pxor %xmm6,%xmm2");
377 25630048 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][1][0]));
378 25630048 : asm volatile ("pshufb %xmm5,%xmm6");
379 25630048 : asm volatile ("pxor %xmm6,%xmm2");
380 : }
381 :
382 : /* first disk with all coefficients at 1 */
383 4859280 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
384 :
385 4859280 : asm volatile ("pxor %xmm5,%xmm5");
386 4859280 : asm volatile ("pcmpgtb %xmm1,%xmm5");
387 4859280 : asm volatile ("paddb %xmm1,%xmm1");
388 4859280 : asm volatile ("pand %xmm3,%xmm5");
389 4859280 : asm volatile ("pxor %xmm5,%xmm1");
390 :
391 4859280 : asm volatile ("pxor %xmm4,%xmm0");
392 4859280 : asm volatile ("pxor %xmm4,%xmm1");
393 4859280 : asm volatile ("pxor %xmm4,%xmm2");
394 :
395 4859280 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
396 4859280 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
397 4859280 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
398 : }
399 :
400 : raid_sse_end();
401 : }
402 : #endif
403 :
404 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
405 : /*
406 : * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
407 : *
408 : * Note that it uses 16 registers, meaning that x64 is required.
409 : */
410 : void raid_gen3_ssse3ext(int nd, size_t size, void **vv)
411 : {
412 : uint8_t **v = (uint8_t **)vv;
413 : uint8_t *p;
414 : uint8_t *q;
415 : uint8_t *r;
416 : int d, l;
417 : size_t i;
418 :
419 : l = nd - 1;
420 : p = v[nd];
421 : q = v[nd + 1];
422 : r = v[nd + 2];
423 :
424 : /* special case with only one data disk */
425 : if (l == 0) {
426 : for (i = 0; i < 3; ++i)
427 : memcpy(v[1 + i], v[0], size);
428 : return;
429 : }
430 :
431 : raid_sse_begin();
432 :
433 : /* generic case with at least two data disks */
434 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
435 : asm volatile ("movdqa %0,%%xmm11" : : "m" (gfconst16.low4[0]));
436 :
437 : for (i = 0; i < size; i += 32) {
438 : /* last disk without the by two multiplication */
439 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
440 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
441 :
442 : asm volatile ("movdqa %xmm4,%xmm0");
443 : asm volatile ("movdqa %xmm4,%xmm1");
444 : asm volatile ("movdqa %xmm12,%xmm8");
445 : asm volatile ("movdqa %xmm12,%xmm9");
446 :
447 : asm volatile ("movdqa %xmm4,%xmm5");
448 : asm volatile ("movdqa %xmm12,%xmm13");
449 : asm volatile ("psrlw $4,%xmm5");
450 : asm volatile ("psrlw $4,%xmm13");
451 : asm volatile ("pand %xmm11,%xmm4");
452 : asm volatile ("pand %xmm11,%xmm12");
453 : asm volatile ("pand %xmm11,%xmm5");
454 : asm volatile ("pand %xmm11,%xmm13");
455 :
456 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
457 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
458 : asm volatile ("movdqa %xmm2,%xmm10");
459 : asm volatile ("movdqa %xmm7,%xmm15");
460 : asm volatile ("pshufb %xmm4,%xmm2");
461 : asm volatile ("pshufb %xmm12,%xmm10");
462 : asm volatile ("pshufb %xmm5,%xmm7");
463 : asm volatile ("pshufb %xmm13,%xmm15");
464 : asm volatile ("pxor %xmm7,%xmm2");
465 : asm volatile ("pxor %xmm15,%xmm10");
466 :
467 : /* intermediate disks */
468 : for (d = l - 1; d > 0; --d) {
469 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
470 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
471 :
472 : asm volatile ("pxor %xmm5,%xmm5");
473 : asm volatile ("pxor %xmm13,%xmm13");
474 : asm volatile ("pcmpgtb %xmm1,%xmm5");
475 : asm volatile ("pcmpgtb %xmm9,%xmm13");
476 : asm volatile ("paddb %xmm1,%xmm1");
477 : asm volatile ("paddb %xmm9,%xmm9");
478 : asm volatile ("pand %xmm3,%xmm5");
479 : asm volatile ("pand %xmm3,%xmm13");
480 : asm volatile ("pxor %xmm5,%xmm1");
481 : asm volatile ("pxor %xmm13,%xmm9");
482 :
483 : asm volatile ("pxor %xmm4,%xmm0");
484 : asm volatile ("pxor %xmm4,%xmm1");
485 : asm volatile ("pxor %xmm12,%xmm8");
486 : asm volatile ("pxor %xmm12,%xmm9");
487 :
488 : asm volatile ("movdqa %xmm4,%xmm5");
489 : asm volatile ("movdqa %xmm12,%xmm13");
490 : asm volatile ("psrlw $4,%xmm5");
491 : asm volatile ("psrlw $4,%xmm13");
492 : asm volatile ("pand %xmm11,%xmm4");
493 : asm volatile ("pand %xmm11,%xmm12");
494 : asm volatile ("pand %xmm11,%xmm5");
495 : asm volatile ("pand %xmm11,%xmm13");
496 :
497 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
498 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
499 : asm volatile ("movdqa %xmm6,%xmm14");
500 : asm volatile ("movdqa %xmm7,%xmm15");
501 : asm volatile ("pshufb %xmm4,%xmm6");
502 : asm volatile ("pshufb %xmm12,%xmm14");
503 : asm volatile ("pshufb %xmm5,%xmm7");
504 : asm volatile ("pshufb %xmm13,%xmm15");
505 : asm volatile ("pxor %xmm6,%xmm2");
506 : asm volatile ("pxor %xmm14,%xmm10");
507 : asm volatile ("pxor %xmm7,%xmm2");
508 : asm volatile ("pxor %xmm15,%xmm10");
509 : }
510 :
511 : /* first disk with all coefficients at 1 */
512 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
513 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
514 :
515 : asm volatile ("pxor %xmm5,%xmm5");
516 : asm volatile ("pxor %xmm13,%xmm13");
517 : asm volatile ("pcmpgtb %xmm1,%xmm5");
518 : asm volatile ("pcmpgtb %xmm9,%xmm13");
519 : asm volatile ("paddb %xmm1,%xmm1");
520 : asm volatile ("paddb %xmm9,%xmm9");
521 : asm volatile ("pand %xmm3,%xmm5");
522 : asm volatile ("pand %xmm3,%xmm13");
523 : asm volatile ("pxor %xmm5,%xmm1");
524 : asm volatile ("pxor %xmm13,%xmm9");
525 :
526 : asm volatile ("pxor %xmm4,%xmm0");
527 : asm volatile ("pxor %xmm4,%xmm1");
528 : asm volatile ("pxor %xmm4,%xmm2");
529 : asm volatile ("pxor %xmm12,%xmm8");
530 : asm volatile ("pxor %xmm12,%xmm9");
531 : asm volatile ("pxor %xmm12,%xmm10");
532 :
533 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
534 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
535 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
536 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
537 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
538 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
539 : }
540 :
541 : raid_sse_end();
542 : }
543 : #endif
544 :
545 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
546 : /*
547 : * GEN3 (triple parity with Cauchy matrix) AVX2 implementation
548 : *
549 : * Note that it uses 16 registers, meaning that x64 is required.
550 : */
551 : void raid_gen3_avx2ext(int nd, size_t size, void **vv)
552 : {
553 : uint8_t **v = (uint8_t **)vv;
554 : uint8_t *p;
555 : uint8_t *q;
556 : uint8_t *r;
557 : int d, l;
558 : size_t i;
559 :
560 : l = nd - 1;
561 : p = v[nd];
562 : q = v[nd + 1];
563 : r = v[nd + 2];
564 :
565 : /* special case with only one data disk */
566 : if (l == 0) {
567 : for (i = 0; i < 3; ++i)
568 : memcpy(v[1 + i], v[0], size);
569 : return;
570 : }
571 :
572 : raid_avx_begin();
573 :
574 : /* generic case with at least two data disks */
575 : asm volatile ("vbroadcasti128 %0, %%ymm3" : : "m" (gfconst16.poly[0]));
576 : asm volatile ("vbroadcasti128 %0, %%ymm11" : : "m" (gfconst16.low4[0]));
577 :
578 : for (i = 0; i < size; i += 64) {
579 : /* last disk without the by two multiplication */
580 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
581 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
582 :
583 : asm volatile ("vmovdqa %ymm4,%ymm0");
584 : asm volatile ("vmovdqa %ymm4,%ymm1");
585 : asm volatile ("vmovdqa %ymm12,%ymm8");
586 : asm volatile ("vmovdqa %ymm12,%ymm9");
587 :
588 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
589 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
590 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
591 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
592 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
593 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
594 :
595 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
596 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
597 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
598 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
599 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
600 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
601 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
602 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
603 :
604 : /* intermediate disks */
605 : for (d = l - 1; d > 0; --d) {
606 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
607 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
608 :
609 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
610 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
611 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
612 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
613 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
614 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
615 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
616 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
617 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
618 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
619 :
620 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
621 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
622 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
623 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
624 :
625 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
626 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
627 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
628 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
629 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
630 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
631 :
632 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
633 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
634 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
635 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
636 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
637 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
638 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
639 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
640 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
641 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
642 : }
643 :
644 : /* first disk with all coefficients at 1 */
645 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
646 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
647 :
648 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
649 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
650 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
651 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
652 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
653 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
654 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
655 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
656 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
657 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
658 :
659 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
660 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
661 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
662 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
663 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
664 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
665 :
666 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
667 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
668 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
669 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
670 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
671 : asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
672 : }
673 :
674 : raid_avx_end();
675 : }
676 : #endif
677 :
678 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
679 : /*
680 : * GEN4 (quad parity with Cauchy matrix) SSSE3 implementation
681 : */
682 32469 : void raid_gen4_ssse3(int nd, size_t size, void **vv)
683 : {
684 32469 : uint8_t **v = (uint8_t **)vv;
685 : uint8_t *p;
686 : uint8_t *q;
687 : uint8_t *r;
688 : uint8_t *s;
689 : int d, l;
690 : size_t i;
691 :
692 32469 : l = nd - 1;
693 32469 : p = v[nd];
694 32469 : q = v[nd + 1];
695 32469 : r = v[nd + 2];
696 32469 : s = v[nd + 3];
697 :
698 : /* special case with only one data disk */
699 32469 : if (l == 0) {
700 5 : for (i = 0; i < 4; ++i)
701 4 : memcpy(v[1 + i], v[0], size);
702 32470 : return;
703 : }
704 :
705 : raid_sse_begin();
706 :
707 : /* generic case with at least two data disks */
708 3334804 : for (i = 0; i < size; i += 16) {
709 : /* last disk without the by two multiplication */
710 3302336 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
711 3302336 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
712 :
713 3302336 : asm volatile ("movdqa %xmm4,%xmm0");
714 3302336 : asm volatile ("movdqa %xmm4,%xmm1");
715 :
716 3302336 : asm volatile ("movdqa %xmm4,%xmm5");
717 3302336 : asm volatile ("psrlw $4,%xmm5");
718 3302336 : asm volatile ("pand %xmm7,%xmm4");
719 3302336 : asm volatile ("pand %xmm7,%xmm5");
720 :
721 3302336 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
722 3302336 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
723 3302336 : asm volatile ("pshufb %xmm4,%xmm2");
724 3302336 : asm volatile ("pshufb %xmm5,%xmm7");
725 3302336 : asm volatile ("pxor %xmm7,%xmm2");
726 :
727 3302336 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
728 3302336 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
729 3302336 : asm volatile ("pshufb %xmm4,%xmm3");
730 3302336 : asm volatile ("pshufb %xmm5,%xmm7");
731 3302336 : asm volatile ("pxor %xmm7,%xmm3");
732 :
733 : /* intermediate disks */
734 19771392 : for (d = l - 1; d > 0; --d) {
735 16469056 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
736 16469056 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
737 :
738 16469056 : asm volatile ("pxor %xmm5,%xmm5");
739 16469056 : asm volatile ("pcmpgtb %xmm1,%xmm5");
740 16469056 : asm volatile ("paddb %xmm1,%xmm1");
741 16469056 : asm volatile ("pand %xmm7,%xmm5");
742 16469056 : asm volatile ("pxor %xmm5,%xmm1");
743 :
744 16469056 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
745 :
746 16469056 : asm volatile ("pxor %xmm4,%xmm0");
747 16469056 : asm volatile ("pxor %xmm4,%xmm1");
748 :
749 16469056 : asm volatile ("movdqa %xmm4,%xmm5");
750 16469056 : asm volatile ("psrlw $4,%xmm5");
751 16469056 : asm volatile ("pand %xmm7,%xmm4");
752 16469056 : asm volatile ("pand %xmm7,%xmm5");
753 :
754 16469056 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
755 16469056 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
756 16469056 : asm volatile ("pshufb %xmm4,%xmm6");
757 16469056 : asm volatile ("pshufb %xmm5,%xmm7");
758 16469056 : asm volatile ("pxor %xmm6,%xmm2");
759 16469056 : asm volatile ("pxor %xmm7,%xmm2");
760 :
761 16469056 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
762 16469056 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
763 16469056 : asm volatile ("pshufb %xmm4,%xmm6");
764 16469056 : asm volatile ("pshufb %xmm5,%xmm7");
765 16469056 : asm volatile ("pxor %xmm6,%xmm3");
766 16469056 : asm volatile ("pxor %xmm7,%xmm3");
767 : }
768 :
769 : /* first disk with all coefficients at 1 */
770 3302336 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
771 3302336 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
772 :
773 3302336 : asm volatile ("pxor %xmm5,%xmm5");
774 3302336 : asm volatile ("pcmpgtb %xmm1,%xmm5");
775 3302336 : asm volatile ("paddb %xmm1,%xmm1");
776 3302336 : asm volatile ("pand %xmm7,%xmm5");
777 3302336 : asm volatile ("pxor %xmm5,%xmm1");
778 :
779 3302336 : asm volatile ("pxor %xmm4,%xmm0");
780 3302336 : asm volatile ("pxor %xmm4,%xmm1");
781 3302336 : asm volatile ("pxor %xmm4,%xmm2");
782 3302336 : asm volatile ("pxor %xmm4,%xmm3");
783 :
784 3302336 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
785 3302336 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
786 3302336 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
787 3302336 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
788 : }
789 :
790 : raid_sse_end();
791 : }
792 : #endif
793 :
794 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
795 : /*
796 : * GEN4 (quad parity with Cauchy matrix) SSSE3 implementation
797 : *
798 : * Note that it uses 16 registers, meaning that x64 is required.
799 : */
800 : void raid_gen4_ssse3ext(int nd, size_t size, void **vv)
801 : {
802 : uint8_t **v = (uint8_t **)vv;
803 : uint8_t *p;
804 : uint8_t *q;
805 : uint8_t *r;
806 : uint8_t *s;
807 : int d, l;
808 : size_t i;
809 :
810 : l = nd - 1;
811 : p = v[nd];
812 : q = v[nd + 1];
813 : r = v[nd + 2];
814 : s = v[nd + 3];
815 :
816 : /* special case with only one data disk */
817 : if (l == 0) {
818 : for (i = 0; i < 4; ++i)
819 : memcpy(v[1 + i], v[0], size);
820 : return;
821 : }
822 :
823 : raid_sse_begin();
824 :
825 : /* generic case with at least two data disks */
826 : for (i = 0; i < size; i += 32) {
827 : /* last disk without the by two multiplication */
828 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
829 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
830 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
831 :
832 : asm volatile ("movdqa %xmm4,%xmm0");
833 : asm volatile ("movdqa %xmm4,%xmm1");
834 : asm volatile ("movdqa %xmm12,%xmm8");
835 : asm volatile ("movdqa %xmm12,%xmm9");
836 :
837 : asm volatile ("movdqa %xmm4,%xmm5");
838 : asm volatile ("movdqa %xmm12,%xmm13");
839 : asm volatile ("psrlw $4,%xmm5");
840 : asm volatile ("psrlw $4,%xmm13");
841 : asm volatile ("pand %xmm15,%xmm4");
842 : asm volatile ("pand %xmm15,%xmm12");
843 : asm volatile ("pand %xmm15,%xmm5");
844 : asm volatile ("pand %xmm15,%xmm13");
845 :
846 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
847 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
848 : asm volatile ("movdqa %xmm2,%xmm10");
849 : asm volatile ("movdqa %xmm7,%xmm15");
850 : asm volatile ("pshufb %xmm4,%xmm2");
851 : asm volatile ("pshufb %xmm12,%xmm10");
852 : asm volatile ("pshufb %xmm5,%xmm7");
853 : asm volatile ("pshufb %xmm13,%xmm15");
854 : asm volatile ("pxor %xmm7,%xmm2");
855 : asm volatile ("pxor %xmm15,%xmm10");
856 :
857 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
858 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
859 : asm volatile ("movdqa %xmm3,%xmm11");
860 : asm volatile ("movdqa %xmm7,%xmm15");
861 : asm volatile ("pshufb %xmm4,%xmm3");
862 : asm volatile ("pshufb %xmm12,%xmm11");
863 : asm volatile ("pshufb %xmm5,%xmm7");
864 : asm volatile ("pshufb %xmm13,%xmm15");
865 : asm volatile ("pxor %xmm7,%xmm3");
866 : asm volatile ("pxor %xmm15,%xmm11");
867 :
868 : /* intermediate disks */
869 : for (d = l - 1; d > 0; --d) {
870 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
871 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
872 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
873 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
874 :
875 : asm volatile ("pxor %xmm5,%xmm5");
876 : asm volatile ("pxor %xmm13,%xmm13");
877 : asm volatile ("pcmpgtb %xmm1,%xmm5");
878 : asm volatile ("pcmpgtb %xmm9,%xmm13");
879 : asm volatile ("paddb %xmm1,%xmm1");
880 : asm volatile ("paddb %xmm9,%xmm9");
881 : asm volatile ("pand %xmm7,%xmm5");
882 : asm volatile ("pand %xmm7,%xmm13");
883 : asm volatile ("pxor %xmm5,%xmm1");
884 : asm volatile ("pxor %xmm13,%xmm9");
885 :
886 : asm volatile ("pxor %xmm4,%xmm0");
887 : asm volatile ("pxor %xmm4,%xmm1");
888 : asm volatile ("pxor %xmm12,%xmm8");
889 : asm volatile ("pxor %xmm12,%xmm9");
890 :
891 : asm volatile ("movdqa %xmm4,%xmm5");
892 : asm volatile ("movdqa %xmm12,%xmm13");
893 : asm volatile ("psrlw $4,%xmm5");
894 : asm volatile ("psrlw $4,%xmm13");
895 : asm volatile ("pand %xmm15,%xmm4");
896 : asm volatile ("pand %xmm15,%xmm12");
897 : asm volatile ("pand %xmm15,%xmm5");
898 : asm volatile ("pand %xmm15,%xmm13");
899 :
900 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
901 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
902 : asm volatile ("movdqa %xmm6,%xmm14");
903 : asm volatile ("movdqa %xmm7,%xmm15");
904 : asm volatile ("pshufb %xmm4,%xmm6");
905 : asm volatile ("pshufb %xmm12,%xmm14");
906 : asm volatile ("pshufb %xmm5,%xmm7");
907 : asm volatile ("pshufb %xmm13,%xmm15");
908 : asm volatile ("pxor %xmm6,%xmm2");
909 : asm volatile ("pxor %xmm14,%xmm10");
910 : asm volatile ("pxor %xmm7,%xmm2");
911 : asm volatile ("pxor %xmm15,%xmm10");
912 :
913 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
914 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
915 : asm volatile ("movdqa %xmm6,%xmm14");
916 : asm volatile ("movdqa %xmm7,%xmm15");
917 : asm volatile ("pshufb %xmm4,%xmm6");
918 : asm volatile ("pshufb %xmm12,%xmm14");
919 : asm volatile ("pshufb %xmm5,%xmm7");
920 : asm volatile ("pshufb %xmm13,%xmm15");
921 : asm volatile ("pxor %xmm6,%xmm3");
922 : asm volatile ("pxor %xmm14,%xmm11");
923 : asm volatile ("pxor %xmm7,%xmm3");
924 : asm volatile ("pxor %xmm15,%xmm11");
925 : }
926 :
927 : /* first disk with all coefficients at 1 */
928 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
929 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
930 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
931 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
932 :
933 : asm volatile ("pxor %xmm5,%xmm5");
934 : asm volatile ("pxor %xmm13,%xmm13");
935 : asm volatile ("pcmpgtb %xmm1,%xmm5");
936 : asm volatile ("pcmpgtb %xmm9,%xmm13");
937 : asm volatile ("paddb %xmm1,%xmm1");
938 : asm volatile ("paddb %xmm9,%xmm9");
939 : asm volatile ("pand %xmm7,%xmm5");
940 : asm volatile ("pand %xmm7,%xmm13");
941 : asm volatile ("pxor %xmm5,%xmm1");
942 : asm volatile ("pxor %xmm13,%xmm9");
943 :
944 : asm volatile ("pxor %xmm4,%xmm0");
945 : asm volatile ("pxor %xmm4,%xmm1");
946 : asm volatile ("pxor %xmm4,%xmm2");
947 : asm volatile ("pxor %xmm4,%xmm3");
948 : asm volatile ("pxor %xmm12,%xmm8");
949 : asm volatile ("pxor %xmm12,%xmm9");
950 : asm volatile ("pxor %xmm12,%xmm10");
951 : asm volatile ("pxor %xmm12,%xmm11");
952 :
953 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
954 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
955 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
956 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
957 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
958 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
959 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
960 : asm volatile ("movntdq %%xmm11,%0" : "=m" (s[i + 16]));
961 : }
962 :
963 : raid_sse_end();
964 : }
965 : #endif
966 :
967 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
968 : /*
969 : * GEN4 (quad parity with Cauchy matrix) AVX2 implementation
970 : *
971 : * Note that it uses 16 registers, meaning that x64 is required.
972 : */
973 : void raid_gen4_avx2ext(int nd, size_t size, void **vv)
974 : {
975 : uint8_t **v = (uint8_t **)vv;
976 : uint8_t *p;
977 : uint8_t *q;
978 : uint8_t *r;
979 : uint8_t *s;
980 : int d, l;
981 : size_t i;
982 :
983 : l = nd - 1;
984 : p = v[nd];
985 : q = v[nd + 1];
986 : r = v[nd + 2];
987 : s = v[nd + 3];
988 :
989 : /* special case with only one data disk */
990 : if (l == 0) {
991 : for (i = 0; i < 4; ++i)
992 : memcpy(v[1 + i], v[0], size);
993 : return;
994 : }
995 :
996 : raid_avx_begin();
997 :
998 : /* generic case with at least two data disks */
999 : for (i = 0; i < size; i += 64) {
1000 : /* last disk without the by two multiplication */
1001 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1002 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
1003 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
1004 :
1005 : asm volatile ("vmovdqa %ymm4,%ymm0");
1006 : asm volatile ("vmovdqa %ymm4,%ymm1");
1007 : asm volatile ("vmovdqa %ymm12,%ymm8");
1008 : asm volatile ("vmovdqa %ymm12,%ymm9");
1009 :
1010 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
1011 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
1012 : asm volatile ("vpand %ymm15,%ymm4,%ymm4");
1013 : asm volatile ("vpand %ymm15,%ymm12,%ymm12");
1014 : asm volatile ("vpand %ymm15,%ymm5,%ymm5");
1015 : asm volatile ("vpand %ymm15,%ymm13,%ymm13");
1016 :
1017 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
1018 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
1019 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
1020 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1021 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
1022 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1023 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
1024 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
1025 :
1026 : asm volatile ("vbroadcasti128 %0,%%ymm11" : : "m" (gfgenpshufb[l][1][0][0]));
1027 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][1][1][0]));
1028 : asm volatile ("vpshufb %ymm4,%ymm11,%ymm3");
1029 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1030 : asm volatile ("vpshufb %ymm12,%ymm11,%ymm11");
1031 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1032 : asm volatile ("vpxor %ymm7,%ymm3,%ymm3");
1033 : asm volatile ("vpxor %ymm15,%ymm11,%ymm11");
1034 :
1035 : /* intermediate disks */
1036 : for (d = l - 1; d > 0; --d) {
1037 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
1038 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1039 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
1040 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
1041 :
1042 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
1043 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
1044 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
1045 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
1046 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1047 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
1048 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
1049 : asm volatile ("vpand %ymm7,%ymm13,%ymm13");
1050 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
1051 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
1052 :
1053 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
1054 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
1055 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
1056 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
1057 :
1058 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
1059 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
1060 : asm volatile ("vpand %ymm15,%ymm4,%ymm4");
1061 : asm volatile ("vpand %ymm15,%ymm12,%ymm12");
1062 : asm volatile ("vpand %ymm15,%ymm5,%ymm5");
1063 : asm volatile ("vpand %ymm15,%ymm13,%ymm13");
1064 :
1065 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
1066 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
1067 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
1068 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1069 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
1070 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1071 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
1072 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
1073 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
1074 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
1075 :
1076 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][1][0][0]));
1077 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][1][1][0]));
1078 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
1079 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1080 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
1081 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1082 : asm volatile ("vpxor %ymm6,%ymm3,%ymm3");
1083 : asm volatile ("vpxor %ymm14,%ymm11,%ymm11");
1084 : asm volatile ("vpxor %ymm7,%ymm3,%ymm3");
1085 : asm volatile ("vpxor %ymm15,%ymm11,%ymm11");
1086 : }
1087 :
1088 : /* first disk with all coefficients at 1 */
1089 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
1090 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1091 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
1092 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
1093 :
1094 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
1095 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
1096 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
1097 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
1098 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1099 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
1100 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
1101 : asm volatile ("vpand %ymm7,%ymm13,%ymm13");
1102 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
1103 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
1104 :
1105 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
1106 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
1107 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
1108 : asm volatile ("vpxor %ymm4,%ymm3,%ymm3");
1109 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
1110 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
1111 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
1112 : asm volatile ("vpxor %ymm12,%ymm11,%ymm11");
1113 :
1114 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1115 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
1116 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1117 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
1118 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1119 : asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
1120 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1121 : asm volatile ("vmovntdq %%ymm11,%0" : "=m" (s[i + 32]));
1122 : }
1123 :
1124 : raid_avx_end();
1125 : }
1126 : #endif
1127 :
1128 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
1129 : /*
1130 : * GEN5 (penta parity with Cauchy matrix) SSSE3 implementation
1131 : */
1132 50654 : void raid_gen5_ssse3(int nd, size_t size, void **vv)
1133 : {
1134 50654 : uint8_t **v = (uint8_t **)vv;
1135 : uint8_t *p;
1136 : uint8_t *q;
1137 : uint8_t *r;
1138 : uint8_t *s;
1139 : uint8_t *t;
1140 : int d, l;
1141 : size_t i;
1142 : uint8_t buffer[16+16];
1143 50654 : uint8_t *pd = __align_ptr(buffer, 16);
1144 :
1145 50654 : l = nd - 1;
1146 50654 : p = v[nd];
1147 50654 : q = v[nd + 1];
1148 50654 : r = v[nd + 2];
1149 50654 : s = v[nd + 3];
1150 50654 : t = v[nd + 4];
1151 :
1152 : /* special case with only one data disk */
1153 50654 : if (l == 0) {
1154 6 : for (i = 0; i < 5; ++i)
1155 5 : memcpy(v[1 + i], v[0], size);
1156 50655 : return;
1157 : }
1158 :
1159 : raid_sse_begin();
1160 :
1161 : /* generic case with at least two data disks */
1162 3937517 : for (i = 0; i < size; i += 16) {
1163 : /* last disk without the by two multiplication */
1164 3886864 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1165 :
1166 3886864 : asm volatile ("movdqa %xmm4,%xmm0");
1167 3886864 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1168 :
1169 3886864 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1170 3886864 : asm volatile ("movdqa %xmm4,%xmm5");
1171 3886864 : asm volatile ("psrlw $4,%xmm5");
1172 3886864 : asm volatile ("pand %xmm7,%xmm4");
1173 3886864 : asm volatile ("pand %xmm7,%xmm5");
1174 :
1175 3886864 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][0][0][0]));
1176 3886864 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1177 3886864 : asm volatile ("pshufb %xmm4,%xmm1");
1178 3886864 : asm volatile ("pshufb %xmm5,%xmm7");
1179 3886864 : asm volatile ("pxor %xmm7,%xmm1");
1180 :
1181 3886864 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][1][0][0]));
1182 3886864 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1183 3886864 : asm volatile ("pshufb %xmm4,%xmm2");
1184 3886864 : asm volatile ("pshufb %xmm5,%xmm7");
1185 3886864 : asm volatile ("pxor %xmm7,%xmm2");
1186 :
1187 3886864 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][2][0][0]));
1188 3886864 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1189 3886864 : asm volatile ("pshufb %xmm4,%xmm3");
1190 3886864 : asm volatile ("pshufb %xmm5,%xmm7");
1191 3886864 : asm volatile ("pxor %xmm7,%xmm3");
1192 :
1193 : /* intermediate disks */
1194 23263984 : for (d = l - 1; d > 0; --d) {
1195 19377120 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1196 19377120 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1197 19377120 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1198 :
1199 19377120 : asm volatile ("pxor %xmm5,%xmm5");
1200 19377120 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1201 19377120 : asm volatile ("paddb %xmm0,%xmm0");
1202 19377120 : asm volatile ("pand %xmm7,%xmm5");
1203 19377120 : asm volatile ("pxor %xmm5,%xmm0");
1204 :
1205 19377120 : asm volatile ("pxor %xmm4,%xmm0");
1206 19377120 : asm volatile ("pxor %xmm4,%xmm6");
1207 19377120 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[0]));
1208 :
1209 19377120 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1210 19377120 : asm volatile ("movdqa %xmm4,%xmm5");
1211 19377120 : asm volatile ("psrlw $4,%xmm5");
1212 19377120 : asm volatile ("pand %xmm7,%xmm4");
1213 19377120 : asm volatile ("pand %xmm7,%xmm5");
1214 :
1215 19377120 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1216 19377120 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1217 19377120 : asm volatile ("pshufb %xmm4,%xmm6");
1218 19377120 : asm volatile ("pshufb %xmm5,%xmm7");
1219 19377120 : asm volatile ("pxor %xmm6,%xmm1");
1220 19377120 : asm volatile ("pxor %xmm7,%xmm1");
1221 :
1222 19377120 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1223 19377120 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1224 19377120 : asm volatile ("pshufb %xmm4,%xmm6");
1225 19377120 : asm volatile ("pshufb %xmm5,%xmm7");
1226 19377120 : asm volatile ("pxor %xmm6,%xmm2");
1227 19377120 : asm volatile ("pxor %xmm7,%xmm2");
1228 :
1229 19377120 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1230 19377120 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1231 19377120 : asm volatile ("pshufb %xmm4,%xmm6");
1232 19377120 : asm volatile ("pshufb %xmm5,%xmm7");
1233 19377120 : asm volatile ("pxor %xmm6,%xmm3");
1234 19377120 : asm volatile ("pxor %xmm7,%xmm3");
1235 : }
1236 :
1237 : /* first disk with all coefficients at 1 */
1238 3886864 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1239 3886864 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1240 3886864 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1241 :
1242 3886864 : asm volatile ("pxor %xmm5,%xmm5");
1243 3886864 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1244 3886864 : asm volatile ("paddb %xmm0,%xmm0");
1245 3886864 : asm volatile ("pand %xmm7,%xmm5");
1246 3886864 : asm volatile ("pxor %xmm5,%xmm0");
1247 :
1248 3886864 : asm volatile ("pxor %xmm4,%xmm0");
1249 3886864 : asm volatile ("pxor %xmm4,%xmm1");
1250 3886864 : asm volatile ("pxor %xmm4,%xmm2");
1251 3886864 : asm volatile ("pxor %xmm4,%xmm3");
1252 3886864 : asm volatile ("pxor %xmm4,%xmm6");
1253 :
1254 3886864 : asm volatile ("movntdq %%xmm6,%0" : "=m" (p[i]));
1255 3886864 : asm volatile ("movntdq %%xmm0,%0" : "=m" (q[i]));
1256 3886864 : asm volatile ("movntdq %%xmm1,%0" : "=m" (r[i]));
1257 3886864 : asm volatile ("movntdq %%xmm2,%0" : "=m" (s[i]));
1258 3886864 : asm volatile ("movntdq %%xmm3,%0" : "=m" (t[i]));
1259 : }
1260 :
1261 : raid_sse_end();
1262 : }
1263 : #endif
1264 :
1265 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
1266 : /*
1267 : * GEN5 (penta parity with Cauchy matrix) SSSE3 implementation
1268 : *
1269 : * Note that it uses 16 registers, meaning that x64 is required.
1270 : */
1271 : void raid_gen5_ssse3ext(int nd, size_t size, void **vv)
1272 : {
1273 : uint8_t **v = (uint8_t **)vv;
1274 : uint8_t *p;
1275 : uint8_t *q;
1276 : uint8_t *r;
1277 : uint8_t *s;
1278 : uint8_t *t;
1279 : int d, l;
1280 : size_t i;
1281 :
1282 : l = nd - 1;
1283 : p = v[nd];
1284 : q = v[nd + 1];
1285 : r = v[nd + 2];
1286 : s = v[nd + 3];
1287 : t = v[nd + 4];
1288 :
1289 : /* special case with only one data disk */
1290 : if (l == 0) {
1291 : for (i = 0; i < 5; ++i)
1292 : memcpy(v[1 + i], v[0], size);
1293 : return;
1294 : }
1295 :
1296 : raid_sse_begin();
1297 :
1298 : /* generic case with at least two data disks */
1299 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1300 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1301 :
1302 : for (i = 0; i < size; i += 16) {
1303 : /* last disk without the by two multiplication */
1304 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1305 :
1306 : asm volatile ("movdqa %xmm10,%xmm0");
1307 : asm volatile ("movdqa %xmm10,%xmm1");
1308 :
1309 : asm volatile ("movdqa %xmm10,%xmm11");
1310 : asm volatile ("psrlw $4,%xmm11");
1311 : asm volatile ("pand %xmm15,%xmm10");
1312 : asm volatile ("pand %xmm15,%xmm11");
1313 :
1314 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1315 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1316 : asm volatile ("pshufb %xmm10,%xmm2");
1317 : asm volatile ("pshufb %xmm11,%xmm13");
1318 : asm volatile ("pxor %xmm13,%xmm2");
1319 :
1320 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1321 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1322 : asm volatile ("pshufb %xmm10,%xmm3");
1323 : asm volatile ("pshufb %xmm11,%xmm13");
1324 : asm volatile ("pxor %xmm13,%xmm3");
1325 :
1326 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1327 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1328 : asm volatile ("pshufb %xmm10,%xmm4");
1329 : asm volatile ("pshufb %xmm11,%xmm13");
1330 : asm volatile ("pxor %xmm13,%xmm4");
1331 :
1332 : /* intermediate disks */
1333 : for (d = l - 1; d > 0; --d) {
1334 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1335 :
1336 : asm volatile ("pxor %xmm11,%xmm11");
1337 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1338 : asm volatile ("paddb %xmm1,%xmm1");
1339 : asm volatile ("pand %xmm14,%xmm11");
1340 : asm volatile ("pxor %xmm11,%xmm1");
1341 :
1342 : asm volatile ("pxor %xmm10,%xmm0");
1343 : asm volatile ("pxor %xmm10,%xmm1");
1344 :
1345 : asm volatile ("movdqa %xmm10,%xmm11");
1346 : asm volatile ("psrlw $4,%xmm11");
1347 : asm volatile ("pand %xmm15,%xmm10");
1348 : asm volatile ("pand %xmm15,%xmm11");
1349 :
1350 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1351 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1352 : asm volatile ("pshufb %xmm10,%xmm12");
1353 : asm volatile ("pshufb %xmm11,%xmm13");
1354 : asm volatile ("pxor %xmm12,%xmm2");
1355 : asm volatile ("pxor %xmm13,%xmm2");
1356 :
1357 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1358 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1359 : asm volatile ("pshufb %xmm10,%xmm12");
1360 : asm volatile ("pshufb %xmm11,%xmm13");
1361 : asm volatile ("pxor %xmm12,%xmm3");
1362 : asm volatile ("pxor %xmm13,%xmm3");
1363 :
1364 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1365 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1366 : asm volatile ("pshufb %xmm10,%xmm12");
1367 : asm volatile ("pshufb %xmm11,%xmm13");
1368 : asm volatile ("pxor %xmm12,%xmm4");
1369 : asm volatile ("pxor %xmm13,%xmm4");
1370 : }
1371 :
1372 : /* first disk with all coefficients at 1 */
1373 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1374 :
1375 : asm volatile ("pxor %xmm11,%xmm11");
1376 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1377 : asm volatile ("paddb %xmm1,%xmm1");
1378 : asm volatile ("pand %xmm14,%xmm11");
1379 : asm volatile ("pxor %xmm11,%xmm1");
1380 :
1381 : asm volatile ("pxor %xmm10,%xmm0");
1382 : asm volatile ("pxor %xmm10,%xmm1");
1383 : asm volatile ("pxor %xmm10,%xmm2");
1384 : asm volatile ("pxor %xmm10,%xmm3");
1385 : asm volatile ("pxor %xmm10,%xmm4");
1386 :
1387 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1388 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1389 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1390 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1391 : asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
1392 : }
1393 :
1394 : raid_sse_end();
1395 : }
1396 : #endif
1397 :
1398 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
1399 : /*
1400 : * GEN5 (penta parity with Cauchy matrix) AVX2 implementation
1401 : *
1402 : * Note that it uses 16 registers, meaning that x64 is required.
1403 : */
1404 : void raid_gen5_avx2ext(int nd, size_t size, void **vv)
1405 : {
1406 : uint8_t **v = (uint8_t **)vv;
1407 : uint8_t *p;
1408 : uint8_t *q;
1409 : uint8_t *r;
1410 : uint8_t *s;
1411 : uint8_t *t;
1412 : int d, l;
1413 : size_t i;
1414 :
1415 : l = nd - 1;
1416 : p = v[nd];
1417 : q = v[nd + 1];
1418 : r = v[nd + 2];
1419 : s = v[nd + 3];
1420 : t = v[nd + 4];
1421 :
1422 : /* special case with only one data disk */
1423 : if (l == 0) {
1424 : for (i = 0; i < 5; ++i)
1425 : memcpy(v[1 + i], v[0], size);
1426 : return;
1427 : }
1428 :
1429 : raid_avx_begin();
1430 :
1431 : /* generic case with at least two data disks */
1432 : asm volatile ("vpxor %ymm8,%ymm8,%ymm8");
1433 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
1434 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1435 :
1436 : for (i = 0; i < size; i += 32) {
1437 : /* last disk without the by two multiplication */
1438 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
1439 :
1440 : asm volatile ("vmovdqa %ymm10,%ymm0");
1441 : asm volatile ("vmovdqa %ymm10,%ymm1");
1442 :
1443 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1444 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1445 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1446 :
1447 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
1448 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
1449 : asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
1450 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1451 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1452 :
1453 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
1454 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
1455 : asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
1456 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1457 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1458 :
1459 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
1460 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
1461 : asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
1462 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1463 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1464 :
1465 : /* intermediate disks */
1466 : for (d = l - 1; d > 0; --d) {
1467 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
1468 :
1469 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1470 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1471 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1472 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1473 :
1474 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1475 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1476 :
1477 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1478 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1479 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1480 :
1481 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
1482 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
1483 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1484 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1485 : asm volatile ("vpxor %ymm12,%ymm2,%ymm2");
1486 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1487 :
1488 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
1489 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
1490 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1491 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1492 : asm volatile ("vpxor %ymm12,%ymm3,%ymm3");
1493 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1494 :
1495 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
1496 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
1497 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1498 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1499 : asm volatile ("vpxor %ymm12,%ymm4,%ymm4");
1500 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1501 : }
1502 :
1503 : /* first disk with all coefficients at 1 */
1504 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
1505 :
1506 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1507 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1508 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1509 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1510 :
1511 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1512 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1513 : asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
1514 : asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
1515 : asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
1516 :
1517 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1518 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1519 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1520 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1521 : asm volatile ("vmovntdq %%ymm4,%0" : "=m" (t[i]));
1522 : }
1523 :
1524 : raid_avx_end();
1525 : }
1526 : #endif
1527 :
1528 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
1529 : /*
1530 : * GEN6 (hexa parity with Cauchy matrix) SSSE3 implementation
1531 : */
1532 564177 : void raid_gen6_ssse3(int nd, size_t size, void **vv)
1533 : {
1534 564177 : uint8_t **v = (uint8_t **)vv;
1535 : uint8_t *p;
1536 : uint8_t *q;
1537 : uint8_t *r;
1538 : uint8_t *s;
1539 : uint8_t *t;
1540 : uint8_t *u;
1541 : int d, l;
1542 : size_t i;
1543 : uint8_t buffer[2*16+16];
1544 564177 : uint8_t *pd = __align_ptr(buffer, 16);
1545 :
1546 564177 : l = nd - 1;
1547 564177 : p = v[nd];
1548 564177 : q = v[nd + 1];
1549 564177 : r = v[nd + 2];
1550 564177 : s = v[nd + 3];
1551 564177 : t = v[nd + 4];
1552 564177 : u = v[nd + 5];
1553 :
1554 : /* special case with only one data disk */
1555 564177 : if (l == 0) {
1556 7 : for (i = 0; i < 6; ++i)
1557 6 : memcpy(v[1 + i], v[0], size);
1558 564178 : return;
1559 : }
1560 :
1561 : raid_sse_begin();
1562 :
1563 : /* generic case with at least two data disks */
1564 36098080 : for (i = 0; i < size; i += 16) {
1565 : /* last disk without the by two multiplication */
1566 35533904 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1567 :
1568 35533904 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1569 35533904 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[16]));
1570 :
1571 35533904 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1572 35533904 : asm volatile ("movdqa %xmm4,%xmm5");
1573 35533904 : asm volatile ("psrlw $4,%xmm5");
1574 35533904 : asm volatile ("pand %xmm7,%xmm4");
1575 35533904 : asm volatile ("pand %xmm7,%xmm5");
1576 :
1577 35533904 : asm volatile ("movdqa %0,%%xmm0" : : "m" (gfgenpshufb[l][0][0][0]));
1578 35533904 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1579 35533904 : asm volatile ("pshufb %xmm4,%xmm0");
1580 35533904 : asm volatile ("pshufb %xmm5,%xmm7");
1581 35533904 : asm volatile ("pxor %xmm7,%xmm0");
1582 :
1583 35533904 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][1][0][0]));
1584 35533904 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1585 35533904 : asm volatile ("pshufb %xmm4,%xmm1");
1586 35533904 : asm volatile ("pshufb %xmm5,%xmm7");
1587 35533904 : asm volatile ("pxor %xmm7,%xmm1");
1588 :
1589 35533904 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][2][0][0]));
1590 35533904 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1591 35533904 : asm volatile ("pshufb %xmm4,%xmm2");
1592 35533904 : asm volatile ("pshufb %xmm5,%xmm7");
1593 35533904 : asm volatile ("pxor %xmm7,%xmm2");
1594 :
1595 35533904 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][3][0][0]));
1596 35533904 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][3][1][0]));
1597 35533904 : asm volatile ("pshufb %xmm4,%xmm3");
1598 35533904 : asm volatile ("pshufb %xmm5,%xmm7");
1599 35533904 : asm volatile ("pxor %xmm7,%xmm3");
1600 :
1601 : /* intermediate disks */
1602 183674416 : for (d = l - 1; d > 0; --d) {
1603 148140512 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
1604 148140512 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
1605 148140512 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1606 :
1607 148140512 : asm volatile ("pxor %xmm4,%xmm4");
1608 148140512 : asm volatile ("pcmpgtb %xmm6,%xmm4");
1609 148140512 : asm volatile ("paddb %xmm6,%xmm6");
1610 148140512 : asm volatile ("pand %xmm7,%xmm4");
1611 148140512 : asm volatile ("pxor %xmm4,%xmm6");
1612 :
1613 148140512 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1614 :
1615 148140512 : asm volatile ("pxor %xmm4,%xmm5");
1616 148140512 : asm volatile ("pxor %xmm4,%xmm6");
1617 148140512 : asm volatile ("movdqa %%xmm5,%0" : "=m" (pd[0]));
1618 148140512 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[16]));
1619 :
1620 148140512 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1621 148140512 : asm volatile ("movdqa %xmm4,%xmm5");
1622 148140512 : asm volatile ("psrlw $4,%xmm5");
1623 148140512 : asm volatile ("pand %xmm7,%xmm4");
1624 148140512 : asm volatile ("pand %xmm7,%xmm5");
1625 :
1626 148140512 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1627 148140512 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1628 148140512 : asm volatile ("pshufb %xmm4,%xmm6");
1629 148140512 : asm volatile ("pshufb %xmm5,%xmm7");
1630 148140512 : asm volatile ("pxor %xmm6,%xmm0");
1631 148140512 : asm volatile ("pxor %xmm7,%xmm0");
1632 :
1633 148140512 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1634 148140512 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1635 148140512 : asm volatile ("pshufb %xmm4,%xmm6");
1636 148140512 : asm volatile ("pshufb %xmm5,%xmm7");
1637 148140512 : asm volatile ("pxor %xmm6,%xmm1");
1638 148140512 : asm volatile ("pxor %xmm7,%xmm1");
1639 :
1640 148140512 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1641 148140512 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1642 148140512 : asm volatile ("pshufb %xmm4,%xmm6");
1643 148140512 : asm volatile ("pshufb %xmm5,%xmm7");
1644 148140512 : asm volatile ("pxor %xmm6,%xmm2");
1645 148140512 : asm volatile ("pxor %xmm7,%xmm2");
1646 :
1647 148140512 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][3][0][0]));
1648 148140512 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][3][1][0]));
1649 148140512 : asm volatile ("pshufb %xmm4,%xmm6");
1650 148140512 : asm volatile ("pshufb %xmm5,%xmm7");
1651 148140512 : asm volatile ("pxor %xmm6,%xmm3");
1652 148140512 : asm volatile ("pxor %xmm7,%xmm3");
1653 : }
1654 :
1655 : /* first disk with all coefficients at 1 */
1656 35533904 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
1657 35533904 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
1658 35533904 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1659 :
1660 35533904 : asm volatile ("pxor %xmm4,%xmm4");
1661 35533904 : asm volatile ("pcmpgtb %xmm6,%xmm4");
1662 35533904 : asm volatile ("paddb %xmm6,%xmm6");
1663 35533904 : asm volatile ("pand %xmm7,%xmm4");
1664 35533904 : asm volatile ("pxor %xmm4,%xmm6");
1665 :
1666 35533904 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1667 35533904 : asm volatile ("pxor %xmm4,%xmm0");
1668 35533904 : asm volatile ("pxor %xmm4,%xmm1");
1669 35533904 : asm volatile ("pxor %xmm4,%xmm2");
1670 35533904 : asm volatile ("pxor %xmm4,%xmm3");
1671 35533904 : asm volatile ("pxor %xmm4,%xmm5");
1672 35533904 : asm volatile ("pxor %xmm4,%xmm6");
1673 :
1674 35533904 : asm volatile ("movntdq %%xmm5,%0" : "=m" (p[i]));
1675 35533904 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i]));
1676 35533904 : asm volatile ("movntdq %%xmm0,%0" : "=m" (r[i]));
1677 35533904 : asm volatile ("movntdq %%xmm1,%0" : "=m" (s[i]));
1678 35533904 : asm volatile ("movntdq %%xmm2,%0" : "=m" (t[i]));
1679 35533904 : asm volatile ("movntdq %%xmm3,%0" : "=m" (u[i]));
1680 : }
1681 :
1682 : raid_sse_end();
1683 : }
1684 : #endif
1685 :
1686 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSSE3)
1687 : /*
1688 : * GEN6 (hexa parity with Cauchy matrix) SSSE3 implementation
1689 : *
1690 : * Note that it uses 16 registers, meaning that x64 is required.
1691 : */
1692 : void raid_gen6_ssse3ext(int nd, size_t size, void **vv)
1693 : {
1694 : uint8_t **v = (uint8_t **)vv;
1695 : uint8_t *p;
1696 : uint8_t *q;
1697 : uint8_t *r;
1698 : uint8_t *s;
1699 : uint8_t *t;
1700 : uint8_t *u;
1701 : int d, l;
1702 : size_t i;
1703 :
1704 : l = nd - 1;
1705 : p = v[nd];
1706 : q = v[nd + 1];
1707 : r = v[nd + 2];
1708 : s = v[nd + 3];
1709 : t = v[nd + 4];
1710 : u = v[nd + 5];
1711 :
1712 : /* special case with only one data disk */
1713 : if (l == 0) {
1714 : for (i = 0; i < 6; ++i)
1715 : memcpy(v[1 + i], v[0], size);
1716 : return;
1717 : }
1718 :
1719 : raid_sse_begin();
1720 :
1721 : /* generic case with at least two data disks */
1722 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1723 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1724 :
1725 : for (i = 0; i < size; i += 16) {
1726 : /* last disk without the by two multiplication */
1727 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1728 :
1729 : asm volatile ("movdqa %xmm10,%xmm0");
1730 : asm volatile ("movdqa %xmm10,%xmm1");
1731 :
1732 : asm volatile ("movdqa %xmm10,%xmm11");
1733 : asm volatile ("psrlw $4,%xmm11");
1734 : asm volatile ("pand %xmm15,%xmm10");
1735 : asm volatile ("pand %xmm15,%xmm11");
1736 :
1737 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1738 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1739 : asm volatile ("pshufb %xmm10,%xmm2");
1740 : asm volatile ("pshufb %xmm11,%xmm13");
1741 : asm volatile ("pxor %xmm13,%xmm2");
1742 :
1743 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1744 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1745 : asm volatile ("pshufb %xmm10,%xmm3");
1746 : asm volatile ("pshufb %xmm11,%xmm13");
1747 : asm volatile ("pxor %xmm13,%xmm3");
1748 :
1749 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1750 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1751 : asm volatile ("pshufb %xmm10,%xmm4");
1752 : asm volatile ("pshufb %xmm11,%xmm13");
1753 : asm volatile ("pxor %xmm13,%xmm4");
1754 :
1755 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfgenpshufb[l][3][0][0]));
1756 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][3][1][0]));
1757 : asm volatile ("pshufb %xmm10,%xmm5");
1758 : asm volatile ("pshufb %xmm11,%xmm13");
1759 : asm volatile ("pxor %xmm13,%xmm5");
1760 :
1761 : /* intermediate disks */
1762 : for (d = l - 1; d > 0; --d) {
1763 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1764 :
1765 : asm volatile ("pxor %xmm11,%xmm11");
1766 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1767 : asm volatile ("paddb %xmm1,%xmm1");
1768 : asm volatile ("pand %xmm14,%xmm11");
1769 : asm volatile ("pxor %xmm11,%xmm1");
1770 :
1771 : asm volatile ("pxor %xmm10,%xmm0");
1772 : asm volatile ("pxor %xmm10,%xmm1");
1773 :
1774 : asm volatile ("movdqa %xmm10,%xmm11");
1775 : asm volatile ("psrlw $4,%xmm11");
1776 : asm volatile ("pand %xmm15,%xmm10");
1777 : asm volatile ("pand %xmm15,%xmm11");
1778 :
1779 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1780 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1781 : asm volatile ("pshufb %xmm10,%xmm12");
1782 : asm volatile ("pshufb %xmm11,%xmm13");
1783 : asm volatile ("pxor %xmm12,%xmm2");
1784 : asm volatile ("pxor %xmm13,%xmm2");
1785 :
1786 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1787 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1788 : asm volatile ("pshufb %xmm10,%xmm12");
1789 : asm volatile ("pshufb %xmm11,%xmm13");
1790 : asm volatile ("pxor %xmm12,%xmm3");
1791 : asm volatile ("pxor %xmm13,%xmm3");
1792 :
1793 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1794 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1795 : asm volatile ("pshufb %xmm10,%xmm12");
1796 : asm volatile ("pshufb %xmm11,%xmm13");
1797 : asm volatile ("pxor %xmm12,%xmm4");
1798 : asm volatile ("pxor %xmm13,%xmm4");
1799 :
1800 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][3][0][0]));
1801 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][3][1][0]));
1802 : asm volatile ("pshufb %xmm10,%xmm12");
1803 : asm volatile ("pshufb %xmm11,%xmm13");
1804 : asm volatile ("pxor %xmm12,%xmm5");
1805 : asm volatile ("pxor %xmm13,%xmm5");
1806 : }
1807 :
1808 : /* first disk with all coefficients at 1 */
1809 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1810 :
1811 : asm volatile ("pxor %xmm11,%xmm11");
1812 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1813 : asm volatile ("paddb %xmm1,%xmm1");
1814 : asm volatile ("pand %xmm14,%xmm11");
1815 : asm volatile ("pxor %xmm11,%xmm1");
1816 :
1817 : asm volatile ("pxor %xmm10,%xmm0");
1818 : asm volatile ("pxor %xmm10,%xmm1");
1819 : asm volatile ("pxor %xmm10,%xmm2");
1820 : asm volatile ("pxor %xmm10,%xmm3");
1821 : asm volatile ("pxor %xmm10,%xmm4");
1822 : asm volatile ("pxor %xmm10,%xmm5");
1823 :
1824 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1825 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1826 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1827 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1828 : asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
1829 : asm volatile ("movntdq %%xmm5,%0" : "=m" (u[i]));
1830 : }
1831 :
1832 : raid_sse_end();
1833 : }
1834 : #endif
1835 :
1836 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
1837 : /*
1838 : * GEN6 (hexa parity with Cauchy matrix) AVX2 implementation
1839 : *
1840 : * Note that it uses 16 registers, meaning that x64 is required.
1841 : */
1842 : void raid_gen6_avx2ext(int nd, size_t size, void **vv)
1843 : {
1844 : uint8_t **v = (uint8_t **)vv;
1845 : uint8_t *p;
1846 : uint8_t *q;
1847 : uint8_t *r;
1848 : uint8_t *s;
1849 : uint8_t *t;
1850 : uint8_t *u;
1851 : int d, l;
1852 : size_t i;
1853 :
1854 : l = nd - 1;
1855 : p = v[nd];
1856 : q = v[nd + 1];
1857 : r = v[nd + 2];
1858 : s = v[nd + 3];
1859 : t = v[nd + 4];
1860 : u = v[nd + 5];
1861 :
1862 : /* special case with only one data disk */
1863 : if (l == 0) {
1864 : for (i = 0; i < 6; ++i)
1865 : memcpy(v[1 + i], v[0], size);
1866 : return;
1867 : }
1868 :
1869 : raid_avx_begin();
1870 :
1871 : /* generic case with at least two data disks */
1872 : asm volatile ("vpxor %ymm8,%ymm8,%ymm8");
1873 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
1874 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1875 :
1876 : for (i = 0; i < size; i += 32) {
1877 : /* last disk without the by two multiplication */
1878 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
1879 :
1880 : asm volatile ("vmovdqa %ymm10,%ymm0");
1881 : asm volatile ("vmovdqa %ymm10,%ymm1");
1882 :
1883 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1884 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1885 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1886 :
1887 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
1888 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
1889 : asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
1890 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1891 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1892 :
1893 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
1894 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
1895 : asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
1896 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1897 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1898 :
1899 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
1900 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
1901 : asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
1902 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1903 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1904 :
1905 : asm volatile ("vbroadcasti128 %0,%%ymm5" : : "m" (gfgenpshufb[l][3][0][0]));
1906 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][3][1][0]));
1907 : asm volatile ("vpshufb %ymm10,%ymm5,%ymm5");
1908 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1909 : asm volatile ("vpxor %ymm13,%ymm5,%ymm5");
1910 :
1911 : /* intermediate disks */
1912 : for (d = l - 1; d > 0; --d) {
1913 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
1914 :
1915 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1916 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1917 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1918 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1919 :
1920 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1921 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1922 :
1923 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1924 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1925 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1926 :
1927 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
1928 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
1929 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1930 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1931 : asm volatile ("vpxor %ymm12,%ymm2,%ymm2");
1932 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1933 :
1934 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
1935 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
1936 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1937 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1938 : asm volatile ("vpxor %ymm12,%ymm3,%ymm3");
1939 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1940 :
1941 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
1942 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
1943 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1944 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1945 : asm volatile ("vpxor %ymm12,%ymm4,%ymm4");
1946 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1947 :
1948 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][3][0][0]));
1949 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][3][1][0]));
1950 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1951 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1952 : asm volatile ("vpxor %ymm12,%ymm5,%ymm5");
1953 : asm volatile ("vpxor %ymm13,%ymm5,%ymm5");
1954 : }
1955 :
1956 : /* first disk with all coefficients at 1 */
1957 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
1958 :
1959 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1960 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1961 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1962 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1963 :
1964 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1965 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1966 : asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
1967 : asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
1968 : asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
1969 : asm volatile ("vpxor %ymm10,%ymm5,%ymm5");
1970 :
1971 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1972 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1973 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1974 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1975 : asm volatile ("vmovntdq %%ymm4,%0" : "=m" (t[i]));
1976 : asm volatile ("vmovntdq %%ymm5,%0" : "=m" (u[i]));
1977 : }
1978 :
1979 : raid_avx_end();
1980 : }
1981 : #endif
1982 :
1983 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
1984 : /*
1985 : * RAID recovering for one disk SSSE3 implementation
1986 : */
1987 111395 : void raid_rec1_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
1988 : {
1989 111395 : uint8_t **v = (uint8_t **)vv;
1990 : uint8_t *p;
1991 : uint8_t *pa;
1992 : uint8_t G;
1993 : uint8_t V;
1994 : size_t i;
1995 :
1996 : (void)nr; /* unused, it's always 1 */
1997 :
1998 : /* if it's RAID5 uses the faster function */
1999 111395 : if (ip[0] == 0) {
2000 101506 : raid_rec1of1(id, nd, size, vv);
2001 212901 : return;
2002 : }
2003 :
2004 : /* setup the coefficients matrix */
2005 19778 : G = A(ip[0], id[0]);
2006 :
2007 : /* invert it to solve the system of linear equations */
2008 19778 : V = inv(G);
2009 :
2010 : /* compute delta parity */
2011 9889 : raid_delta_gen(1, id, ip, nd, size, vv);
2012 :
2013 9889 : p = v[nd + ip[0]];
2014 9889 : pa = v[id[0]];
2015 :
2016 : raid_sse_begin();
2017 :
2018 9889 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2019 9889 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfmulpshufb[V][0][0]));
2020 9889 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfmulpshufb[V][1][0]));
2021 :
2022 1552673 : for (i = 0; i < size; i += 16) {
2023 1542784 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[i]));
2024 1542784 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[i]));
2025 1542784 : asm volatile ("movdqa %xmm4,%xmm2");
2026 1542784 : asm volatile ("movdqa %xmm5,%xmm3");
2027 1542784 : asm volatile ("pxor %xmm0,%xmm1");
2028 1542784 : asm volatile ("movdqa %xmm1,%xmm0");
2029 1542784 : asm volatile ("psrlw $4,%xmm1");
2030 1542784 : asm volatile ("pand %xmm7,%xmm0");
2031 1542784 : asm volatile ("pand %xmm7,%xmm1");
2032 1542784 : asm volatile ("pshufb %xmm0,%xmm2");
2033 1542784 : asm volatile ("pshufb %xmm1,%xmm3");
2034 1542784 : asm volatile ("pxor %xmm3,%xmm2");
2035 1542784 : asm volatile ("movdqa %%xmm2,%0" : "=m" (pa[i]));
2036 : }
2037 :
2038 : raid_sse_end();
2039 : }
2040 : #endif
2041 :
2042 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
2043 : /*
2044 : * RAID recovering for two disks SSSE3 implementation
2045 : */
2046 44038 : void raid_rec2_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2047 : {
2048 44038 : uint8_t **v = (uint8_t **)vv;
2049 44038 : const int N = 2;
2050 44038 : uint8_t *p[N];
2051 44038 : uint8_t *pa[N];
2052 44038 : uint8_t G[N * N];
2053 44038 : uint8_t V[N * N];
2054 : size_t i;
2055 : int j, k;
2056 :
2057 : (void)nr; /* unused, it's always 2 */
2058 :
2059 : /* setup the coefficients matrix */
2060 132114 : for (j = 0; j < N; ++j)
2061 264228 : for (k = 0; k < N; ++k)
2062 352304 : G[j * N + k] = A(ip[j], id[k]);
2063 :
2064 : /* invert it to solve the system of linear equations */
2065 44038 : raid_invert(G, V, N);
2066 :
2067 : /* compute delta parity */
2068 44038 : raid_delta_gen(N, id, ip, nd, size, vv);
2069 :
2070 132114 : for (j = 0; j < N; ++j) {
2071 88076 : p[j] = v[nd + ip[j]];
2072 88076 : pa[j] = v[id[j]];
2073 : }
2074 :
2075 : raid_sse_begin();
2076 :
2077 44038 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2078 :
2079 3588806 : for (i = 0; i < size; i += 16) {
2080 3544768 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[0][i]));
2081 3544768 : asm volatile ("movdqa %0,%%xmm2" : : "m" (pa[0][i]));
2082 3544768 : asm volatile ("movdqa %0,%%xmm1" : : "m" (p[1][i]));
2083 3544768 : asm volatile ("movdqa %0,%%xmm3" : : "m" (pa[1][i]));
2084 3544768 : asm volatile ("pxor %xmm2,%xmm0");
2085 3544768 : asm volatile ("pxor %xmm3,%xmm1");
2086 :
2087 3544768 : asm volatile ("pxor %xmm6,%xmm6");
2088 :
2089 3544768 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[0]][0][0]));
2090 3544768 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[0]][1][0]));
2091 3544768 : asm volatile ("movdqa %xmm0,%xmm4");
2092 3544768 : asm volatile ("movdqa %xmm0,%xmm5");
2093 3544768 : asm volatile ("psrlw $4,%xmm5");
2094 3544768 : asm volatile ("pand %xmm7,%xmm4");
2095 3544768 : asm volatile ("pand %xmm7,%xmm5");
2096 3544768 : asm volatile ("pshufb %xmm4,%xmm2");
2097 3544768 : asm volatile ("pshufb %xmm5,%xmm3");
2098 3544768 : asm volatile ("pxor %xmm2,%xmm6");
2099 3544768 : asm volatile ("pxor %xmm3,%xmm6");
2100 :
2101 3544768 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[1]][0][0]));
2102 3544768 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[1]][1][0]));
2103 3544768 : asm volatile ("movdqa %xmm1,%xmm4");
2104 3544768 : asm volatile ("movdqa %xmm1,%xmm5");
2105 3544768 : asm volatile ("psrlw $4,%xmm5");
2106 3544768 : asm volatile ("pand %xmm7,%xmm4");
2107 3544768 : asm volatile ("pand %xmm7,%xmm5");
2108 3544768 : asm volatile ("pshufb %xmm4,%xmm2");
2109 3544768 : asm volatile ("pshufb %xmm5,%xmm3");
2110 3544768 : asm volatile ("pxor %xmm2,%xmm6");
2111 3544768 : asm volatile ("pxor %xmm3,%xmm6");
2112 :
2113 3544768 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[0][i]));
2114 :
2115 3544768 : asm volatile ("pxor %xmm6,%xmm6");
2116 :
2117 3544768 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[2]][0][0]));
2118 3544768 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[2]][1][0]));
2119 3544768 : asm volatile ("movdqa %xmm0,%xmm4");
2120 3544768 : asm volatile ("movdqa %xmm0,%xmm5");
2121 3544768 : asm volatile ("psrlw $4,%xmm5");
2122 3544768 : asm volatile ("pand %xmm7,%xmm4");
2123 3544768 : asm volatile ("pand %xmm7,%xmm5");
2124 3544768 : asm volatile ("pshufb %xmm4,%xmm2");
2125 3544768 : asm volatile ("pshufb %xmm5,%xmm3");
2126 3544768 : asm volatile ("pxor %xmm2,%xmm6");
2127 3544768 : asm volatile ("pxor %xmm3,%xmm6");
2128 :
2129 3544768 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[3]][0][0]));
2130 3544768 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[3]][1][0]));
2131 3544768 : asm volatile ("movdqa %xmm1,%xmm4");
2132 3544768 : asm volatile ("movdqa %xmm1,%xmm5");
2133 3544768 : asm volatile ("psrlw $4,%xmm5");
2134 3544768 : asm volatile ("pand %xmm7,%xmm4");
2135 3544768 : asm volatile ("pand %xmm7,%xmm5");
2136 3544768 : asm volatile ("pshufb %xmm4,%xmm2");
2137 3544768 : asm volatile ("pshufb %xmm5,%xmm3");
2138 3544768 : asm volatile ("pxor %xmm2,%xmm6");
2139 3544768 : asm volatile ("pxor %xmm3,%xmm6");
2140 :
2141 3544768 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[1][i]));
2142 : }
2143 :
2144 : raid_sse_end();
2145 44038 : }
2146 : #endif
2147 :
2148 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
2149 : /*
2150 : * RAID recovering SSSE3 implementation
2151 : */
2152 79288 : void raid_recX_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2153 : {
2154 79288 : uint8_t **v = (uint8_t **)vv;
2155 79288 : int N = nr;
2156 : uint8_t *p[RAID_PARITY_MAX];
2157 : uint8_t *pa[RAID_PARITY_MAX];
2158 : uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
2159 : uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
2160 : uint8_t buffer[RAID_PARITY_MAX*16+16];
2161 79288 : uint8_t *pd = __align_ptr(buffer, 16);
2162 : size_t i;
2163 : int j, k;
2164 :
2165 : /* setup the coefficients matrix */
2166 435102 : for (j = 0; j < N; ++j)
2167 2046374 : for (k = 0; k < N; ++k)
2168 3381120 : G[j * N + k] = A(ip[j], id[k]);
2169 :
2170 : /* invert it to solve the system of linear equations */
2171 79288 : raid_invert(G, V, N);
2172 :
2173 : /* compute delta parity */
2174 79288 : raid_delta_gen(N, id, ip, nd, size, vv);
2175 :
2176 435102 : for (j = 0; j < N; ++j) {
2177 355814 : p[j] = v[nd + ip[j]];
2178 355814 : pa[j] = v[id[j]];
2179 : }
2180 :
2181 : raid_sse_begin();
2182 :
2183 79288 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2184 :
2185 5869832 : for (i = 0; i < size; i += 16) {
2186 : /* delta */
2187 32115408 : for (j = 0; j < N; ++j) {
2188 26324864 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[j][i]));
2189 26324864 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[j][i]));
2190 26324864 : asm volatile ("pxor %xmm1,%xmm0");
2191 26324864 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pd[j*16]));
2192 : }
2193 :
2194 : /* reconstruct */
2195 32115408 : for (j = 0; j < N; ++j) {
2196 26324864 : asm volatile ("pxor %xmm0,%xmm0");
2197 26324864 : asm volatile ("pxor %xmm1,%xmm1");
2198 :
2199 153207872 : for (k = 0; k < N; ++k) {
2200 126883008 : uint8_t m = V[j * N + k];
2201 :
2202 126883008 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[m][0][0]));
2203 126883008 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[m][1][0]));
2204 126883008 : asm volatile ("movdqa %0,%%xmm4" : : "m" (pd[k*16]));
2205 126883008 : asm volatile ("movdqa %xmm4,%xmm5");
2206 126883008 : asm volatile ("psrlw $4,%xmm5");
2207 126883008 : asm volatile ("pand %xmm7,%xmm4");
2208 126883008 : asm volatile ("pand %xmm7,%xmm5");
2209 126883008 : asm volatile ("pshufb %xmm4,%xmm2");
2210 126883008 : asm volatile ("pshufb %xmm5,%xmm3");
2211 126883008 : asm volatile ("pxor %xmm2,%xmm0");
2212 126883008 : asm volatile ("pxor %xmm3,%xmm1");
2213 : }
2214 :
2215 26324864 : asm volatile ("pxor %xmm1,%xmm0");
2216 26324864 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pa[j][i]));
2217 : }
2218 : }
2219 :
2220 : raid_sse_end();
2221 79288 : }
2222 : #endif
2223 :
2224 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
2225 : /*
2226 : * RAID recovering for one disk AVX2 implementation
2227 : */
2228 126 : void raid_rec1_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2229 : {
2230 126 : uint8_t **v = (uint8_t **)vv;
2231 : uint8_t *p;
2232 : uint8_t *pa;
2233 : uint8_t G;
2234 : uint8_t V;
2235 : size_t i;
2236 :
2237 : (void)nr; /* unused, it's always 1 */
2238 :
2239 : /* if it's RAID5 uses the faster function */
2240 126 : if (ip[0] == 0) {
2241 30 : raid_rec1of1(id, nd, size, vv);
2242 156 : return;
2243 : }
2244 :
2245 : /* setup the coefficients matrix */
2246 192 : G = A(ip[0], id[0]);
2247 :
2248 : /* invert it to solve the system of linear equations */
2249 192 : V = inv(G);
2250 :
2251 : /* compute delta parity */
2252 96 : raid_delta_gen(1, id, ip, nd, size, vv);
2253 :
2254 96 : p = v[nd + ip[0]];
2255 96 : pa = v[id[0]];
2256 :
2257 : raid_avx_begin();
2258 :
2259 96 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
2260 96 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfmulpshufb[V][0][0]));
2261 96 : asm volatile ("vbroadcasti128 %0,%%ymm5" : : "m" (gfmulpshufb[V][1][0]));
2262 :
2263 66816 : for (i = 0; i < size; i += 32) {
2264 66720 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[i]));
2265 66720 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (pa[i]));
2266 66720 : asm volatile ("vpxor %ymm1,%ymm0,%ymm0");
2267 66720 : asm volatile ("vpsrlw $4,%ymm0,%ymm1");
2268 66720 : asm volatile ("vpand %ymm7,%ymm0,%ymm0");
2269 66720 : asm volatile ("vpand %ymm7,%ymm1,%ymm1");
2270 66720 : asm volatile ("vpshufb %ymm0,%ymm4,%ymm2");
2271 66720 : asm volatile ("vpshufb %ymm1,%ymm5,%ymm3");
2272 66720 : asm volatile ("vpxor %ymm3,%ymm2,%ymm2");
2273 66720 : asm volatile ("vmovdqa %%ymm2,%0" : "=m" (pa[i]));
2274 : }
2275 :
2276 : raid_avx_end();
2277 : }
2278 : #endif
2279 :
2280 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
2281 : /*
2282 : * RAID recovering for two disks AVX2 implementation
2283 : */
2284 1206 : void raid_rec2_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2285 : {
2286 1206 : uint8_t **v = (uint8_t **)vv;
2287 1206 : const int N = 2;
2288 1206 : uint8_t *p[N];
2289 1206 : uint8_t *pa[N];
2290 1206 : uint8_t G[N * N];
2291 1206 : uint8_t V[N * N];
2292 : size_t i;
2293 : int j, k;
2294 :
2295 : (void)nr; /* unused, it's always 2 */
2296 :
2297 : /* setup the coefficients matrix */
2298 3618 : for (j = 0; j < N; ++j)
2299 7236 : for (k = 0; k < N; ++k)
2300 9648 : G[j * N + k] = A(ip[j], id[k]);
2301 :
2302 : /* invert it to solve the system of linear equations */
2303 1206 : raid_invert(G, V, N);
2304 :
2305 : /* compute delta parity */
2306 1206 : raid_delta_gen(N, id, ip, nd, size, vv);
2307 :
2308 3618 : for (j = 0; j < N; ++j) {
2309 2412 : p[j] = v[nd + ip[j]];
2310 2412 : pa[j] = v[id[j]];
2311 : }
2312 :
2313 : raid_avx_begin();
2314 :
2315 1206 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
2316 :
2317 77526 : for (i = 0; i < size; i += 32) {
2318 76320 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[0][i]));
2319 76320 : asm volatile ("vmovdqa %0,%%ymm2" : : "m" (pa[0][i]));
2320 76320 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (p[1][i]));
2321 76320 : asm volatile ("vmovdqa %0,%%ymm3" : : "m" (pa[1][i]));
2322 76320 : asm volatile ("vpxor %ymm2,%ymm0,%ymm0");
2323 76320 : asm volatile ("vpxor %ymm3,%ymm1,%ymm1");
2324 :
2325 76320 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
2326 :
2327 76320 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[0]][0][0]));
2328 76320 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[0]][1][0]));
2329 76320 : asm volatile ("vpsrlw $4,%ymm0,%ymm5");
2330 76320 : asm volatile ("vpand %ymm7,%ymm0,%ymm4");
2331 76320 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2332 76320 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2333 76320 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2334 76320 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2335 76320 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2336 :
2337 76320 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[1]][0][0]));
2338 76320 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[1]][1][0]));
2339 76320 : asm volatile ("vpsrlw $4,%ymm1,%ymm5");
2340 76320 : asm volatile ("vpand %ymm7,%ymm1,%ymm4");
2341 76320 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2342 76320 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2343 76320 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2344 76320 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2345 76320 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2346 :
2347 76320 : asm volatile ("vmovdqa %%ymm6,%0" : "=m" (pa[0][i]));
2348 :
2349 76320 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
2350 :
2351 76320 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[2]][0][0]));
2352 76320 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[2]][1][0]));
2353 76320 : asm volatile ("vpsrlw $4,%ymm0,%ymm5");
2354 76320 : asm volatile ("vpand %ymm7,%ymm0,%ymm4");
2355 76320 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2356 76320 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2357 76320 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2358 76320 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2359 76320 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2360 :
2361 76320 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[V[3]][0][0]));
2362 76320 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[V[3]][1][0]));
2363 76320 : asm volatile ("vpsrlw $4,%ymm1,%ymm5");
2364 76320 : asm volatile ("vpand %ymm7,%ymm1,%ymm4");
2365 76320 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2366 76320 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2367 76320 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2368 76320 : asm volatile ("vpxor %ymm2,%ymm6,%ymm6");
2369 76320 : asm volatile ("vpxor %ymm3,%ymm6,%ymm6");
2370 :
2371 76320 : asm volatile ("vmovdqa %%ymm6,%0" : "=m" (pa[1][i]));
2372 : }
2373 :
2374 : raid_avx_end();
2375 1206 : }
2376 : #endif
2377 :
2378 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
2379 : /*
2380 : * RAID recovering AVX2 implementation
2381 : */
2382 17765 : void raid_recX_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2383 : {
2384 17765 : uint8_t **v = (uint8_t **)vv;
2385 17765 : int N = nr;
2386 : uint8_t *p[RAID_PARITY_MAX];
2387 : uint8_t *pa[RAID_PARITY_MAX];
2388 : uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
2389 : uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
2390 : uint8_t buffer[RAID_PARITY_MAX*32+32];
2391 17765 : uint8_t *pd = __align_ptr(buffer, 32);
2392 : size_t i;
2393 : int j, k;
2394 :
2395 : /* setup the coefficients matrix */
2396 90821 : for (j = 0; j < N; ++j)
2397 386396 : for (k = 0; k < N; ++k)
2398 626680 : G[j * N + k] = A(ip[j], id[k]);
2399 :
2400 : /* invert it to solve the system of linear equations */
2401 17765 : raid_invert(G, V, N);
2402 :
2403 : /* compute delta parity */
2404 17765 : raid_delta_gen(N, id, ip, nd, size, vv);
2405 :
2406 90821 : for (j = 0; j < N; ++j) {
2407 73056 : p[j] = v[nd + ip[j]];
2408 73056 : pa[j] = v[id[j]];
2409 : }
2410 :
2411 : raid_avx_begin();
2412 :
2413 17765 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.low4[0]));
2414 :
2415 423213 : for (i = 0; i < size; i += 32) {
2416 : /* delta */
2417 2174152 : for (j = 0; j < N; ++j) {
2418 1768704 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (p[j][i]));
2419 1768704 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (pa[j][i]));
2420 1768704 : asm volatile ("vpxor %ymm1,%ymm0,%ymm0");
2421 1768704 : asm volatile ("vmovdqa %%ymm0,%0" : "=m" (pd[j*32]));
2422 : }
2423 :
2424 : /* reconstruct */
2425 2174152 : for (j = 0; j < N; ++j) {
2426 1768704 : asm volatile ("vpxor %ymm0,%ymm0,%ymm0");
2427 1768704 : asm volatile ("vpxor %ymm1,%ymm1,%ymm1");
2428 :
2429 9930976 : for (k = 0; k < N; ++k) {
2430 8162272 : uint8_t m = V[j * N + k];
2431 :
2432 8162272 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfmulpshufb[m][0][0]));
2433 8162272 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfmulpshufb[m][1][0]));
2434 8162272 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (pd[k*32]));
2435 8162272 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
2436 8162272 : asm volatile ("vpand %ymm7,%ymm4,%ymm4");
2437 8162272 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
2438 8162272 : asm volatile ("vpshufb %ymm4,%ymm2,%ymm2");
2439 8162272 : asm volatile ("vpshufb %ymm5,%ymm3,%ymm3");
2440 8162272 : asm volatile ("vpxor %ymm2,%ymm0,%ymm0");
2441 8162272 : asm volatile ("vpxor %ymm3,%ymm1,%ymm1");
2442 : }
2443 :
2444 1768704 : asm volatile ("vpxor %ymm1,%ymm0,%ymm0");
2445 1768704 : asm volatile ("vmovdqa %%ymm0,%0" : "=m" (pa[j][i]));
2446 : }
2447 : }
2448 :
2449 : raid_avx_end();
2450 17765 : }
2451 : #endif
2452 :
|