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 288623 : void raid_gen1_sse2(int nd, size_t size, void **vv)
37 : {
38 288623 : uint8_t **v = (uint8_t **)vv;
39 : uint8_t *p;
40 : int d, l;
41 : size_t i;
42 :
43 288623 : l = nd - 1;
44 288623 : p = v[nd];
45 :
46 : raid_sse_begin();
47 :
48 5714395 : for (i = 0; i < size; i += 64) {
49 5425772 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
50 5425772 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
51 5425772 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
52 5425772 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
53 34176836 : for (d = l - 1; d >= 0; --d) {
54 28751064 : asm volatile ("pxor %0,%%xmm0" : : "m" (v[d][i]));
55 28751064 : asm volatile ("pxor %0,%%xmm1" : : "m" (v[d][i + 16]));
56 28751064 : asm volatile ("pxor %0,%%xmm2" : : "m" (v[d][i + 32]));
57 28751064 : asm volatile ("pxor %0,%%xmm3" : : "m" (v[d][i + 48]));
58 : }
59 5425772 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
60 5425772 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
61 5425772 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
62 5425772 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
63 : }
64 :
65 : raid_sse_end();
66 288623 : }
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 86 : void raid_gen1_avx2(int nd, size_t size, void **vv)
78 : {
79 86 : uint8_t **v = (uint8_t **)vv;
80 : uint8_t *p;
81 : int d, l;
82 : size_t i;
83 :
84 86 : l = nd - 1;
85 86 : p = v[nd];
86 :
87 : raid_avx_begin();
88 :
89 5122 : for (i = 0; i < size; i += 64) {
90 5036 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
91 5036 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
92 46724 : for (d = l - 1; d >= 0; --d) {
93 41688 : asm volatile ("vpxor %0,%%ymm0,%%ymm0" : : "m" (v[d][i]));
94 41688 : asm volatile ("vpxor %0,%%ymm1,%%ymm1" : : "m" (v[d][i + 32]));
95 : }
96 5036 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
97 5036 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
98 : }
99 :
100 : raid_avx_end();
101 86 : }
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 145 : void raid_gen2_sse2(int nd, size_t size, void **vv)
125 : {
126 145 : uint8_t **v = (uint8_t **)vv;
127 : uint8_t *p;
128 : uint8_t *q;
129 : int d, l;
130 : size_t i;
131 :
132 145 : l = nd - 1;
133 145 : p = v[nd];
134 145 : q = v[nd + 1];
135 :
136 : raid_sse_begin();
137 :
138 145 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
139 :
140 1163433 : for (i = 0; i < size; i += 32) {
141 1163288 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
142 1163288 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
143 1163288 : asm volatile ("movdqa %xmm0,%xmm2");
144 1163288 : asm volatile ("movdqa %xmm1,%xmm3");
145 9306632 : for (d = l - 1; d >= 0; --d) {
146 8143344 : asm volatile ("pxor %xmm4,%xmm4");
147 8143344 : asm volatile ("pxor %xmm5,%xmm5");
148 8143344 : asm volatile ("pcmpgtb %xmm2,%xmm4");
149 8143344 : asm volatile ("pcmpgtb %xmm3,%xmm5");
150 8143344 : asm volatile ("paddb %xmm2,%xmm2");
151 8143344 : asm volatile ("paddb %xmm3,%xmm3");
152 8143344 : asm volatile ("pand %xmm7,%xmm4");
153 8143344 : asm volatile ("pand %xmm7,%xmm5");
154 8143344 : asm volatile ("pxor %xmm4,%xmm2");
155 8143344 : asm volatile ("pxor %xmm5,%xmm3");
156 :
157 8143344 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
158 8143344 : asm volatile ("movdqa %0,%%xmm5" : : "m" (v[d][i + 16]));
159 8143344 : asm volatile ("pxor %xmm4,%xmm0");
160 8143344 : asm volatile ("pxor %xmm5,%xmm1");
161 8143344 : asm volatile ("pxor %xmm4,%xmm2");
162 8143344 : asm volatile ("pxor %xmm5,%xmm3");
163 : }
164 1163288 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
165 1163288 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
166 1163288 : asm volatile ("movntdq %%xmm2,%0" : "=m" (q[i]));
167 1163288 : asm volatile ("movntdq %%xmm3,%0" : "=m" (q[i + 16]));
168 : }
169 :
170 : raid_sse_end();
171 145 : }
172 : #endif
173 :
174 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
175 : /*
176 : * GEN2 (RAID6 with powers of 2) AVX2 implementation
177 : */
178 511 : void raid_gen2_avx2(int nd, size_t size, void **vv)
179 : {
180 511 : uint8_t **v = (uint8_t **)vv;
181 : uint8_t *p;
182 : uint8_t *q;
183 : int d, l;
184 : size_t i;
185 :
186 511 : l = nd - 1;
187 511 : p = v[nd];
188 511 : q = v[nd + 1];
189 :
190 : raid_avx_begin();
191 :
192 511 : asm volatile ("vbroadcasti128 %0, %%ymm7" : : "m" (gfconst16.poly[0]));
193 511 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
194 :
195 117851 : for (i = 0; i < size; i += 64) {
196 117340 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
197 117340 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
198 117340 : asm volatile ("vmovdqa %ymm0,%ymm2");
199 117340 : asm volatile ("vmovdqa %ymm1,%ymm3");
200 952516 : for (d = l - 1; d >= 0; --d) {
201 835176 : asm volatile ("vpcmpgtb %ymm2,%ymm6,%ymm4");
202 835176 : asm volatile ("vpcmpgtb %ymm3,%ymm6,%ymm5");
203 835176 : asm volatile ("vpaddb %ymm2,%ymm2,%ymm2");
204 835176 : asm volatile ("vpaddb %ymm3,%ymm3,%ymm3");
205 835176 : asm volatile ("vpand %ymm7,%ymm4,%ymm4");
206 835176 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
207 835176 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
208 835176 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
209 :
210 835176 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
211 835176 : asm volatile ("vmovdqa %0,%%ymm5" : : "m" (v[d][i + 32]));
212 835176 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
213 835176 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
214 835176 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
215 835176 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
216 : }
217 117340 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
218 117340 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
219 117340 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (q[i]));
220 117340 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (q[i + 32]));
221 : }
222 :
223 : raid_avx_end();
224 511 : }
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 269129 : void raid_gen2_sse2ext(int nd, size_t size, void **vv)
234 : {
235 269129 : uint8_t **v = (uint8_t **)vv;
236 : uint8_t *p;
237 : uint8_t *q;
238 : int d, l;
239 : size_t i;
240 :
241 269129 : l = nd - 1;
242 269129 : p = v[nd];
243 269129 : q = v[nd + 1];
244 :
245 : raid_sse_begin();
246 :
247 269129 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.poly[0]));
248 :
249 5513557 : for (i = 0; i < size; i += 64) {
250 5244428 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
251 5244428 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
252 5244428 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
253 5244428 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
254 5244428 : asm volatile ("movdqa %xmm0,%xmm4");
255 5244428 : asm volatile ("movdqa %xmm1,%xmm5");
256 5244428 : asm volatile ("movdqa %xmm2,%xmm6");
257 5244428 : asm volatile ("movdqa %xmm3,%xmm7");
258 33350916 : for (d = l - 1; d >= 0; --d) {
259 28106488 : asm volatile ("pxor %xmm8,%xmm8");
260 28106488 : asm volatile ("pxor %xmm9,%xmm9");
261 28106488 : asm volatile ("pxor %xmm10,%xmm10");
262 28106488 : asm volatile ("pxor %xmm11,%xmm11");
263 28106488 : asm volatile ("pcmpgtb %xmm4,%xmm8");
264 28106488 : asm volatile ("pcmpgtb %xmm5,%xmm9");
265 28106488 : asm volatile ("pcmpgtb %xmm6,%xmm10");
266 28106488 : asm volatile ("pcmpgtb %xmm7,%xmm11");
267 28106488 : asm volatile ("paddb %xmm4,%xmm4");
268 28106488 : asm volatile ("paddb %xmm5,%xmm5");
269 28106488 : asm volatile ("paddb %xmm6,%xmm6");
270 28106488 : asm volatile ("paddb %xmm7,%xmm7");
271 28106488 : asm volatile ("pand %xmm15,%xmm8");
272 28106488 : asm volatile ("pand %xmm15,%xmm9");
273 28106488 : asm volatile ("pand %xmm15,%xmm10");
274 28106488 : asm volatile ("pand %xmm15,%xmm11");
275 28106488 : asm volatile ("pxor %xmm8,%xmm4");
276 28106488 : asm volatile ("pxor %xmm9,%xmm5");
277 28106488 : asm volatile ("pxor %xmm10,%xmm6");
278 28106488 : asm volatile ("pxor %xmm11,%xmm7");
279 :
280 28106488 : asm volatile ("movdqa %0,%%xmm8" : : "m" (v[d][i]));
281 28106488 : asm volatile ("movdqa %0,%%xmm9" : : "m" (v[d][i + 16]));
282 28106488 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i + 32]));
283 28106488 : asm volatile ("movdqa %0,%%xmm11" : : "m" (v[d][i + 48]));
284 28106488 : asm volatile ("pxor %xmm8,%xmm0");
285 28106488 : asm volatile ("pxor %xmm9,%xmm1");
286 28106488 : asm volatile ("pxor %xmm10,%xmm2");
287 28106488 : asm volatile ("pxor %xmm11,%xmm3");
288 28106488 : asm volatile ("pxor %xmm8,%xmm4");
289 28106488 : asm volatile ("pxor %xmm9,%xmm5");
290 28106488 : asm volatile ("pxor %xmm10,%xmm6");
291 28106488 : asm volatile ("pxor %xmm11,%xmm7");
292 : }
293 5244428 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
294 5244428 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
295 5244428 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
296 5244428 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
297 5244428 : asm volatile ("movntdq %%xmm4,%0" : "=m" (q[i]));
298 5244428 : asm volatile ("movntdq %%xmm5,%0" : "=m" (q[i + 16]));
299 5244428 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i + 32]));
300 5244428 : asm volatile ("movntdq %%xmm7,%0" : "=m" (q[i + 48]));
301 : }
302 :
303 : raid_sse_end();
304 269129 : }
305 : #endif
306 :
307 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
308 : /*
309 : * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
310 : */
311 45 : void raid_gen3_ssse3(int nd, size_t size, void **vv)
312 : {
313 45 : 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 45 : l = nd - 1;
321 45 : p = v[nd];
322 45 : q = v[nd + 1];
323 45 : r = v[nd + 2];
324 :
325 : /* special case with only one data disk */
326 45 : if (l == 0) {
327 4 : for (i = 0; i < 3; ++i)
328 3 : memcpy(v[1 + i], v[0], size);
329 1 : return;
330 : }
331 :
332 : raid_sse_begin();
333 :
334 : /* generic case with at least two data disks */
335 44 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
336 44 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
337 :
338 704572 : for (i = 0; i < size; i += 16) {
339 : /* last disk without the by two multiplication */
340 704528 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
341 :
342 704528 : asm volatile ("movdqa %xmm4,%xmm0");
343 704528 : asm volatile ("movdqa %xmm4,%xmm1");
344 :
345 704528 : asm volatile ("movdqa %xmm4,%xmm5");
346 704528 : asm volatile ("psrlw $4,%xmm5");
347 704528 : asm volatile ("pand %xmm7,%xmm4");
348 704528 : asm volatile ("pand %xmm7,%xmm5");
349 :
350 704528 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
351 704528 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[l][0][1][0]));
352 704528 : asm volatile ("pshufb %xmm4,%xmm2");
353 704528 : asm volatile ("pshufb %xmm5,%xmm6");
354 704528 : asm volatile ("pxor %xmm6,%xmm2");
355 :
356 : /* intermediate disks */
357 4932080 : for (d = l - 1; d > 0; --d) {
358 4227552 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
359 :
360 4227552 : asm volatile ("pxor %xmm5,%xmm5");
361 4227552 : asm volatile ("pcmpgtb %xmm1,%xmm5");
362 4227552 : asm volatile ("paddb %xmm1,%xmm1");
363 4227552 : asm volatile ("pand %xmm3,%xmm5");
364 4227552 : asm volatile ("pxor %xmm5,%xmm1");
365 :
366 4227552 : asm volatile ("pxor %xmm4,%xmm0");
367 4227552 : asm volatile ("pxor %xmm4,%xmm1");
368 :
369 4227552 : asm volatile ("movdqa %xmm4,%xmm5");
370 4227552 : asm volatile ("psrlw $4,%xmm5");
371 4227552 : asm volatile ("pand %xmm7,%xmm4");
372 4227552 : asm volatile ("pand %xmm7,%xmm5");
373 :
374 4227552 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
375 4227552 : asm volatile ("pshufb %xmm4,%xmm6");
376 4227552 : asm volatile ("pxor %xmm6,%xmm2");
377 4227552 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][1][0]));
378 4227552 : asm volatile ("pshufb %xmm5,%xmm6");
379 4227552 : asm volatile ("pxor %xmm6,%xmm2");
380 : }
381 :
382 : /* first disk with all coefficients at 1 */
383 704528 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
384 :
385 704528 : asm volatile ("pxor %xmm5,%xmm5");
386 704528 : asm volatile ("pcmpgtb %xmm1,%xmm5");
387 704528 : asm volatile ("paddb %xmm1,%xmm1");
388 704528 : asm volatile ("pand %xmm3,%xmm5");
389 704528 : asm volatile ("pxor %xmm5,%xmm1");
390 :
391 704528 : asm volatile ("pxor %xmm4,%xmm0");
392 704528 : asm volatile ("pxor %xmm4,%xmm1");
393 704528 : asm volatile ("pxor %xmm4,%xmm2");
394 :
395 704528 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
396 704528 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
397 704528 : 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 28387 : void raid_gen3_ssse3ext(int nd, size_t size, void **vv)
411 : {
412 28387 : 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 28387 : l = nd - 1;
420 28387 : p = v[nd];
421 28387 : q = v[nd + 1];
422 28387 : r = v[nd + 2];
423 :
424 : /* special case with only one data disk */
425 28387 : if (l == 0) {
426 4 : for (i = 0; i < 3; ++i)
427 3 : memcpy(v[1 + i], v[0], size);
428 1 : return;
429 : }
430 :
431 : raid_sse_begin();
432 :
433 : /* generic case with at least two data disks */
434 28386 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
435 28386 : asm volatile ("movdqa %0,%%xmm11" : : "m" (gfconst16.low4[0]));
436 :
437 2013834 : for (i = 0; i < size; i += 32) {
438 : /* last disk without the by two multiplication */
439 1985448 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
440 1985448 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
441 :
442 1985448 : asm volatile ("movdqa %xmm4,%xmm0");
443 1985448 : asm volatile ("movdqa %xmm4,%xmm1");
444 1985448 : asm volatile ("movdqa %xmm12,%xmm8");
445 1985448 : asm volatile ("movdqa %xmm12,%xmm9");
446 :
447 1985448 : asm volatile ("movdqa %xmm4,%xmm5");
448 1985448 : asm volatile ("movdqa %xmm12,%xmm13");
449 1985448 : asm volatile ("psrlw $4,%xmm5");
450 1985448 : asm volatile ("psrlw $4,%xmm13");
451 1985448 : asm volatile ("pand %xmm11,%xmm4");
452 1985448 : asm volatile ("pand %xmm11,%xmm12");
453 1985448 : asm volatile ("pand %xmm11,%xmm5");
454 1985448 : asm volatile ("pand %xmm11,%xmm13");
455 :
456 1985448 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
457 1985448 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
458 1985448 : asm volatile ("movdqa %xmm2,%xmm10");
459 1985448 : asm volatile ("movdqa %xmm7,%xmm15");
460 1985448 : asm volatile ("pshufb %xmm4,%xmm2");
461 1985448 : asm volatile ("pshufb %xmm12,%xmm10");
462 1985448 : asm volatile ("pshufb %xmm5,%xmm7");
463 1985448 : asm volatile ("pshufb %xmm13,%xmm15");
464 1985448 : asm volatile ("pxor %xmm7,%xmm2");
465 1985448 : asm volatile ("pxor %xmm15,%xmm10");
466 :
467 : /* intermediate disks */
468 12090136 : for (d = l - 1; d > 0; --d) {
469 10104688 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
470 10104688 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
471 :
472 10104688 : asm volatile ("pxor %xmm5,%xmm5");
473 10104688 : asm volatile ("pxor %xmm13,%xmm13");
474 10104688 : asm volatile ("pcmpgtb %xmm1,%xmm5");
475 10104688 : asm volatile ("pcmpgtb %xmm9,%xmm13");
476 10104688 : asm volatile ("paddb %xmm1,%xmm1");
477 10104688 : asm volatile ("paddb %xmm9,%xmm9");
478 10104688 : asm volatile ("pand %xmm3,%xmm5");
479 10104688 : asm volatile ("pand %xmm3,%xmm13");
480 10104688 : asm volatile ("pxor %xmm5,%xmm1");
481 10104688 : asm volatile ("pxor %xmm13,%xmm9");
482 :
483 10104688 : asm volatile ("pxor %xmm4,%xmm0");
484 10104688 : asm volatile ("pxor %xmm4,%xmm1");
485 10104688 : asm volatile ("pxor %xmm12,%xmm8");
486 10104688 : asm volatile ("pxor %xmm12,%xmm9");
487 :
488 10104688 : asm volatile ("movdqa %xmm4,%xmm5");
489 10104688 : asm volatile ("movdqa %xmm12,%xmm13");
490 10104688 : asm volatile ("psrlw $4,%xmm5");
491 10104688 : asm volatile ("psrlw $4,%xmm13");
492 10104688 : asm volatile ("pand %xmm11,%xmm4");
493 10104688 : asm volatile ("pand %xmm11,%xmm12");
494 10104688 : asm volatile ("pand %xmm11,%xmm5");
495 10104688 : asm volatile ("pand %xmm11,%xmm13");
496 :
497 10104688 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
498 10104688 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
499 10104688 : asm volatile ("movdqa %xmm6,%xmm14");
500 10104688 : asm volatile ("movdqa %xmm7,%xmm15");
501 10104688 : asm volatile ("pshufb %xmm4,%xmm6");
502 10104688 : asm volatile ("pshufb %xmm12,%xmm14");
503 10104688 : asm volatile ("pshufb %xmm5,%xmm7");
504 10104688 : asm volatile ("pshufb %xmm13,%xmm15");
505 10104688 : asm volatile ("pxor %xmm6,%xmm2");
506 10104688 : asm volatile ("pxor %xmm14,%xmm10");
507 10104688 : asm volatile ("pxor %xmm7,%xmm2");
508 10104688 : asm volatile ("pxor %xmm15,%xmm10");
509 : }
510 :
511 : /* first disk with all coefficients at 1 */
512 1985448 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
513 1985448 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
514 :
515 1985448 : asm volatile ("pxor %xmm5,%xmm5");
516 1985448 : asm volatile ("pxor %xmm13,%xmm13");
517 1985448 : asm volatile ("pcmpgtb %xmm1,%xmm5");
518 1985448 : asm volatile ("pcmpgtb %xmm9,%xmm13");
519 1985448 : asm volatile ("paddb %xmm1,%xmm1");
520 1985448 : asm volatile ("paddb %xmm9,%xmm9");
521 1985448 : asm volatile ("pand %xmm3,%xmm5");
522 1985448 : asm volatile ("pand %xmm3,%xmm13");
523 1985448 : asm volatile ("pxor %xmm5,%xmm1");
524 1985448 : asm volatile ("pxor %xmm13,%xmm9");
525 :
526 1985448 : asm volatile ("pxor %xmm4,%xmm0");
527 1985448 : asm volatile ("pxor %xmm4,%xmm1");
528 1985448 : asm volatile ("pxor %xmm4,%xmm2");
529 1985448 : asm volatile ("pxor %xmm12,%xmm8");
530 1985448 : asm volatile ("pxor %xmm12,%xmm9");
531 1985448 : asm volatile ("pxor %xmm12,%xmm10");
532 :
533 1985448 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
534 1985448 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
535 1985448 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
536 1985448 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
537 1985448 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
538 1985448 : 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 1154 : void raid_gen3_avx2ext(int nd, size_t size, void **vv)
552 : {
553 1154 : 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 1154 : l = nd - 1;
561 1154 : p = v[nd];
562 1154 : q = v[nd + 1];
563 1154 : r = v[nd + 2];
564 :
565 : /* special case with only one data disk */
566 1154 : if (l == 0) {
567 4 : for (i = 0; i < 3; ++i)
568 3 : memcpy(v[1 + i], v[0], size);
569 1 : return;
570 : }
571 :
572 : raid_avx_begin();
573 :
574 : /* generic case with at least two data disks */
575 1153 : asm volatile ("vbroadcasti128 %0, %%ymm3" : : "m" (gfconst16.poly[0]));
576 1153 : asm volatile ("vbroadcasti128 %0, %%ymm11" : : "m" (gfconst16.low4[0]));
577 :
578 210965 : for (i = 0; i < size; i += 64) {
579 : /* last disk without the by two multiplication */
580 209812 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
581 209812 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
582 :
583 209812 : asm volatile ("vmovdqa %ymm4,%ymm0");
584 209812 : asm volatile ("vmovdqa %ymm4,%ymm1");
585 209812 : asm volatile ("vmovdqa %ymm12,%ymm8");
586 209812 : asm volatile ("vmovdqa %ymm12,%ymm9");
587 :
588 209812 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
589 209812 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
590 209812 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
591 209812 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
592 209812 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
593 209812 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
594 :
595 209812 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
596 209812 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
597 209812 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
598 209812 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
599 209812 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
600 209812 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
601 209812 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
602 209812 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
603 :
604 : /* intermediate disks */
605 1491372 : for (d = l - 1; d > 0; --d) {
606 1281560 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
607 1281560 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
608 :
609 1281560 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
610 1281560 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
611 1281560 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
612 1281560 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
613 1281560 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
614 1281560 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
615 1281560 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
616 1281560 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
617 1281560 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
618 1281560 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
619 :
620 1281560 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
621 1281560 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
622 1281560 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
623 1281560 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
624 :
625 1281560 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
626 1281560 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
627 1281560 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
628 1281560 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
629 1281560 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
630 1281560 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
631 :
632 1281560 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
633 1281560 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
634 1281560 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
635 1281560 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
636 1281560 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
637 1281560 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
638 1281560 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
639 1281560 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
640 1281560 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
641 1281560 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
642 : }
643 :
644 : /* first disk with all coefficients at 1 */
645 209812 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
646 209812 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
647 :
648 209812 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
649 209812 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
650 209812 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
651 209812 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
652 209812 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
653 209812 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
654 209812 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
655 209812 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
656 209812 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
657 209812 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
658 :
659 209812 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
660 209812 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
661 209812 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
662 209812 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
663 209812 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
664 209812 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
665 :
666 209812 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
667 209812 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
668 209812 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
669 209812 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
670 209812 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
671 209812 : 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 22 : void raid_gen4_ssse3(int nd, size_t size, void **vv)
683 : {
684 22 : 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 22 : l = nd - 1;
693 22 : p = v[nd];
694 22 : q = v[nd + 1];
695 22 : r = v[nd + 2];
696 22 : s = v[nd + 3];
697 :
698 : /* special case with only one data disk */
699 22 : if (l == 0) {
700 5 : for (i = 0; i < 4; ++i)
701 4 : memcpy(v[1 + i], v[0], size);
702 1 : return;
703 : }
704 :
705 : raid_sse_begin();
706 :
707 : /* generic case with at least two data disks */
708 327717 : for (i = 0; i < size; i += 16) {
709 : /* last disk without the by two multiplication */
710 327696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
711 327696 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
712 :
713 327696 : asm volatile ("movdqa %xmm4,%xmm0");
714 327696 : asm volatile ("movdqa %xmm4,%xmm1");
715 :
716 327696 : asm volatile ("movdqa %xmm4,%xmm5");
717 327696 : asm volatile ("psrlw $4,%xmm5");
718 327696 : asm volatile ("pand %xmm7,%xmm4");
719 327696 : asm volatile ("pand %xmm7,%xmm5");
720 :
721 327696 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
722 327696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
723 327696 : asm volatile ("pshufb %xmm4,%xmm2");
724 327696 : asm volatile ("pshufb %xmm5,%xmm7");
725 327696 : asm volatile ("pxor %xmm7,%xmm2");
726 :
727 327696 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
728 327696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
729 327696 : asm volatile ("pshufb %xmm4,%xmm3");
730 327696 : asm volatile ("pshufb %xmm5,%xmm7");
731 327696 : asm volatile ("pxor %xmm7,%xmm3");
732 :
733 : /* intermediate disks */
734 2294256 : for (d = l - 1; d > 0; --d) {
735 1966560 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
736 1966560 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
737 :
738 1966560 : asm volatile ("pxor %xmm5,%xmm5");
739 1966560 : asm volatile ("pcmpgtb %xmm1,%xmm5");
740 1966560 : asm volatile ("paddb %xmm1,%xmm1");
741 1966560 : asm volatile ("pand %xmm7,%xmm5");
742 1966560 : asm volatile ("pxor %xmm5,%xmm1");
743 :
744 1966560 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
745 :
746 1966560 : asm volatile ("pxor %xmm4,%xmm0");
747 1966560 : asm volatile ("pxor %xmm4,%xmm1");
748 :
749 1966560 : asm volatile ("movdqa %xmm4,%xmm5");
750 1966560 : asm volatile ("psrlw $4,%xmm5");
751 1966560 : asm volatile ("pand %xmm7,%xmm4");
752 1966560 : asm volatile ("pand %xmm7,%xmm5");
753 :
754 1966560 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
755 1966560 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
756 1966560 : asm volatile ("pshufb %xmm4,%xmm6");
757 1966560 : asm volatile ("pshufb %xmm5,%xmm7");
758 1966560 : asm volatile ("pxor %xmm6,%xmm2");
759 1966560 : asm volatile ("pxor %xmm7,%xmm2");
760 :
761 1966560 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
762 1966560 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
763 1966560 : asm volatile ("pshufb %xmm4,%xmm6");
764 1966560 : asm volatile ("pshufb %xmm5,%xmm7");
765 1966560 : asm volatile ("pxor %xmm6,%xmm3");
766 1966560 : asm volatile ("pxor %xmm7,%xmm3");
767 : }
768 :
769 : /* first disk with all coefficients at 1 */
770 327696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
771 327696 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
772 :
773 327696 : asm volatile ("pxor %xmm5,%xmm5");
774 327696 : asm volatile ("pcmpgtb %xmm1,%xmm5");
775 327696 : asm volatile ("paddb %xmm1,%xmm1");
776 327696 : asm volatile ("pand %xmm7,%xmm5");
777 327696 : asm volatile ("pxor %xmm5,%xmm1");
778 :
779 327696 : asm volatile ("pxor %xmm4,%xmm0");
780 327696 : asm volatile ("pxor %xmm4,%xmm1");
781 327696 : asm volatile ("pxor %xmm4,%xmm2");
782 327696 : asm volatile ("pxor %xmm4,%xmm3");
783 :
784 327696 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
785 327696 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
786 327696 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
787 327696 : 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 28339 : void raid_gen4_ssse3ext(int nd, size_t size, void **vv)
801 : {
802 28339 : 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 28339 : l = nd - 1;
811 28339 : p = v[nd];
812 28339 : q = v[nd + 1];
813 28339 : r = v[nd + 2];
814 28339 : s = v[nd + 3];
815 :
816 : /* special case with only one data disk */
817 28339 : if (l == 0) {
818 5 : for (i = 0; i < 4; ++i)
819 4 : memcpy(v[1 + i], v[0], size);
820 1 : return;
821 : }
822 :
823 : raid_sse_begin();
824 :
825 : /* generic case with at least two data disks */
826 1408410 : for (i = 0; i < size; i += 32) {
827 : /* last disk without the by two multiplication */
828 1380072 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
829 1380072 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
830 1380072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
831 :
832 1380072 : asm volatile ("movdqa %xmm4,%xmm0");
833 1380072 : asm volatile ("movdqa %xmm4,%xmm1");
834 1380072 : asm volatile ("movdqa %xmm12,%xmm8");
835 1380072 : asm volatile ("movdqa %xmm12,%xmm9");
836 :
837 1380072 : asm volatile ("movdqa %xmm4,%xmm5");
838 1380072 : asm volatile ("movdqa %xmm12,%xmm13");
839 1380072 : asm volatile ("psrlw $4,%xmm5");
840 1380072 : asm volatile ("psrlw $4,%xmm13");
841 1380072 : asm volatile ("pand %xmm15,%xmm4");
842 1380072 : asm volatile ("pand %xmm15,%xmm12");
843 1380072 : asm volatile ("pand %xmm15,%xmm5");
844 1380072 : asm volatile ("pand %xmm15,%xmm13");
845 :
846 1380072 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
847 1380072 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
848 1380072 : asm volatile ("movdqa %xmm2,%xmm10");
849 1380072 : asm volatile ("movdqa %xmm7,%xmm15");
850 1380072 : asm volatile ("pshufb %xmm4,%xmm2");
851 1380072 : asm volatile ("pshufb %xmm12,%xmm10");
852 1380072 : asm volatile ("pshufb %xmm5,%xmm7");
853 1380072 : asm volatile ("pshufb %xmm13,%xmm15");
854 1380072 : asm volatile ("pxor %xmm7,%xmm2");
855 1380072 : asm volatile ("pxor %xmm15,%xmm10");
856 :
857 1380072 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
858 1380072 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
859 1380072 : asm volatile ("movdqa %xmm3,%xmm11");
860 1380072 : asm volatile ("movdqa %xmm7,%xmm15");
861 1380072 : asm volatile ("pshufb %xmm4,%xmm3");
862 1380072 : asm volatile ("pshufb %xmm12,%xmm11");
863 1380072 : asm volatile ("pshufb %xmm5,%xmm7");
864 1380072 : asm volatile ("pshufb %xmm13,%xmm15");
865 1380072 : asm volatile ("pxor %xmm7,%xmm3");
866 1380072 : asm volatile ("pxor %xmm15,%xmm11");
867 :
868 : /* intermediate disks */
869 7850840 : for (d = l - 1; d > 0; --d) {
870 6470768 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
871 6470768 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
872 6470768 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
873 6470768 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
874 :
875 6470768 : asm volatile ("pxor %xmm5,%xmm5");
876 6470768 : asm volatile ("pxor %xmm13,%xmm13");
877 6470768 : asm volatile ("pcmpgtb %xmm1,%xmm5");
878 6470768 : asm volatile ("pcmpgtb %xmm9,%xmm13");
879 6470768 : asm volatile ("paddb %xmm1,%xmm1");
880 6470768 : asm volatile ("paddb %xmm9,%xmm9");
881 6470768 : asm volatile ("pand %xmm7,%xmm5");
882 6470768 : asm volatile ("pand %xmm7,%xmm13");
883 6470768 : asm volatile ("pxor %xmm5,%xmm1");
884 6470768 : asm volatile ("pxor %xmm13,%xmm9");
885 :
886 6470768 : asm volatile ("pxor %xmm4,%xmm0");
887 6470768 : asm volatile ("pxor %xmm4,%xmm1");
888 6470768 : asm volatile ("pxor %xmm12,%xmm8");
889 6470768 : asm volatile ("pxor %xmm12,%xmm9");
890 :
891 6470768 : asm volatile ("movdqa %xmm4,%xmm5");
892 6470768 : asm volatile ("movdqa %xmm12,%xmm13");
893 6470768 : asm volatile ("psrlw $4,%xmm5");
894 6470768 : asm volatile ("psrlw $4,%xmm13");
895 6470768 : asm volatile ("pand %xmm15,%xmm4");
896 6470768 : asm volatile ("pand %xmm15,%xmm12");
897 6470768 : asm volatile ("pand %xmm15,%xmm5");
898 6470768 : asm volatile ("pand %xmm15,%xmm13");
899 :
900 6470768 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
901 6470768 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
902 6470768 : asm volatile ("movdqa %xmm6,%xmm14");
903 6470768 : asm volatile ("movdqa %xmm7,%xmm15");
904 6470768 : asm volatile ("pshufb %xmm4,%xmm6");
905 6470768 : asm volatile ("pshufb %xmm12,%xmm14");
906 6470768 : asm volatile ("pshufb %xmm5,%xmm7");
907 6470768 : asm volatile ("pshufb %xmm13,%xmm15");
908 6470768 : asm volatile ("pxor %xmm6,%xmm2");
909 6470768 : asm volatile ("pxor %xmm14,%xmm10");
910 6470768 : asm volatile ("pxor %xmm7,%xmm2");
911 6470768 : asm volatile ("pxor %xmm15,%xmm10");
912 :
913 6470768 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
914 6470768 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
915 6470768 : asm volatile ("movdqa %xmm6,%xmm14");
916 6470768 : asm volatile ("movdqa %xmm7,%xmm15");
917 6470768 : asm volatile ("pshufb %xmm4,%xmm6");
918 6470768 : asm volatile ("pshufb %xmm12,%xmm14");
919 6470768 : asm volatile ("pshufb %xmm5,%xmm7");
920 6470768 : asm volatile ("pshufb %xmm13,%xmm15");
921 6470768 : asm volatile ("pxor %xmm6,%xmm3");
922 6470768 : asm volatile ("pxor %xmm14,%xmm11");
923 6470768 : asm volatile ("pxor %xmm7,%xmm3");
924 6470768 : asm volatile ("pxor %xmm15,%xmm11");
925 : }
926 :
927 : /* first disk with all coefficients at 1 */
928 1380072 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
929 1380072 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
930 1380072 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
931 1380072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
932 :
933 1380072 : asm volatile ("pxor %xmm5,%xmm5");
934 1380072 : asm volatile ("pxor %xmm13,%xmm13");
935 1380072 : asm volatile ("pcmpgtb %xmm1,%xmm5");
936 1380072 : asm volatile ("pcmpgtb %xmm9,%xmm13");
937 1380072 : asm volatile ("paddb %xmm1,%xmm1");
938 1380072 : asm volatile ("paddb %xmm9,%xmm9");
939 1380072 : asm volatile ("pand %xmm7,%xmm5");
940 1380072 : asm volatile ("pand %xmm7,%xmm13");
941 1380072 : asm volatile ("pxor %xmm5,%xmm1");
942 1380072 : asm volatile ("pxor %xmm13,%xmm9");
943 :
944 1380072 : asm volatile ("pxor %xmm4,%xmm0");
945 1380072 : asm volatile ("pxor %xmm4,%xmm1");
946 1380072 : asm volatile ("pxor %xmm4,%xmm2");
947 1380072 : asm volatile ("pxor %xmm4,%xmm3");
948 1380072 : asm volatile ("pxor %xmm12,%xmm8");
949 1380072 : asm volatile ("pxor %xmm12,%xmm9");
950 1380072 : asm volatile ("pxor %xmm12,%xmm10");
951 1380072 : asm volatile ("pxor %xmm12,%xmm11");
952 :
953 1380072 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
954 1380072 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
955 1380072 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
956 1380072 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
957 1380072 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
958 1380072 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
959 1380072 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
960 1380072 : 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 4128 : void raid_gen4_avx2ext(int nd, size_t size, void **vv)
974 : {
975 4128 : 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 4128 : l = nd - 1;
984 4128 : p = v[nd];
985 4128 : q = v[nd + 1];
986 4128 : r = v[nd + 2];
987 4128 : s = v[nd + 3];
988 :
989 : /* special case with only one data disk */
990 4128 : if (l == 0) {
991 5 : for (i = 0; i < 4; ++i)
992 4 : memcpy(v[1 + i], v[0], size);
993 1 : return;
994 : }
995 :
996 : raid_avx_begin();
997 :
998 : /* generic case with at least two data disks */
999 123295 : for (i = 0; i < size; i += 64) {
1000 : /* last disk without the by two multiplication */
1001 119168 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1002 119168 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
1003 119168 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
1004 :
1005 119168 : asm volatile ("vmovdqa %ymm4,%ymm0");
1006 119168 : asm volatile ("vmovdqa %ymm4,%ymm1");
1007 119168 : asm volatile ("vmovdqa %ymm12,%ymm8");
1008 119168 : asm volatile ("vmovdqa %ymm12,%ymm9");
1009 :
1010 119168 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
1011 119168 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
1012 119168 : asm volatile ("vpand %ymm15,%ymm4,%ymm4");
1013 119168 : asm volatile ("vpand %ymm15,%ymm12,%ymm12");
1014 119168 : asm volatile ("vpand %ymm15,%ymm5,%ymm5");
1015 119168 : asm volatile ("vpand %ymm15,%ymm13,%ymm13");
1016 :
1017 119168 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
1018 119168 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
1019 119168 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
1020 119168 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1021 119168 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
1022 119168 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1023 119168 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
1024 119168 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
1025 :
1026 119168 : asm volatile ("vbroadcasti128 %0,%%ymm11" : : "m" (gfgenpshufb[l][1][0][0]));
1027 119168 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][1][1][0]));
1028 119168 : asm volatile ("vpshufb %ymm4,%ymm11,%ymm3");
1029 119168 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1030 119168 : asm volatile ("vpshufb %ymm12,%ymm11,%ymm11");
1031 119168 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1032 119168 : asm volatile ("vpxor %ymm7,%ymm3,%ymm3");
1033 119168 : asm volatile ("vpxor %ymm15,%ymm11,%ymm11");
1034 :
1035 : /* intermediate disks */
1036 902864 : for (d = l - 1; d > 0; --d) {
1037 783696 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
1038 783696 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1039 783696 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
1040 783696 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
1041 :
1042 783696 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
1043 783696 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
1044 783696 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
1045 783696 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
1046 783696 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1047 783696 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
1048 783696 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
1049 783696 : asm volatile ("vpand %ymm7,%ymm13,%ymm13");
1050 783696 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
1051 783696 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
1052 :
1053 783696 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
1054 783696 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
1055 783696 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
1056 783696 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
1057 :
1058 783696 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
1059 783696 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
1060 783696 : asm volatile ("vpand %ymm15,%ymm4,%ymm4");
1061 783696 : asm volatile ("vpand %ymm15,%ymm12,%ymm12");
1062 783696 : asm volatile ("vpand %ymm15,%ymm5,%ymm5");
1063 783696 : asm volatile ("vpand %ymm15,%ymm13,%ymm13");
1064 :
1065 783696 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
1066 783696 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
1067 783696 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
1068 783696 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1069 783696 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
1070 783696 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1071 783696 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
1072 783696 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
1073 783696 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
1074 783696 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
1075 :
1076 783696 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][1][0][0]));
1077 783696 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][1][1][0]));
1078 783696 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
1079 783696 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
1080 783696 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
1081 783696 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
1082 783696 : asm volatile ("vpxor %ymm6,%ymm3,%ymm3");
1083 783696 : asm volatile ("vpxor %ymm14,%ymm11,%ymm11");
1084 783696 : asm volatile ("vpxor %ymm7,%ymm3,%ymm3");
1085 783696 : asm volatile ("vpxor %ymm15,%ymm11,%ymm11");
1086 : }
1087 :
1088 : /* first disk with all coefficients at 1 */
1089 119168 : asm volatile ("vbroadcasti128 %0,%%ymm7" : : "m" (gfconst16.poly[0]));
1090 119168 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1091 119168 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
1092 119168 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
1093 :
1094 119168 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
1095 119168 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
1096 119168 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
1097 119168 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
1098 119168 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1099 119168 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
1100 119168 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
1101 119168 : asm volatile ("vpand %ymm7,%ymm13,%ymm13");
1102 119168 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
1103 119168 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
1104 :
1105 119168 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
1106 119168 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
1107 119168 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
1108 119168 : asm volatile ("vpxor %ymm4,%ymm3,%ymm3");
1109 119168 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
1110 119168 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
1111 119168 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
1112 119168 : asm volatile ("vpxor %ymm12,%ymm11,%ymm11");
1113 :
1114 119168 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1115 119168 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
1116 119168 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1117 119168 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
1118 119168 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1119 119168 : asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
1120 119168 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1121 119168 : 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 14 : void raid_gen5_ssse3(int nd, size_t size, void **vv)
1133 : {
1134 14 : 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 14 : uint8_t *pd = __align_ptr(buffer, 16);
1144 :
1145 14 : l = nd - 1;
1146 14 : p = v[nd];
1147 14 : q = v[nd + 1];
1148 14 : r = v[nd + 2];
1149 14 : s = v[nd + 3];
1150 14 : t = v[nd + 4];
1151 :
1152 : /* special case with only one data disk */
1153 14 : if (l == 0) {
1154 6 : for (i = 0; i < 5; ++i)
1155 5 : memcpy(v[1 + i], v[0], size);
1156 1 : return;
1157 : }
1158 :
1159 : raid_sse_begin();
1160 :
1161 : /* generic case with at least two data disks */
1162 196637 : for (i = 0; i < size; i += 16) {
1163 : /* last disk without the by two multiplication */
1164 196624 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1165 :
1166 196624 : asm volatile ("movdqa %xmm4,%xmm0");
1167 196624 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1168 :
1169 196624 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1170 196624 : asm volatile ("movdqa %xmm4,%xmm5");
1171 196624 : asm volatile ("psrlw $4,%xmm5");
1172 196624 : asm volatile ("pand %xmm7,%xmm4");
1173 196624 : asm volatile ("pand %xmm7,%xmm5");
1174 :
1175 196624 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][0][0][0]));
1176 196624 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1177 196624 : asm volatile ("pshufb %xmm4,%xmm1");
1178 196624 : asm volatile ("pshufb %xmm5,%xmm7");
1179 196624 : asm volatile ("pxor %xmm7,%xmm1");
1180 :
1181 196624 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][1][0][0]));
1182 196624 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1183 196624 : asm volatile ("pshufb %xmm4,%xmm2");
1184 196624 : asm volatile ("pshufb %xmm5,%xmm7");
1185 196624 : asm volatile ("pxor %xmm7,%xmm2");
1186 :
1187 196624 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][2][0][0]));
1188 196624 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1189 196624 : asm volatile ("pshufb %xmm4,%xmm3");
1190 196624 : asm volatile ("pshufb %xmm5,%xmm7");
1191 196624 : asm volatile ("pxor %xmm7,%xmm3");
1192 :
1193 : /* intermediate disks */
1194 1376752 : for (d = l - 1; d > 0; --d) {
1195 1180128 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1196 1180128 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1197 1180128 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1198 :
1199 1180128 : asm volatile ("pxor %xmm5,%xmm5");
1200 1180128 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1201 1180128 : asm volatile ("paddb %xmm0,%xmm0");
1202 1180128 : asm volatile ("pand %xmm7,%xmm5");
1203 1180128 : asm volatile ("pxor %xmm5,%xmm0");
1204 :
1205 1180128 : asm volatile ("pxor %xmm4,%xmm0");
1206 1180128 : asm volatile ("pxor %xmm4,%xmm6");
1207 1180128 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[0]));
1208 :
1209 1180128 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1210 1180128 : asm volatile ("movdqa %xmm4,%xmm5");
1211 1180128 : asm volatile ("psrlw $4,%xmm5");
1212 1180128 : asm volatile ("pand %xmm7,%xmm4");
1213 1180128 : asm volatile ("pand %xmm7,%xmm5");
1214 :
1215 1180128 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1216 1180128 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1217 1180128 : asm volatile ("pshufb %xmm4,%xmm6");
1218 1180128 : asm volatile ("pshufb %xmm5,%xmm7");
1219 1180128 : asm volatile ("pxor %xmm6,%xmm1");
1220 1180128 : asm volatile ("pxor %xmm7,%xmm1");
1221 :
1222 1180128 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1223 1180128 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1224 1180128 : asm volatile ("pshufb %xmm4,%xmm6");
1225 1180128 : asm volatile ("pshufb %xmm5,%xmm7");
1226 1180128 : asm volatile ("pxor %xmm6,%xmm2");
1227 1180128 : asm volatile ("pxor %xmm7,%xmm2");
1228 :
1229 1180128 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1230 1180128 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1231 1180128 : asm volatile ("pshufb %xmm4,%xmm6");
1232 1180128 : asm volatile ("pshufb %xmm5,%xmm7");
1233 1180128 : asm volatile ("pxor %xmm6,%xmm3");
1234 1180128 : asm volatile ("pxor %xmm7,%xmm3");
1235 : }
1236 :
1237 : /* first disk with all coefficients at 1 */
1238 196624 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1239 196624 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1240 196624 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1241 :
1242 196624 : asm volatile ("pxor %xmm5,%xmm5");
1243 196624 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1244 196624 : asm volatile ("paddb %xmm0,%xmm0");
1245 196624 : asm volatile ("pand %xmm7,%xmm5");
1246 196624 : asm volatile ("pxor %xmm5,%xmm0");
1247 :
1248 196624 : asm volatile ("pxor %xmm4,%xmm0");
1249 196624 : asm volatile ("pxor %xmm4,%xmm1");
1250 196624 : asm volatile ("pxor %xmm4,%xmm2");
1251 196624 : asm volatile ("pxor %xmm4,%xmm3");
1252 196624 : asm volatile ("pxor %xmm4,%xmm6");
1253 :
1254 196624 : asm volatile ("movntdq %%xmm6,%0" : "=m" (p[i]));
1255 196624 : asm volatile ("movntdq %%xmm0,%0" : "=m" (q[i]));
1256 196624 : asm volatile ("movntdq %%xmm1,%0" : "=m" (r[i]));
1257 196624 : asm volatile ("movntdq %%xmm2,%0" : "=m" (s[i]));
1258 196624 : 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 37518 : void raid_gen5_ssse3ext(int nd, size_t size, void **vv)
1272 : {
1273 37518 : 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 37518 : l = nd - 1;
1283 37518 : p = v[nd];
1284 37518 : q = v[nd + 1];
1285 37518 : r = v[nd + 2];
1286 37518 : s = v[nd + 3];
1287 37518 : t = v[nd + 4];
1288 :
1289 : /* special case with only one data disk */
1290 37518 : if (l == 0) {
1291 6 : for (i = 0; i < 5; ++i)
1292 5 : memcpy(v[1 + i], v[0], size);
1293 1 : return;
1294 : }
1295 :
1296 : raid_sse_begin();
1297 :
1298 : /* generic case with at least two data disks */
1299 37517 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1300 37517 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1301 :
1302 3287197 : for (i = 0; i < size; i += 16) {
1303 : /* last disk without the by two multiplication */
1304 3249680 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1305 :
1306 3249680 : asm volatile ("movdqa %xmm10,%xmm0");
1307 3249680 : asm volatile ("movdqa %xmm10,%xmm1");
1308 :
1309 3249680 : asm volatile ("movdqa %xmm10,%xmm11");
1310 3249680 : asm volatile ("psrlw $4,%xmm11");
1311 3249680 : asm volatile ("pand %xmm15,%xmm10");
1312 3249680 : asm volatile ("pand %xmm15,%xmm11");
1313 :
1314 3249680 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1315 3249680 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1316 3249680 : asm volatile ("pshufb %xmm10,%xmm2");
1317 3249680 : asm volatile ("pshufb %xmm11,%xmm13");
1318 3249680 : asm volatile ("pxor %xmm13,%xmm2");
1319 :
1320 3249680 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1321 3249680 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1322 3249680 : asm volatile ("pshufb %xmm10,%xmm3");
1323 3249680 : asm volatile ("pshufb %xmm11,%xmm13");
1324 3249680 : asm volatile ("pxor %xmm13,%xmm3");
1325 :
1326 3249680 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1327 3249680 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1328 3249680 : asm volatile ("pshufb %xmm10,%xmm4");
1329 3249680 : asm volatile ("pshufb %xmm11,%xmm13");
1330 3249680 : asm volatile ("pxor %xmm13,%xmm4");
1331 :
1332 : /* intermediate disks */
1333 17952752 : for (d = l - 1; d > 0; --d) {
1334 14703072 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1335 :
1336 14703072 : asm volatile ("pxor %xmm11,%xmm11");
1337 14703072 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1338 14703072 : asm volatile ("paddb %xmm1,%xmm1");
1339 14703072 : asm volatile ("pand %xmm14,%xmm11");
1340 14703072 : asm volatile ("pxor %xmm11,%xmm1");
1341 :
1342 14703072 : asm volatile ("pxor %xmm10,%xmm0");
1343 14703072 : asm volatile ("pxor %xmm10,%xmm1");
1344 :
1345 14703072 : asm volatile ("movdqa %xmm10,%xmm11");
1346 14703072 : asm volatile ("psrlw $4,%xmm11");
1347 14703072 : asm volatile ("pand %xmm15,%xmm10");
1348 14703072 : asm volatile ("pand %xmm15,%xmm11");
1349 :
1350 14703072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1351 14703072 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1352 14703072 : asm volatile ("pshufb %xmm10,%xmm12");
1353 14703072 : asm volatile ("pshufb %xmm11,%xmm13");
1354 14703072 : asm volatile ("pxor %xmm12,%xmm2");
1355 14703072 : asm volatile ("pxor %xmm13,%xmm2");
1356 :
1357 14703072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1358 14703072 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1359 14703072 : asm volatile ("pshufb %xmm10,%xmm12");
1360 14703072 : asm volatile ("pshufb %xmm11,%xmm13");
1361 14703072 : asm volatile ("pxor %xmm12,%xmm3");
1362 14703072 : asm volatile ("pxor %xmm13,%xmm3");
1363 :
1364 14703072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1365 14703072 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1366 14703072 : asm volatile ("pshufb %xmm10,%xmm12");
1367 14703072 : asm volatile ("pshufb %xmm11,%xmm13");
1368 14703072 : asm volatile ("pxor %xmm12,%xmm4");
1369 14703072 : asm volatile ("pxor %xmm13,%xmm4");
1370 : }
1371 :
1372 : /* first disk with all coefficients at 1 */
1373 3249680 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1374 :
1375 3249680 : asm volatile ("pxor %xmm11,%xmm11");
1376 3249680 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1377 3249680 : asm volatile ("paddb %xmm1,%xmm1");
1378 3249680 : asm volatile ("pand %xmm14,%xmm11");
1379 3249680 : asm volatile ("pxor %xmm11,%xmm1");
1380 :
1381 3249680 : asm volatile ("pxor %xmm10,%xmm0");
1382 3249680 : asm volatile ("pxor %xmm10,%xmm1");
1383 3249680 : asm volatile ("pxor %xmm10,%xmm2");
1384 3249680 : asm volatile ("pxor %xmm10,%xmm3");
1385 3249680 : asm volatile ("pxor %xmm10,%xmm4");
1386 :
1387 3249680 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1388 3249680 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1389 3249680 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1390 3249680 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1391 3249680 : 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 13137 : void raid_gen5_avx2ext(int nd, size_t size, void **vv)
1405 : {
1406 13137 : 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 13137 : l = nd - 1;
1416 13137 : p = v[nd];
1417 13137 : q = v[nd + 1];
1418 13137 : r = v[nd + 2];
1419 13137 : s = v[nd + 3];
1420 13137 : t = v[nd + 4];
1421 :
1422 : /* special case with only one data disk */
1423 13137 : if (l == 0) {
1424 6 : for (i = 0; i < 5; ++i)
1425 5 : memcpy(v[1 + i], v[0], size);
1426 1 : return;
1427 : }
1428 :
1429 : raid_avx_begin();
1430 :
1431 : /* generic case with at least two data disks */
1432 13136 : asm volatile ("vpxor %ymm8,%ymm8,%ymm8");
1433 13136 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
1434 13136 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1435 :
1436 323544 : for (i = 0; i < size; i += 32) {
1437 : /* last disk without the by two multiplication */
1438 310408 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
1439 :
1440 310408 : asm volatile ("vmovdqa %ymm10,%ymm0");
1441 310408 : asm volatile ("vmovdqa %ymm10,%ymm1");
1442 :
1443 310408 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1444 310408 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1445 310408 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1446 :
1447 310408 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
1448 310408 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
1449 310408 : asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
1450 310408 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1451 310408 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1452 :
1453 310408 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
1454 310408 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
1455 310408 : asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
1456 310408 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1457 310408 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1458 :
1459 310408 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
1460 310408 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
1461 310408 : asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
1462 310408 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1463 310408 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1464 :
1465 : /* intermediate disks */
1466 2598520 : for (d = l - 1; d > 0; --d) {
1467 2288112 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
1468 :
1469 2288112 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1470 2288112 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1471 2288112 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1472 2288112 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1473 :
1474 2288112 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1475 2288112 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1476 :
1477 2288112 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1478 2288112 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1479 2288112 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1480 :
1481 2288112 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
1482 2288112 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
1483 2288112 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1484 2288112 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1485 2288112 : asm volatile ("vpxor %ymm12,%ymm2,%ymm2");
1486 2288112 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1487 :
1488 2288112 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
1489 2288112 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
1490 2288112 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1491 2288112 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1492 2288112 : asm volatile ("vpxor %ymm12,%ymm3,%ymm3");
1493 2288112 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1494 :
1495 2288112 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
1496 2288112 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
1497 2288112 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1498 2288112 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1499 2288112 : asm volatile ("vpxor %ymm12,%ymm4,%ymm4");
1500 2288112 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1501 : }
1502 :
1503 : /* first disk with all coefficients at 1 */
1504 310408 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
1505 :
1506 310408 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1507 310408 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1508 310408 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1509 310408 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1510 :
1511 310408 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1512 310408 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1513 310408 : asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
1514 310408 : asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
1515 310408 : asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
1516 :
1517 310408 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1518 310408 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1519 310408 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1520 310408 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1521 310408 : 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 12 : void raid_gen6_ssse3(int nd, size_t size, void **vv)
1533 : {
1534 12 : 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 12 : uint8_t *pd = __align_ptr(buffer, 16);
1545 :
1546 12 : l = nd - 1;
1547 12 : p = v[nd];
1548 12 : q = v[nd + 1];
1549 12 : r = v[nd + 2];
1550 12 : s = v[nd + 3];
1551 12 : t = v[nd + 4];
1552 12 : u = v[nd + 5];
1553 :
1554 : /* special case with only one data disk */
1555 12 : if (l == 0) {
1556 7 : for (i = 0; i < 6; ++i)
1557 6 : memcpy(v[1 + i], v[0], size);
1558 1 : return;
1559 : }
1560 :
1561 : raid_sse_begin();
1562 :
1563 : /* generic case with at least two data disks */
1564 163867 : for (i = 0; i < size; i += 16) {
1565 : /* last disk without the by two multiplication */
1566 163856 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1567 :
1568 163856 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1569 163856 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[16]));
1570 :
1571 163856 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1572 163856 : asm volatile ("movdqa %xmm4,%xmm5");
1573 163856 : asm volatile ("psrlw $4,%xmm5");
1574 163856 : asm volatile ("pand %xmm7,%xmm4");
1575 163856 : asm volatile ("pand %xmm7,%xmm5");
1576 :
1577 163856 : asm volatile ("movdqa %0,%%xmm0" : : "m" (gfgenpshufb[l][0][0][0]));
1578 163856 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1579 163856 : asm volatile ("pshufb %xmm4,%xmm0");
1580 163856 : asm volatile ("pshufb %xmm5,%xmm7");
1581 163856 : asm volatile ("pxor %xmm7,%xmm0");
1582 :
1583 163856 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][1][0][0]));
1584 163856 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1585 163856 : asm volatile ("pshufb %xmm4,%xmm1");
1586 163856 : asm volatile ("pshufb %xmm5,%xmm7");
1587 163856 : asm volatile ("pxor %xmm7,%xmm1");
1588 :
1589 163856 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][2][0][0]));
1590 163856 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1591 163856 : asm volatile ("pshufb %xmm4,%xmm2");
1592 163856 : asm volatile ("pshufb %xmm5,%xmm7");
1593 163856 : asm volatile ("pxor %xmm7,%xmm2");
1594 :
1595 163856 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][3][0][0]));
1596 163856 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][3][1][0]));
1597 163856 : asm volatile ("pshufb %xmm4,%xmm3");
1598 163856 : asm volatile ("pshufb %xmm5,%xmm7");
1599 163856 : asm volatile ("pxor %xmm7,%xmm3");
1600 :
1601 : /* intermediate disks */
1602 1147376 : for (d = l - 1; d > 0; --d) {
1603 983520 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
1604 983520 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
1605 983520 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1606 :
1607 983520 : asm volatile ("pxor %xmm4,%xmm4");
1608 983520 : asm volatile ("pcmpgtb %xmm6,%xmm4");
1609 983520 : asm volatile ("paddb %xmm6,%xmm6");
1610 983520 : asm volatile ("pand %xmm7,%xmm4");
1611 983520 : asm volatile ("pxor %xmm4,%xmm6");
1612 :
1613 983520 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1614 :
1615 983520 : asm volatile ("pxor %xmm4,%xmm5");
1616 983520 : asm volatile ("pxor %xmm4,%xmm6");
1617 983520 : asm volatile ("movdqa %%xmm5,%0" : "=m" (pd[0]));
1618 983520 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[16]));
1619 :
1620 983520 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1621 983520 : asm volatile ("movdqa %xmm4,%xmm5");
1622 983520 : asm volatile ("psrlw $4,%xmm5");
1623 983520 : asm volatile ("pand %xmm7,%xmm4");
1624 983520 : asm volatile ("pand %xmm7,%xmm5");
1625 :
1626 983520 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1627 983520 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1628 983520 : asm volatile ("pshufb %xmm4,%xmm6");
1629 983520 : asm volatile ("pshufb %xmm5,%xmm7");
1630 983520 : asm volatile ("pxor %xmm6,%xmm0");
1631 983520 : asm volatile ("pxor %xmm7,%xmm0");
1632 :
1633 983520 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1634 983520 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1635 983520 : asm volatile ("pshufb %xmm4,%xmm6");
1636 983520 : asm volatile ("pshufb %xmm5,%xmm7");
1637 983520 : asm volatile ("pxor %xmm6,%xmm1");
1638 983520 : asm volatile ("pxor %xmm7,%xmm1");
1639 :
1640 983520 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1641 983520 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1642 983520 : asm volatile ("pshufb %xmm4,%xmm6");
1643 983520 : asm volatile ("pshufb %xmm5,%xmm7");
1644 983520 : asm volatile ("pxor %xmm6,%xmm2");
1645 983520 : asm volatile ("pxor %xmm7,%xmm2");
1646 :
1647 983520 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][3][0][0]));
1648 983520 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][3][1][0]));
1649 983520 : asm volatile ("pshufb %xmm4,%xmm6");
1650 983520 : asm volatile ("pshufb %xmm5,%xmm7");
1651 983520 : asm volatile ("pxor %xmm6,%xmm3");
1652 983520 : asm volatile ("pxor %xmm7,%xmm3");
1653 : }
1654 :
1655 : /* first disk with all coefficients at 1 */
1656 163856 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
1657 163856 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
1658 163856 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1659 :
1660 163856 : asm volatile ("pxor %xmm4,%xmm4");
1661 163856 : asm volatile ("pcmpgtb %xmm6,%xmm4");
1662 163856 : asm volatile ("paddb %xmm6,%xmm6");
1663 163856 : asm volatile ("pand %xmm7,%xmm4");
1664 163856 : asm volatile ("pxor %xmm4,%xmm6");
1665 :
1666 163856 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1667 163856 : asm volatile ("pxor %xmm4,%xmm0");
1668 163856 : asm volatile ("pxor %xmm4,%xmm1");
1669 163856 : asm volatile ("pxor %xmm4,%xmm2");
1670 163856 : asm volatile ("pxor %xmm4,%xmm3");
1671 163856 : asm volatile ("pxor %xmm4,%xmm5");
1672 163856 : asm volatile ("pxor %xmm4,%xmm6");
1673 :
1674 163856 : asm volatile ("movntdq %%xmm5,%0" : "=m" (p[i]));
1675 163856 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i]));
1676 163856 : asm volatile ("movntdq %%xmm0,%0" : "=m" (r[i]));
1677 163856 : asm volatile ("movntdq %%xmm1,%0" : "=m" (s[i]));
1678 163856 : asm volatile ("movntdq %%xmm2,%0" : "=m" (t[i]));
1679 163856 : 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 526942 : void raid_gen6_ssse3ext(int nd, size_t size, void **vv)
1693 : {
1694 526942 : 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 526942 : l = nd - 1;
1705 526942 : p = v[nd];
1706 526942 : q = v[nd + 1];
1707 526942 : r = v[nd + 2];
1708 526942 : s = v[nd + 3];
1709 526942 : t = v[nd + 4];
1710 526942 : u = v[nd + 5];
1711 :
1712 : /* special case with only one data disk */
1713 526942 : if (l == 0) {
1714 7 : for (i = 0; i < 6; ++i)
1715 6 : memcpy(v[1 + i], v[0], size);
1716 1 : return;
1717 : }
1718 :
1719 : raid_sse_begin();
1720 :
1721 : /* generic case with at least two data disks */
1722 526941 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1723 526941 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1724 :
1725 35067117 : for (i = 0; i < size; i += 16) {
1726 : /* last disk without the by two multiplication */
1727 34540176 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1728 :
1729 34540176 : asm volatile ("movdqa %xmm10,%xmm0");
1730 34540176 : asm volatile ("movdqa %xmm10,%xmm1");
1731 :
1732 34540176 : asm volatile ("movdqa %xmm10,%xmm11");
1733 34540176 : asm volatile ("psrlw $4,%xmm11");
1734 34540176 : asm volatile ("pand %xmm15,%xmm10");
1735 34540176 : asm volatile ("pand %xmm15,%xmm11");
1736 :
1737 34540176 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1738 34540176 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1739 34540176 : asm volatile ("pshufb %xmm10,%xmm2");
1740 34540176 : asm volatile ("pshufb %xmm11,%xmm13");
1741 34540176 : asm volatile ("pxor %xmm13,%xmm2");
1742 :
1743 34540176 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1744 34540176 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1745 34540176 : asm volatile ("pshufb %xmm10,%xmm3");
1746 34540176 : asm volatile ("pshufb %xmm11,%xmm13");
1747 34540176 : asm volatile ("pxor %xmm13,%xmm3");
1748 :
1749 34540176 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1750 34540176 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1751 34540176 : asm volatile ("pshufb %xmm10,%xmm4");
1752 34540176 : asm volatile ("pshufb %xmm11,%xmm13");
1753 34540176 : asm volatile ("pxor %xmm13,%xmm4");
1754 :
1755 34540176 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfgenpshufb[l][3][0][0]));
1756 34540176 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][3][1][0]));
1757 34540176 : asm volatile ("pshufb %xmm10,%xmm5");
1758 34540176 : asm volatile ("pshufb %xmm11,%xmm13");
1759 34540176 : asm volatile ("pxor %xmm13,%xmm5");
1760 :
1761 : /* intermediate disks */
1762 174339696 : for (d = l - 1; d > 0; --d) {
1763 139799520 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1764 :
1765 139799520 : asm volatile ("pxor %xmm11,%xmm11");
1766 139799520 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1767 139799520 : asm volatile ("paddb %xmm1,%xmm1");
1768 139799520 : asm volatile ("pand %xmm14,%xmm11");
1769 139799520 : asm volatile ("pxor %xmm11,%xmm1");
1770 :
1771 139799520 : asm volatile ("pxor %xmm10,%xmm0");
1772 139799520 : asm volatile ("pxor %xmm10,%xmm1");
1773 :
1774 139799520 : asm volatile ("movdqa %xmm10,%xmm11");
1775 139799520 : asm volatile ("psrlw $4,%xmm11");
1776 139799520 : asm volatile ("pand %xmm15,%xmm10");
1777 139799520 : asm volatile ("pand %xmm15,%xmm11");
1778 :
1779 139799520 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1780 139799520 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1781 139799520 : asm volatile ("pshufb %xmm10,%xmm12");
1782 139799520 : asm volatile ("pshufb %xmm11,%xmm13");
1783 139799520 : asm volatile ("pxor %xmm12,%xmm2");
1784 139799520 : asm volatile ("pxor %xmm13,%xmm2");
1785 :
1786 139799520 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1787 139799520 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1788 139799520 : asm volatile ("pshufb %xmm10,%xmm12");
1789 139799520 : asm volatile ("pshufb %xmm11,%xmm13");
1790 139799520 : asm volatile ("pxor %xmm12,%xmm3");
1791 139799520 : asm volatile ("pxor %xmm13,%xmm3");
1792 :
1793 139799520 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1794 139799520 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1795 139799520 : asm volatile ("pshufb %xmm10,%xmm12");
1796 139799520 : asm volatile ("pshufb %xmm11,%xmm13");
1797 139799520 : asm volatile ("pxor %xmm12,%xmm4");
1798 139799520 : asm volatile ("pxor %xmm13,%xmm4");
1799 :
1800 139799520 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][3][0][0]));
1801 139799520 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][3][1][0]));
1802 139799520 : asm volatile ("pshufb %xmm10,%xmm12");
1803 139799520 : asm volatile ("pshufb %xmm11,%xmm13");
1804 139799520 : asm volatile ("pxor %xmm12,%xmm5");
1805 139799520 : asm volatile ("pxor %xmm13,%xmm5");
1806 : }
1807 :
1808 : /* first disk with all coefficients at 1 */
1809 34540176 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1810 :
1811 34540176 : asm volatile ("pxor %xmm11,%xmm11");
1812 34540176 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1813 34540176 : asm volatile ("paddb %xmm1,%xmm1");
1814 34540176 : asm volatile ("pand %xmm14,%xmm11");
1815 34540176 : asm volatile ("pxor %xmm11,%xmm1");
1816 :
1817 34540176 : asm volatile ("pxor %xmm10,%xmm0");
1818 34540176 : asm volatile ("pxor %xmm10,%xmm1");
1819 34540176 : asm volatile ("pxor %xmm10,%xmm2");
1820 34540176 : asm volatile ("pxor %xmm10,%xmm3");
1821 34540176 : asm volatile ("pxor %xmm10,%xmm4");
1822 34540176 : asm volatile ("pxor %xmm10,%xmm5");
1823 :
1824 34540176 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1825 34540176 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1826 34540176 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1827 34540176 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1828 34540176 : asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
1829 34540176 : 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 37161 : void raid_gen6_avx2ext(int nd, size_t size, void **vv)
1843 : {
1844 37161 : 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 37161 : l = nd - 1;
1855 37161 : p = v[nd];
1856 37161 : q = v[nd + 1];
1857 37161 : r = v[nd + 2];
1858 37161 : s = v[nd + 3];
1859 37161 : t = v[nd + 4];
1860 37161 : u = v[nd + 5];
1861 :
1862 : /* special case with only one data disk */
1863 37161 : if (l == 0) {
1864 7 : for (i = 0; i < 6; ++i)
1865 6 : memcpy(v[1 + i], v[0], size);
1866 1 : return;
1867 : }
1868 :
1869 : raid_avx_begin();
1870 :
1871 : /* generic case with at least two data disks */
1872 37160 : asm volatile ("vpxor %ymm8,%ymm8,%ymm8");
1873 37160 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfconst16.poly[0]));
1874 37160 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfconst16.low4[0]));
1875 :
1876 539760 : for (i = 0; i < size; i += 32) {
1877 : /* last disk without the by two multiplication */
1878 502600 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[l][i]));
1879 :
1880 502600 : asm volatile ("vmovdqa %ymm10,%ymm0");
1881 502600 : asm volatile ("vmovdqa %ymm10,%ymm1");
1882 :
1883 502600 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1884 502600 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1885 502600 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1886 :
1887 502600 : asm volatile ("vbroadcasti128 %0,%%ymm2" : : "m" (gfgenpshufb[l][0][0][0]));
1888 502600 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][0][1][0]));
1889 502600 : asm volatile ("vpshufb %ymm10,%ymm2,%ymm2");
1890 502600 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1891 502600 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1892 :
1893 502600 : asm volatile ("vbroadcasti128 %0,%%ymm3" : : "m" (gfgenpshufb[l][1][0][0]));
1894 502600 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][1][1][0]));
1895 502600 : asm volatile ("vpshufb %ymm10,%ymm3,%ymm3");
1896 502600 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1897 502600 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1898 :
1899 502600 : asm volatile ("vbroadcasti128 %0,%%ymm4" : : "m" (gfgenpshufb[l][2][0][0]));
1900 502600 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][2][1][0]));
1901 502600 : asm volatile ("vpshufb %ymm10,%ymm4,%ymm4");
1902 502600 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1903 502600 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1904 :
1905 502600 : asm volatile ("vbroadcasti128 %0,%%ymm5" : : "m" (gfgenpshufb[l][3][0][0]));
1906 502600 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[l][3][1][0]));
1907 502600 : asm volatile ("vpshufb %ymm10,%ymm5,%ymm5");
1908 502600 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1909 502600 : asm volatile ("vpxor %ymm13,%ymm5,%ymm5");
1910 :
1911 : /* intermediate disks */
1912 4712632 : for (d = l - 1; d > 0; --d) {
1913 4210032 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[d][i]));
1914 :
1915 4210032 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1916 4210032 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1917 4210032 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1918 4210032 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1919 :
1920 4210032 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1921 4210032 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1922 :
1923 4210032 : asm volatile ("vpsrlw $4,%ymm10,%ymm11");
1924 4210032 : asm volatile ("vpand %ymm15,%ymm10,%ymm10");
1925 4210032 : asm volatile ("vpand %ymm15,%ymm11,%ymm11");
1926 :
1927 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][0][0][0]));
1928 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][0][1][0]));
1929 4210032 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1930 4210032 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1931 4210032 : asm volatile ("vpxor %ymm12,%ymm2,%ymm2");
1932 4210032 : asm volatile ("vpxor %ymm13,%ymm2,%ymm2");
1933 :
1934 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][1][0][0]));
1935 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][1][1][0]));
1936 4210032 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1937 4210032 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1938 4210032 : asm volatile ("vpxor %ymm12,%ymm3,%ymm3");
1939 4210032 : asm volatile ("vpxor %ymm13,%ymm3,%ymm3");
1940 :
1941 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][2][0][0]));
1942 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][2][1][0]));
1943 4210032 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1944 4210032 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1945 4210032 : asm volatile ("vpxor %ymm12,%ymm4,%ymm4");
1946 4210032 : asm volatile ("vpxor %ymm13,%ymm4,%ymm4");
1947 :
1948 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm12" : : "m" (gfgenpshufb[d][3][0][0]));
1949 4210032 : asm volatile ("vbroadcasti128 %0,%%ymm13" : : "m" (gfgenpshufb[d][3][1][0]));
1950 4210032 : asm volatile ("vpshufb %ymm10,%ymm12,%ymm12");
1951 4210032 : asm volatile ("vpshufb %ymm11,%ymm13,%ymm13");
1952 4210032 : asm volatile ("vpxor %ymm12,%ymm5,%ymm5");
1953 4210032 : asm volatile ("vpxor %ymm13,%ymm5,%ymm5");
1954 : }
1955 :
1956 : /* first disk with all coefficients at 1 */
1957 502600 : asm volatile ("vmovdqa %0,%%ymm10" : : "m" (v[0][i]));
1958 :
1959 502600 : asm volatile ("vpcmpgtb %ymm1,%ymm8,%ymm11");
1960 502600 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
1961 502600 : asm volatile ("vpand %ymm14,%ymm11,%ymm11");
1962 502600 : asm volatile ("vpxor %ymm11,%ymm1,%ymm1");
1963 :
1964 502600 : asm volatile ("vpxor %ymm10,%ymm0,%ymm0");
1965 502600 : asm volatile ("vpxor %ymm10,%ymm1,%ymm1");
1966 502600 : asm volatile ("vpxor %ymm10,%ymm2,%ymm2");
1967 502600 : asm volatile ("vpxor %ymm10,%ymm3,%ymm3");
1968 502600 : asm volatile ("vpxor %ymm10,%ymm4,%ymm4");
1969 502600 : asm volatile ("vpxor %ymm10,%ymm5,%ymm5");
1970 :
1971 502600 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
1972 502600 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
1973 502600 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
1974 502600 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (s[i]));
1975 502600 : asm volatile ("vmovntdq %%ymm4,%0" : "=m" (t[i]));
1976 502600 : 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 111520 : void raid_rec1_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
1988 : {
1989 111520 : 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 111520 : if (ip[0] == 0) {
2000 101501 : raid_rec1of1(id, nd, size, vv);
2001 101501 : return;
2002 : }
2003 :
2004 : /* setup the coefficients matrix */
2005 20038 : G = A(ip[0], id[0]);
2006 :
2007 : /* invert it to solve the system of linear equations */
2008 20038 : V = inv(G);
2009 :
2010 : /* compute delta parity */
2011 10019 : raid_delta_gen(1, id, ip, nd, size, vv);
2012 :
2013 10019 : p = v[nd + ip[0]];
2014 10019 : pa = v[id[0]];
2015 :
2016 : raid_sse_begin();
2017 :
2018 10019 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2019 10019 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfmulpshufb[V][0][0]));
2020 10019 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfmulpshufb[V][1][0]));
2021 :
2022 1561123 : for (i = 0; i < size; i += 16) {
2023 1551104 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[i]));
2024 1551104 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[i]));
2025 1551104 : asm volatile ("movdqa %xmm4,%xmm2");
2026 1551104 : asm volatile ("movdqa %xmm5,%xmm3");
2027 1551104 : asm volatile ("pxor %xmm0,%xmm1");
2028 1551104 : asm volatile ("movdqa %xmm1,%xmm0");
2029 1551104 : asm volatile ("psrlw $4,%xmm1");
2030 1551104 : asm volatile ("pand %xmm7,%xmm0");
2031 1551104 : asm volatile ("pand %xmm7,%xmm1");
2032 1551104 : asm volatile ("pshufb %xmm0,%xmm2");
2033 1551104 : asm volatile ("pshufb %xmm1,%xmm3");
2034 1551104 : asm volatile ("pxor %xmm3,%xmm2");
2035 1551104 : 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 44318 : void raid_rec2_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2047 44318 : {
2048 44318 : uint8_t **v = (uint8_t **)vv;
2049 44318 : const int N = 2;
2050 44318 : uint8_t *p[N];
2051 44318 : uint8_t *pa[N];
2052 44318 : uint8_t G[N * N];
2053 44318 : 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 132954 : for (j = 0; j < N; ++j)
2061 265908 : for (k = 0; k < N; ++k)
2062 354544 : G[j * N + k] = A(ip[j], id[k]);
2063 :
2064 : /* invert it to solve the system of linear equations */
2065 44318 : raid_invert(G, V, N);
2066 :
2067 : /* compute delta parity */
2068 44318 : raid_delta_gen(N, id, ip, nd, size, vv);
2069 :
2070 132954 : for (j = 0; j < N; ++j) {
2071 88636 : p[j] = v[nd + ip[j]];
2072 88636 : pa[j] = v[id[j]];
2073 : }
2074 :
2075 : raid_sse_begin();
2076 :
2077 44318 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2078 :
2079 3476446 : for (i = 0; i < size; i += 16) {
2080 3432128 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[0][i]));
2081 3432128 : asm volatile ("movdqa %0,%%xmm2" : : "m" (pa[0][i]));
2082 3432128 : asm volatile ("movdqa %0,%%xmm1" : : "m" (p[1][i]));
2083 3432128 : asm volatile ("movdqa %0,%%xmm3" : : "m" (pa[1][i]));
2084 3432128 : asm volatile ("pxor %xmm2,%xmm0");
2085 3432128 : asm volatile ("pxor %xmm3,%xmm1");
2086 :
2087 3432128 : asm volatile ("pxor %xmm6,%xmm6");
2088 :
2089 3432128 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[0]][0][0]));
2090 3432128 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[0]][1][0]));
2091 3432128 : asm volatile ("movdqa %xmm0,%xmm4");
2092 3432128 : asm volatile ("movdqa %xmm0,%xmm5");
2093 3432128 : asm volatile ("psrlw $4,%xmm5");
2094 3432128 : asm volatile ("pand %xmm7,%xmm4");
2095 3432128 : asm volatile ("pand %xmm7,%xmm5");
2096 3432128 : asm volatile ("pshufb %xmm4,%xmm2");
2097 3432128 : asm volatile ("pshufb %xmm5,%xmm3");
2098 3432128 : asm volatile ("pxor %xmm2,%xmm6");
2099 3432128 : asm volatile ("pxor %xmm3,%xmm6");
2100 :
2101 3432128 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[1]][0][0]));
2102 3432128 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[1]][1][0]));
2103 3432128 : asm volatile ("movdqa %xmm1,%xmm4");
2104 3432128 : asm volatile ("movdqa %xmm1,%xmm5");
2105 3432128 : asm volatile ("psrlw $4,%xmm5");
2106 3432128 : asm volatile ("pand %xmm7,%xmm4");
2107 3432128 : asm volatile ("pand %xmm7,%xmm5");
2108 3432128 : asm volatile ("pshufb %xmm4,%xmm2");
2109 3432128 : asm volatile ("pshufb %xmm5,%xmm3");
2110 3432128 : asm volatile ("pxor %xmm2,%xmm6");
2111 3432128 : asm volatile ("pxor %xmm3,%xmm6");
2112 :
2113 3432128 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[0][i]));
2114 :
2115 3432128 : asm volatile ("pxor %xmm6,%xmm6");
2116 :
2117 3432128 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[2]][0][0]));
2118 3432128 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[2]][1][0]));
2119 3432128 : asm volatile ("movdqa %xmm0,%xmm4");
2120 3432128 : asm volatile ("movdqa %xmm0,%xmm5");
2121 3432128 : asm volatile ("psrlw $4,%xmm5");
2122 3432128 : asm volatile ("pand %xmm7,%xmm4");
2123 3432128 : asm volatile ("pand %xmm7,%xmm5");
2124 3432128 : asm volatile ("pshufb %xmm4,%xmm2");
2125 3432128 : asm volatile ("pshufb %xmm5,%xmm3");
2126 3432128 : asm volatile ("pxor %xmm2,%xmm6");
2127 3432128 : asm volatile ("pxor %xmm3,%xmm6");
2128 :
2129 3432128 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[3]][0][0]));
2130 3432128 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[3]][1][0]));
2131 3432128 : asm volatile ("movdqa %xmm1,%xmm4");
2132 3432128 : asm volatile ("movdqa %xmm1,%xmm5");
2133 3432128 : asm volatile ("psrlw $4,%xmm5");
2134 3432128 : asm volatile ("pand %xmm7,%xmm4");
2135 3432128 : asm volatile ("pand %xmm7,%xmm5");
2136 3432128 : asm volatile ("pshufb %xmm4,%xmm2");
2137 3432128 : asm volatile ("pshufb %xmm5,%xmm3");
2138 3432128 : asm volatile ("pxor %xmm2,%xmm6");
2139 3432128 : asm volatile ("pxor %xmm3,%xmm6");
2140 :
2141 3432128 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[1][i]));
2142 : }
2143 :
2144 : raid_sse_end();
2145 44318 : }
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 30 : 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 1206 : {
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 :
|
