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 293847 : void raid_gen1_sse2(int nd, size_t size, void **vv)
37 : {
38 293847 : uint8_t **v = (uint8_t **)vv;
39 : uint8_t *p;
40 : int d, l;
41 : size_t i;
42 :
43 293847 : l = nd - 1;
44 293847 : p = v[nd];
45 :
46 : raid_sse_begin();
47 :
48 5187123 : for (i = 0; i < size; i += 64) {
49 4893276 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
50 4893276 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
51 4893276 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
52 4893276 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
53 29744868 : for (d = l - 1; d >= 0; --d) {
54 24851592 : asm volatile ("pxor %0,%%xmm0" : : "m" (v[d][i]));
55 24851592 : asm volatile ("pxor %0,%%xmm1" : : "m" (v[d][i + 16]));
56 24851592 : asm volatile ("pxor %0,%%xmm2" : : "m" (v[d][i + 32]));
57 24851592 : asm volatile ("pxor %0,%%xmm3" : : "m" (v[d][i + 48]));
58 : }
59 4893276 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
60 4893276 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
61 4893276 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
62 4893276 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
63 : }
64 :
65 : raid_sse_end();
66 293847 : }
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 98 : void raid_gen1_avx2(int nd, size_t size, void **vv)
78 : {
79 98 : uint8_t **v = (uint8_t **)vv;
80 : uint8_t *p;
81 : int d, l;
82 : size_t i;
83 :
84 98 : l = nd - 1;
85 98 : p = v[nd];
86 :
87 : raid_avx_begin();
88 :
89 54286 : for (i = 0; i < size; i += 64) {
90 54188 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
91 54188 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
92 439940 : for (d = l - 1; d >= 0; --d) {
93 385752 : asm volatile ("vpxor %0,%%ymm0,%%ymm0" : : "m" (v[d][i]));
94 385752 : asm volatile ("vpxor %0,%%ymm1,%%ymm1" : : "m" (v[d][i + 32]));
95 : }
96 54188 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
97 54188 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
98 : }
99 :
100 : raid_avx_end();
101 98 : }
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 21 : void raid_gen2_sse2(int nd, size_t size, void **vv)
125 : {
126 21 : uint8_t **v = (uint8_t **)vv;
127 : uint8_t *p;
128 : uint8_t *q;
129 : int d, l;
130 : size_t i;
131 :
132 21 : l = nd - 1;
133 21 : p = v[nd];
134 21 : q = v[nd + 1];
135 :
136 : raid_sse_begin();
137 :
138 21 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
139 :
140 147501 : for (i = 0; i < size; i += 32) {
141 147480 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
142 147480 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
143 147480 : asm volatile ("movdqa %xmm0,%xmm2");
144 147480 : asm volatile ("movdqa %xmm1,%xmm3");
145 1180168 : for (d = l - 1; d >= 0; --d) {
146 1032688 : asm volatile ("pxor %xmm4,%xmm4");
147 1032688 : asm volatile ("pxor %xmm5,%xmm5");
148 1032688 : asm volatile ("pcmpgtb %xmm2,%xmm4");
149 1032688 : asm volatile ("pcmpgtb %xmm3,%xmm5");
150 1032688 : asm volatile ("paddb %xmm2,%xmm2");
151 1032688 : asm volatile ("paddb %xmm3,%xmm3");
152 1032688 : asm volatile ("pand %xmm7,%xmm4");
153 1032688 : asm volatile ("pand %xmm7,%xmm5");
154 1032688 : asm volatile ("pxor %xmm4,%xmm2");
155 1032688 : asm volatile ("pxor %xmm5,%xmm3");
156 :
157 1032688 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
158 1032688 : asm volatile ("movdqa %0,%%xmm5" : : "m" (v[d][i + 16]));
159 1032688 : asm volatile ("pxor %xmm4,%xmm0");
160 1032688 : asm volatile ("pxor %xmm5,%xmm1");
161 1032688 : asm volatile ("pxor %xmm4,%xmm2");
162 1032688 : asm volatile ("pxor %xmm5,%xmm3");
163 : }
164 147480 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
165 147480 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
166 147480 : asm volatile ("movntdq %%xmm2,%0" : "=m" (q[i]));
167 147480 : asm volatile ("movntdq %%xmm3,%0" : "=m" (q[i + 16]));
168 : }
169 :
170 : raid_sse_end();
171 21 : }
172 : #endif
173 :
174 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
175 : /*
176 : * GEN2 (RAID6 with powers of 2) AVX2 implementation
177 : */
178 510 : void raid_gen2_avx2(int nd, size_t size, void **vv)
179 : {
180 510 : uint8_t **v = (uint8_t **)vv;
181 : uint8_t *p;
182 : uint8_t *q;
183 : int d, l;
184 : size_t i;
185 :
186 510 : l = nd - 1;
187 510 : p = v[nd];
188 510 : q = v[nd + 1];
189 :
190 : raid_avx_begin();
191 :
192 510 : asm volatile ("vbroadcasti128 %0, %%ymm7" : : "m" (gfconst16.poly[0]));
193 510 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
194 :
195 113754 : for (i = 0; i < size; i += 64) {
196 113244 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
197 113244 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
198 113244 : asm volatile ("vmovdqa %ymm0,%ymm2");
199 113244 : asm volatile ("vmovdqa %ymm1,%ymm3");
200 919748 : for (d = l - 1; d >= 0; --d) {
201 806504 : asm volatile ("vpcmpgtb %ymm2,%ymm6,%ymm4");
202 806504 : asm volatile ("vpcmpgtb %ymm3,%ymm6,%ymm5");
203 806504 : asm volatile ("vpaddb %ymm2,%ymm2,%ymm2");
204 806504 : asm volatile ("vpaddb %ymm3,%ymm3,%ymm3");
205 806504 : asm volatile ("vpand %ymm7,%ymm4,%ymm4");
206 806504 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
207 806504 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
208 806504 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
209 :
210 806504 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
211 806504 : asm volatile ("vmovdqa %0,%%ymm5" : : "m" (v[d][i + 32]));
212 806504 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
213 806504 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
214 806504 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
215 806504 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
216 : }
217 113244 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
218 113244 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
219 113244 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (q[i]));
220 113244 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (q[i + 32]));
221 : }
222 :
223 : raid_avx_end();
224 510 : }
225 : #endif
226 :
227 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSE2)
228 : /*
229 : * GEN2 (RAID6 with powers of 2) SSE2 implementation
230 : *
231 : * Note that it uses 16 registers, meaning that x64 is required.
232 : */
233 268944 : void raid_gen2_sse2ext(int nd, size_t size, void **vv)
234 : {
235 268944 : uint8_t **v = (uint8_t **)vv;
236 : uint8_t *p;
237 : uint8_t *q;
238 : int d, l;
239 : size_t i;
240 :
241 268944 : l = nd - 1;
242 268944 : p = v[nd];
243 268944 : q = v[nd + 1];
244 :
245 : raid_sse_begin();
246 :
247 268944 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.poly[0]));
248 :
249 4804572 : for (i = 0; i < size; i += 64) {
250 4535628 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
251 4535628 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
252 4535628 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
253 4535628 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
254 4535628 : asm volatile ("movdqa %xmm0,%xmm4");
255 4535628 : asm volatile ("movdqa %xmm1,%xmm5");
256 4535628 : asm volatile ("movdqa %xmm2,%xmm6");
257 4535628 : asm volatile ("movdqa %xmm3,%xmm7");
258 27680900 : for (d = l - 1; d >= 0; --d) {
259 23145272 : asm volatile ("pxor %xmm8,%xmm8");
260 23145272 : asm volatile ("pxor %xmm9,%xmm9");
261 23145272 : asm volatile ("pxor %xmm10,%xmm10");
262 23145272 : asm volatile ("pxor %xmm11,%xmm11");
263 23145272 : asm volatile ("pcmpgtb %xmm4,%xmm8");
264 23145272 : asm volatile ("pcmpgtb %xmm5,%xmm9");
265 23145272 : asm volatile ("pcmpgtb %xmm6,%xmm10");
266 23145272 : asm volatile ("pcmpgtb %xmm7,%xmm11");
267 23145272 : asm volatile ("paddb %xmm4,%xmm4");
268 23145272 : asm volatile ("paddb %xmm5,%xmm5");
269 23145272 : asm volatile ("paddb %xmm6,%xmm6");
270 23145272 : asm volatile ("paddb %xmm7,%xmm7");
271 23145272 : asm volatile ("pand %xmm15,%xmm8");
272 23145272 : asm volatile ("pand %xmm15,%xmm9");
273 23145272 : asm volatile ("pand %xmm15,%xmm10");
274 23145272 : asm volatile ("pand %xmm15,%xmm11");
275 23145272 : asm volatile ("pxor %xmm8,%xmm4");
276 23145272 : asm volatile ("pxor %xmm9,%xmm5");
277 23145272 : asm volatile ("pxor %xmm10,%xmm6");
278 23145272 : asm volatile ("pxor %xmm11,%xmm7");
279 :
280 23145272 : asm volatile ("movdqa %0,%%xmm8" : : "m" (v[d][i]));
281 23145272 : asm volatile ("movdqa %0,%%xmm9" : : "m" (v[d][i + 16]));
282 23145272 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i + 32]));
283 23145272 : asm volatile ("movdqa %0,%%xmm11" : : "m" (v[d][i + 48]));
284 23145272 : asm volatile ("pxor %xmm8,%xmm0");
285 23145272 : asm volatile ("pxor %xmm9,%xmm1");
286 23145272 : asm volatile ("pxor %xmm10,%xmm2");
287 23145272 : asm volatile ("pxor %xmm11,%xmm3");
288 23145272 : asm volatile ("pxor %xmm8,%xmm4");
289 23145272 : asm volatile ("pxor %xmm9,%xmm5");
290 23145272 : asm volatile ("pxor %xmm10,%xmm6");
291 23145272 : asm volatile ("pxor %xmm11,%xmm7");
292 : }
293 4535628 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
294 4535628 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
295 4535628 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
296 4535628 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
297 4535628 : asm volatile ("movntdq %%xmm4,%0" : "=m" (q[i]));
298 4535628 : asm volatile ("movntdq %%xmm5,%0" : "=m" (q[i + 16]));
299 4535628 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i + 32]));
300 4535628 : asm volatile ("movntdq %%xmm7,%0" : "=m" (q[i + 48]));
301 : }
302 :
303 : raid_sse_end();
304 268944 : }
305 : #endif
306 :
307 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
308 : /*
309 : * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
310 : */
311 9 : void raid_gen3_ssse3(int nd, size_t size, void **vv)
312 : {
313 9 : 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 9 : l = nd - 1;
321 9 : p = v[nd];
322 9 : q = v[nd + 1];
323 9 : r = v[nd + 2];
324 :
325 : /* special case with only one data disk */
326 9 : 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 8 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
336 8 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
337 :
338 114712 : for (i = 0; i < size; i += 16) {
339 : /* last disk without the by two multiplication */
340 114704 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
341 :
342 114704 : asm volatile ("movdqa %xmm4,%xmm0");
343 114704 : asm volatile ("movdqa %xmm4,%xmm1");
344 :
345 114704 : asm volatile ("movdqa %xmm4,%xmm5");
346 114704 : asm volatile ("psrlw $4,%xmm5");
347 114704 : asm volatile ("pand %xmm7,%xmm4");
348 114704 : asm volatile ("pand %xmm7,%xmm5");
349 :
350 114704 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
351 114704 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[l][0][1][0]));
352 114704 : asm volatile ("pshufb %xmm4,%xmm2");
353 114704 : asm volatile ("pshufb %xmm5,%xmm6");
354 114704 : asm volatile ("pxor %xmm6,%xmm2");
355 :
356 : /* intermediate disks */
357 803312 : for (d = l - 1; d > 0; --d) {
358 688608 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
359 :
360 688608 : asm volatile ("pxor %xmm5,%xmm5");
361 688608 : asm volatile ("pcmpgtb %xmm1,%xmm5");
362 688608 : asm volatile ("paddb %xmm1,%xmm1");
363 688608 : asm volatile ("pand %xmm3,%xmm5");
364 688608 : asm volatile ("pxor %xmm5,%xmm1");
365 :
366 688608 : asm volatile ("pxor %xmm4,%xmm0");
367 688608 : asm volatile ("pxor %xmm4,%xmm1");
368 :
369 688608 : asm volatile ("movdqa %xmm4,%xmm5");
370 688608 : asm volatile ("psrlw $4,%xmm5");
371 688608 : asm volatile ("pand %xmm7,%xmm4");
372 688608 : asm volatile ("pand %xmm7,%xmm5");
373 :
374 688608 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
375 688608 : asm volatile ("pshufb %xmm4,%xmm6");
376 688608 : asm volatile ("pxor %xmm6,%xmm2");
377 688608 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][1][0]));
378 688608 : asm volatile ("pshufb %xmm5,%xmm6");
379 688608 : asm volatile ("pxor %xmm6,%xmm2");
380 : }
381 :
382 : /* first disk with all coefficients at 1 */
383 114704 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
384 :
385 114704 : asm volatile ("pxor %xmm5,%xmm5");
386 114704 : asm volatile ("pcmpgtb %xmm1,%xmm5");
387 114704 : asm volatile ("paddb %xmm1,%xmm1");
388 114704 : asm volatile ("pand %xmm3,%xmm5");
389 114704 : asm volatile ("pxor %xmm5,%xmm1");
390 :
391 114704 : asm volatile ("pxor %xmm4,%xmm0");
392 114704 : asm volatile ("pxor %xmm4,%xmm1");
393 114704 : asm volatile ("pxor %xmm4,%xmm2");
394 :
395 114704 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
396 114704 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
397 114704 : 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 28274 : void raid_gen3_ssse3ext(int nd, size_t size, void **vv)
411 : {
412 28274 : 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 28274 : l = nd - 1;
420 28274 : p = v[nd];
421 28274 : q = v[nd + 1];
422 28274 : r = v[nd + 2];
423 :
424 : /* special case with only one data disk */
425 28274 : 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 28273 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
435 28273 : asm volatile ("movdqa %0,%%xmm11" : : "m" (gfconst16.low4[0]));
436 :
437 1512345 : for (i = 0; i < size; i += 32) {
438 : /* last disk without the by two multiplication */
439 1484072 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
440 1484072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
441 :
442 1484072 : asm volatile ("movdqa %xmm4,%xmm0");
443 1484072 : asm volatile ("movdqa %xmm4,%xmm1");
444 1484072 : asm volatile ("movdqa %xmm12,%xmm8");
445 1484072 : asm volatile ("movdqa %xmm12,%xmm9");
446 :
447 1484072 : asm volatile ("movdqa %xmm4,%xmm5");
448 1484072 : asm volatile ("movdqa %xmm12,%xmm13");
449 1484072 : asm volatile ("psrlw $4,%xmm5");
450 1484072 : asm volatile ("psrlw $4,%xmm13");
451 1484072 : asm volatile ("pand %xmm11,%xmm4");
452 1484072 : asm volatile ("pand %xmm11,%xmm12");
453 1484072 : asm volatile ("pand %xmm11,%xmm5");
454 1484072 : asm volatile ("pand %xmm11,%xmm13");
455 :
456 1484072 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
457 1484072 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
458 1484072 : asm volatile ("movdqa %xmm2,%xmm10");
459 1484072 : asm volatile ("movdqa %xmm7,%xmm15");
460 1484072 : asm volatile ("pshufb %xmm4,%xmm2");
461 1484072 : asm volatile ("pshufb %xmm12,%xmm10");
462 1484072 : asm volatile ("pshufb %xmm5,%xmm7");
463 1484072 : asm volatile ("pshufb %xmm13,%xmm15");
464 1484072 : asm volatile ("pxor %xmm7,%xmm2");
465 1484072 : asm volatile ("pxor %xmm15,%xmm10");
466 :
467 : /* intermediate disks */
468 8583832 : for (d = l - 1; d > 0; --d) {
469 7099760 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
470 7099760 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
471 :
472 7099760 : asm volatile ("pxor %xmm5,%xmm5");
473 7099760 : asm volatile ("pxor %xmm13,%xmm13");
474 7099760 : asm volatile ("pcmpgtb %xmm1,%xmm5");
475 7099760 : asm volatile ("pcmpgtb %xmm9,%xmm13");
476 7099760 : asm volatile ("paddb %xmm1,%xmm1");
477 7099760 : asm volatile ("paddb %xmm9,%xmm9");
478 7099760 : asm volatile ("pand %xmm3,%xmm5");
479 7099760 : asm volatile ("pand %xmm3,%xmm13");
480 7099760 : asm volatile ("pxor %xmm5,%xmm1");
481 7099760 : asm volatile ("pxor %xmm13,%xmm9");
482 :
483 7099760 : asm volatile ("pxor %xmm4,%xmm0");
484 7099760 : asm volatile ("pxor %xmm4,%xmm1");
485 7099760 : asm volatile ("pxor %xmm12,%xmm8");
486 7099760 : asm volatile ("pxor %xmm12,%xmm9");
487 :
488 7099760 : asm volatile ("movdqa %xmm4,%xmm5");
489 7099760 : asm volatile ("movdqa %xmm12,%xmm13");
490 7099760 : asm volatile ("psrlw $4,%xmm5");
491 7099760 : asm volatile ("psrlw $4,%xmm13");
492 7099760 : asm volatile ("pand %xmm11,%xmm4");
493 7099760 : asm volatile ("pand %xmm11,%xmm12");
494 7099760 : asm volatile ("pand %xmm11,%xmm5");
495 7099760 : asm volatile ("pand %xmm11,%xmm13");
496 :
497 7099760 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
498 7099760 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
499 7099760 : asm volatile ("movdqa %xmm6,%xmm14");
500 7099760 : asm volatile ("movdqa %xmm7,%xmm15");
501 7099760 : asm volatile ("pshufb %xmm4,%xmm6");
502 7099760 : asm volatile ("pshufb %xmm12,%xmm14");
503 7099760 : asm volatile ("pshufb %xmm5,%xmm7");
504 7099760 : asm volatile ("pshufb %xmm13,%xmm15");
505 7099760 : asm volatile ("pxor %xmm6,%xmm2");
506 7099760 : asm volatile ("pxor %xmm14,%xmm10");
507 7099760 : asm volatile ("pxor %xmm7,%xmm2");
508 7099760 : asm volatile ("pxor %xmm15,%xmm10");
509 : }
510 :
511 : /* first disk with all coefficients at 1 */
512 1484072 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
513 1484072 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
514 :
515 1484072 : asm volatile ("pxor %xmm5,%xmm5");
516 1484072 : asm volatile ("pxor %xmm13,%xmm13");
517 1484072 : asm volatile ("pcmpgtb %xmm1,%xmm5");
518 1484072 : asm volatile ("pcmpgtb %xmm9,%xmm13");
519 1484072 : asm volatile ("paddb %xmm1,%xmm1");
520 1484072 : asm volatile ("paddb %xmm9,%xmm9");
521 1484072 : asm volatile ("pand %xmm3,%xmm5");
522 1484072 : asm volatile ("pand %xmm3,%xmm13");
523 1484072 : asm volatile ("pxor %xmm5,%xmm1");
524 1484072 : asm volatile ("pxor %xmm13,%xmm9");
525 :
526 1484072 : asm volatile ("pxor %xmm4,%xmm0");
527 1484072 : asm volatile ("pxor %xmm4,%xmm1");
528 1484072 : asm volatile ("pxor %xmm4,%xmm2");
529 1484072 : asm volatile ("pxor %xmm12,%xmm8");
530 1484072 : asm volatile ("pxor %xmm12,%xmm9");
531 1484072 : asm volatile ("pxor %xmm12,%xmm10");
532 :
533 1484072 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
534 1484072 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
535 1484072 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
536 1484072 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
537 1484072 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
538 1484072 : 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 1153 : void raid_gen3_avx2ext(int nd, size_t size, void **vv)
552 : {
553 1153 : 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 1153 : l = nd - 1;
561 1153 : p = v[nd];
562 1153 : q = v[nd + 1];
563 1153 : r = v[nd + 2];
564 :
565 : /* special case with only one data disk */
566 1153 : 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 1152 : asm volatile ("vbroadcasti128 %0, %%ymm3" : : "m" (gfconst16.poly[0]));
576 1152 : asm volatile ("vbroadcasti128 %0, %%ymm11" : : "m" (gfconst16.low4[0]));
577 :
578 206868 : for (i = 0; i < size; i += 64) {
579 : /* last disk without the by two multiplication */
580 205716 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
581 205716 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
582 :
583 205716 : asm volatile ("vmovdqa %ymm4,%ymm0");
584 205716 : asm volatile ("vmovdqa %ymm4,%ymm1");
585 205716 : asm volatile ("vmovdqa %ymm12,%ymm8");
586 205716 : asm volatile ("vmovdqa %ymm12,%ymm9");
587 :
588 205716 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
589 205716 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
590 205716 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
591 205716 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
592 205716 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
593 205716 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
594 :
595 205716 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
596 205716 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
597 205716 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
598 205716 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
599 205716 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
600 205716 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
601 205716 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
602 205716 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
603 :
604 : /* intermediate disks */
605 1462700 : for (d = l - 1; d > 0; --d) {
606 1256984 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
607 1256984 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
608 :
609 1256984 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
610 1256984 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
611 1256984 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
612 1256984 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
613 1256984 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
614 1256984 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
615 1256984 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
616 1256984 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
617 1256984 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
618 1256984 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
619 :
620 1256984 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
621 1256984 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
622 1256984 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
623 1256984 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
624 :
625 1256984 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
626 1256984 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
627 1256984 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
628 1256984 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
629 1256984 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
630 1256984 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
631 :
632 1256984 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
633 1256984 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
634 1256984 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
635 1256984 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
636 1256984 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
637 1256984 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
638 1256984 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
639 1256984 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
640 1256984 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
641 1256984 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
642 : }
643 :
644 : /* first disk with all coefficients at 1 */
645 205716 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
646 205716 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
647 :
648 205716 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
649 205716 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
650 205716 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
651 205716 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
652 205716 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
653 205716 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
654 205716 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
655 205716 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
656 205716 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
657 205716 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
658 :
659 205716 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
660 205716 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
661 205716 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
662 205716 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
663 205716 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
664 205716 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
665 :
666 205716 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
667 205716 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
668 205716 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
669 205716 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
670 205716 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
671 205716 : 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 8 : void raid_gen4_ssse3(int nd, size_t size, void **vv)
683 : {
684 8 : 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 8 : l = nd - 1;
693 8 : p = v[nd];
694 8 : q = v[nd + 1];
695 8 : r = v[nd + 2];
696 8 : s = v[nd + 3];
697 :
698 : /* special case with only one data disk */
699 8 : 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 98327 : for (i = 0; i < size; i += 16) {
709 : /* last disk without the by two multiplication */
710 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
711 98320 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
712 :
713 98320 : asm volatile ("movdqa %xmm4,%xmm0");
714 98320 : asm volatile ("movdqa %xmm4,%xmm1");
715 :
716 98320 : asm volatile ("movdqa %xmm4,%xmm5");
717 98320 : asm volatile ("psrlw $4,%xmm5");
718 98320 : asm volatile ("pand %xmm7,%xmm4");
719 98320 : asm volatile ("pand %xmm7,%xmm5");
720 :
721 98320 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
722 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
723 98320 : asm volatile ("pshufb %xmm4,%xmm2");
724 98320 : asm volatile ("pshufb %xmm5,%xmm7");
725 98320 : asm volatile ("pxor %xmm7,%xmm2");
726 :
727 98320 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
728 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
729 98320 : asm volatile ("pshufb %xmm4,%xmm3");
730 98320 : asm volatile ("pshufb %xmm5,%xmm7");
731 98320 : asm volatile ("pxor %xmm7,%xmm3");
732 :
733 : /* intermediate disks */
734 688624 : for (d = l - 1; d > 0; --d) {
735 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
736 590304 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
737 :
738 590304 : asm volatile ("pxor %xmm5,%xmm5");
739 590304 : asm volatile ("pcmpgtb %xmm1,%xmm5");
740 590304 : asm volatile ("paddb %xmm1,%xmm1");
741 590304 : asm volatile ("pand %xmm7,%xmm5");
742 590304 : asm volatile ("pxor %xmm5,%xmm1");
743 :
744 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
745 :
746 590304 : asm volatile ("pxor %xmm4,%xmm0");
747 590304 : asm volatile ("pxor %xmm4,%xmm1");
748 :
749 590304 : asm volatile ("movdqa %xmm4,%xmm5");
750 590304 : asm volatile ("psrlw $4,%xmm5");
751 590304 : asm volatile ("pand %xmm7,%xmm4");
752 590304 : asm volatile ("pand %xmm7,%xmm5");
753 :
754 590304 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
755 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
756 590304 : asm volatile ("pshufb %xmm4,%xmm6");
757 590304 : asm volatile ("pshufb %xmm5,%xmm7");
758 590304 : asm volatile ("pxor %xmm6,%xmm2");
759 590304 : asm volatile ("pxor %xmm7,%xmm2");
760 :
761 590304 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
762 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
763 590304 : asm volatile ("pshufb %xmm4,%xmm6");
764 590304 : asm volatile ("pshufb %xmm5,%xmm7");
765 590304 : asm volatile ("pxor %xmm6,%xmm3");
766 590304 : asm volatile ("pxor %xmm7,%xmm3");
767 : }
768 :
769 : /* first disk with all coefficients at 1 */
770 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
771 98320 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
772 :
773 98320 : asm volatile ("pxor %xmm5,%xmm5");
774 98320 : asm volatile ("pcmpgtb %xmm1,%xmm5");
775 98320 : asm volatile ("paddb %xmm1,%xmm1");
776 98320 : asm volatile ("pand %xmm7,%xmm5");
777 98320 : asm volatile ("pxor %xmm5,%xmm1");
778 :
779 98320 : asm volatile ("pxor %xmm4,%xmm0");
780 98320 : asm volatile ("pxor %xmm4,%xmm1");
781 98320 : asm volatile ("pxor %xmm4,%xmm2");
782 98320 : asm volatile ("pxor %xmm4,%xmm3");
783 :
784 98320 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
785 98320 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
786 98320 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
787 98320 : 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 28367 : void raid_gen4_ssse3ext(int nd, size_t size, void **vv)
801 : {
802 28367 : 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 28367 : l = nd - 1;
811 28367 : p = v[nd];
812 28367 : q = v[nd + 1];
813 28367 : r = v[nd + 2];
814 28367 : s = v[nd + 3];
815 :
816 : /* special case with only one data disk */
817 28367 : 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 1246134 : for (i = 0; i < size; i += 32) {
827 : /* last disk without the by two multiplication */
828 1217768 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
829 1217768 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
830 1217768 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
831 :
832 1217768 : asm volatile ("movdqa %xmm4,%xmm0");
833 1217768 : asm volatile ("movdqa %xmm4,%xmm1");
834 1217768 : asm volatile ("movdqa %xmm12,%xmm8");
835 1217768 : asm volatile ("movdqa %xmm12,%xmm9");
836 :
837 1217768 : asm volatile ("movdqa %xmm4,%xmm5");
838 1217768 : asm volatile ("movdqa %xmm12,%xmm13");
839 1217768 : asm volatile ("psrlw $4,%xmm5");
840 1217768 : asm volatile ("psrlw $4,%xmm13");
841 1217768 : asm volatile ("pand %xmm15,%xmm4");
842 1217768 : asm volatile ("pand %xmm15,%xmm12");
843 1217768 : asm volatile ("pand %xmm15,%xmm5");
844 1217768 : asm volatile ("pand %xmm15,%xmm13");
845 :
846 1217768 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
847 1217768 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
848 1217768 : asm volatile ("movdqa %xmm2,%xmm10");
849 1217768 : asm volatile ("movdqa %xmm7,%xmm15");
850 1217768 : asm volatile ("pshufb %xmm4,%xmm2");
851 1217768 : asm volatile ("pshufb %xmm12,%xmm10");
852 1217768 : asm volatile ("pshufb %xmm5,%xmm7");
853 1217768 : asm volatile ("pshufb %xmm13,%xmm15");
854 1217768 : asm volatile ("pxor %xmm7,%xmm2");
855 1217768 : asm volatile ("pxor %xmm15,%xmm10");
856 :
857 1217768 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
858 1217768 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
859 1217768 : asm volatile ("movdqa %xmm3,%xmm11");
860 1217768 : asm volatile ("movdqa %xmm7,%xmm15");
861 1217768 : asm volatile ("pshufb %xmm4,%xmm3");
862 1217768 : asm volatile ("pshufb %xmm12,%xmm11");
863 1217768 : asm volatile ("pshufb %xmm5,%xmm7");
864 1217768 : asm volatile ("pshufb %xmm13,%xmm15");
865 1217768 : asm volatile ("pxor %xmm7,%xmm3");
866 1217768 : asm volatile ("pxor %xmm15,%xmm11");
867 :
868 : /* intermediate disks */
869 6711640 : for (d = l - 1; d > 0; --d) {
870 5493872 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
871 5493872 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
872 5493872 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
873 5493872 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
874 :
875 5493872 : asm volatile ("pxor %xmm5,%xmm5");
876 5493872 : asm volatile ("pxor %xmm13,%xmm13");
877 5493872 : asm volatile ("pcmpgtb %xmm1,%xmm5");
878 5493872 : asm volatile ("pcmpgtb %xmm9,%xmm13");
879 5493872 : asm volatile ("paddb %xmm1,%xmm1");
880 5493872 : asm volatile ("paddb %xmm9,%xmm9");
881 5493872 : asm volatile ("pand %xmm7,%xmm5");
882 5493872 : asm volatile ("pand %xmm7,%xmm13");
883 5493872 : asm volatile ("pxor %xmm5,%xmm1");
884 5493872 : asm volatile ("pxor %xmm13,%xmm9");
885 :
886 5493872 : asm volatile ("pxor %xmm4,%xmm0");
887 5493872 : asm volatile ("pxor %xmm4,%xmm1");
888 5493872 : asm volatile ("pxor %xmm12,%xmm8");
889 5493872 : asm volatile ("pxor %xmm12,%xmm9");
890 :
891 5493872 : asm volatile ("movdqa %xmm4,%xmm5");
892 5493872 : asm volatile ("movdqa %xmm12,%xmm13");
893 5493872 : asm volatile ("psrlw $4,%xmm5");
894 5493872 : asm volatile ("psrlw $4,%xmm13");
895 5493872 : asm volatile ("pand %xmm15,%xmm4");
896 5493872 : asm volatile ("pand %xmm15,%xmm12");
897 5493872 : asm volatile ("pand %xmm15,%xmm5");
898 5493872 : asm volatile ("pand %xmm15,%xmm13");
899 :
900 5493872 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
901 5493872 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
902 5493872 : asm volatile ("movdqa %xmm6,%xmm14");
903 5493872 : asm volatile ("movdqa %xmm7,%xmm15");
904 5493872 : asm volatile ("pshufb %xmm4,%xmm6");
905 5493872 : asm volatile ("pshufb %xmm12,%xmm14");
906 5493872 : asm volatile ("pshufb %xmm5,%xmm7");
907 5493872 : asm volatile ("pshufb %xmm13,%xmm15");
908 5493872 : asm volatile ("pxor %xmm6,%xmm2");
909 5493872 : asm volatile ("pxor %xmm14,%xmm10");
910 5493872 : asm volatile ("pxor %xmm7,%xmm2");
911 5493872 : asm volatile ("pxor %xmm15,%xmm10");
912 :
913 5493872 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
914 5493872 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
915 5493872 : asm volatile ("movdqa %xmm6,%xmm14");
916 5493872 : asm volatile ("movdqa %xmm7,%xmm15");
917 5493872 : asm volatile ("pshufb %xmm4,%xmm6");
918 5493872 : asm volatile ("pshufb %xmm12,%xmm14");
919 5493872 : asm volatile ("pshufb %xmm5,%xmm7");
920 5493872 : asm volatile ("pshufb %xmm13,%xmm15");
921 5493872 : asm volatile ("pxor %xmm6,%xmm3");
922 5493872 : asm volatile ("pxor %xmm14,%xmm11");
923 5493872 : asm volatile ("pxor %xmm7,%xmm3");
924 5493872 : asm volatile ("pxor %xmm15,%xmm11");
925 : }
926 :
927 : /* first disk with all coefficients at 1 */
928 1217768 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
929 1217768 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
930 1217768 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
931 1217768 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
932 :
933 1217768 : asm volatile ("pxor %xmm5,%xmm5");
934 1217768 : asm volatile ("pxor %xmm13,%xmm13");
935 1217768 : asm volatile ("pcmpgtb %xmm1,%xmm5");
936 1217768 : asm volatile ("pcmpgtb %xmm9,%xmm13");
937 1217768 : asm volatile ("paddb %xmm1,%xmm1");
938 1217768 : asm volatile ("paddb %xmm9,%xmm9");
939 1217768 : asm volatile ("pand %xmm7,%xmm5");
940 1217768 : asm volatile ("pand %xmm7,%xmm13");
941 1217768 : asm volatile ("pxor %xmm5,%xmm1");
942 1217768 : asm volatile ("pxor %xmm13,%xmm9");
943 :
944 1217768 : asm volatile ("pxor %xmm4,%xmm0");
945 1217768 : asm volatile ("pxor %xmm4,%xmm1");
946 1217768 : asm volatile ("pxor %xmm4,%xmm2");
947 1217768 : asm volatile ("pxor %xmm4,%xmm3");
948 1217768 : asm volatile ("pxor %xmm12,%xmm8");
949 1217768 : asm volatile ("pxor %xmm12,%xmm9");
950 1217768 : asm volatile ("pxor %xmm12,%xmm10");
951 1217768 : asm volatile ("pxor %xmm12,%xmm11");
952 :
953 1217768 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
954 1217768 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
955 1217768 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
956 1217768 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
957 1217768 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
958 1217768 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
959 1217768 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
960 1217768 : 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 6 : void raid_gen5_ssse3(int nd, size_t size, void **vv)
1133 : {
1134 6 : 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 6 : uint8_t *pd = __align_ptr(buffer, 16);
1144 :
1145 6 : l = nd - 1;
1146 6 : p = v[nd];
1147 6 : q = v[nd + 1];
1148 6 : r = v[nd + 2];
1149 6 : s = v[nd + 3];
1150 6 : t = v[nd + 4];
1151 :
1152 : /* special case with only one data disk */
1153 6 : 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 65557 : for (i = 0; i < size; i += 16) {
1163 : /* last disk without the by two multiplication */
1164 65552 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1165 :
1166 65552 : asm volatile ("movdqa %xmm4,%xmm0");
1167 65552 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1168 :
1169 65552 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1170 65552 : asm volatile ("movdqa %xmm4,%xmm5");
1171 65552 : asm volatile ("psrlw $4,%xmm5");
1172 65552 : asm volatile ("pand %xmm7,%xmm4");
1173 65552 : asm volatile ("pand %xmm7,%xmm5");
1174 :
1175 65552 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][0][0][0]));
1176 65552 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1177 65552 : asm volatile ("pshufb %xmm4,%xmm1");
1178 65552 : asm volatile ("pshufb %xmm5,%xmm7");
1179 65552 : asm volatile ("pxor %xmm7,%xmm1");
1180 :
1181 65552 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][1][0][0]));
1182 65552 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1183 65552 : asm volatile ("pshufb %xmm4,%xmm2");
1184 65552 : asm volatile ("pshufb %xmm5,%xmm7");
1185 65552 : asm volatile ("pxor %xmm7,%xmm2");
1186 :
1187 65552 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][2][0][0]));
1188 65552 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1189 65552 : asm volatile ("pshufb %xmm4,%xmm3");
1190 65552 : asm volatile ("pshufb %xmm5,%xmm7");
1191 65552 : asm volatile ("pxor %xmm7,%xmm3");
1192 :
1193 : /* intermediate disks */
1194 459248 : for (d = l - 1; d > 0; --d) {
1195 393696 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1196 393696 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1197 393696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1198 :
1199 393696 : asm volatile ("pxor %xmm5,%xmm5");
1200 393696 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1201 393696 : asm volatile ("paddb %xmm0,%xmm0");
1202 393696 : asm volatile ("pand %xmm7,%xmm5");
1203 393696 : asm volatile ("pxor %xmm5,%xmm0");
1204 :
1205 393696 : asm volatile ("pxor %xmm4,%xmm0");
1206 393696 : asm volatile ("pxor %xmm4,%xmm6");
1207 393696 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[0]));
1208 :
1209 393696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1210 393696 : asm volatile ("movdqa %xmm4,%xmm5");
1211 393696 : asm volatile ("psrlw $4,%xmm5");
1212 393696 : asm volatile ("pand %xmm7,%xmm4");
1213 393696 : asm volatile ("pand %xmm7,%xmm5");
1214 :
1215 393696 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1216 393696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1217 393696 : asm volatile ("pshufb %xmm4,%xmm6");
1218 393696 : asm volatile ("pshufb %xmm5,%xmm7");
1219 393696 : asm volatile ("pxor %xmm6,%xmm1");
1220 393696 : asm volatile ("pxor %xmm7,%xmm1");
1221 :
1222 393696 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1223 393696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1224 393696 : asm volatile ("pshufb %xmm4,%xmm6");
1225 393696 : asm volatile ("pshufb %xmm5,%xmm7");
1226 393696 : asm volatile ("pxor %xmm6,%xmm2");
1227 393696 : asm volatile ("pxor %xmm7,%xmm2");
1228 :
1229 393696 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1230 393696 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1231 393696 : asm volatile ("pshufb %xmm4,%xmm6");
1232 393696 : asm volatile ("pshufb %xmm5,%xmm7");
1233 393696 : asm volatile ("pxor %xmm6,%xmm3");
1234 393696 : asm volatile ("pxor %xmm7,%xmm3");
1235 : }
1236 :
1237 : /* first disk with all coefficients at 1 */
1238 65552 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1239 65552 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1240 65552 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1241 :
1242 65552 : asm volatile ("pxor %xmm5,%xmm5");
1243 65552 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1244 65552 : asm volatile ("paddb %xmm0,%xmm0");
1245 65552 : asm volatile ("pand %xmm7,%xmm5");
1246 65552 : asm volatile ("pxor %xmm5,%xmm0");
1247 :
1248 65552 : asm volatile ("pxor %xmm4,%xmm0");
1249 65552 : asm volatile ("pxor %xmm4,%xmm1");
1250 65552 : asm volatile ("pxor %xmm4,%xmm2");
1251 65552 : asm volatile ("pxor %xmm4,%xmm3");
1252 65552 : asm volatile ("pxor %xmm4,%xmm6");
1253 :
1254 65552 : asm volatile ("movntdq %%xmm6,%0" : "=m" (p[i]));
1255 65552 : asm volatile ("movntdq %%xmm0,%0" : "=m" (q[i]));
1256 65552 : asm volatile ("movntdq %%xmm1,%0" : "=m" (r[i]));
1257 65552 : asm volatile ("movntdq %%xmm2,%0" : "=m" (s[i]));
1258 65552 : 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 37407 : void raid_gen5_ssse3ext(int nd, size_t size, void **vv)
1272 : {
1273 37407 : 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 37407 : l = nd - 1;
1283 37407 : p = v[nd];
1284 37407 : q = v[nd + 1];
1285 37407 : r = v[nd + 2];
1286 37407 : s = v[nd + 3];
1287 37407 : t = v[nd + 4];
1288 :
1289 : /* special case with only one data disk */
1290 37407 : 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 37406 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1300 37406 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1301 :
1302 3035182 : for (i = 0; i < size; i += 16) {
1303 : /* last disk without the by two multiplication */
1304 2997776 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1305 :
1306 2997776 : asm volatile ("movdqa %xmm10,%xmm0");
1307 2997776 : asm volatile ("movdqa %xmm10,%xmm1");
1308 :
1309 2997776 : asm volatile ("movdqa %xmm10,%xmm11");
1310 2997776 : asm volatile ("psrlw $4,%xmm11");
1311 2997776 : asm volatile ("pand %xmm15,%xmm10");
1312 2997776 : asm volatile ("pand %xmm15,%xmm11");
1313 :
1314 2997776 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1315 2997776 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1316 2997776 : asm volatile ("pshufb %xmm10,%xmm2");
1317 2997776 : asm volatile ("pshufb %xmm11,%xmm13");
1318 2997776 : asm volatile ("pxor %xmm13,%xmm2");
1319 :
1320 2997776 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1321 2997776 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1322 2997776 : asm volatile ("pshufb %xmm10,%xmm3");
1323 2997776 : asm volatile ("pshufb %xmm11,%xmm13");
1324 2997776 : asm volatile ("pxor %xmm13,%xmm3");
1325 :
1326 2997776 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1327 2997776 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1328 2997776 : asm volatile ("pshufb %xmm10,%xmm4");
1329 2997776 : asm volatile ("pshufb %xmm11,%xmm13");
1330 2997776 : asm volatile ("pxor %xmm13,%xmm4");
1331 :
1332 : /* intermediate disks */
1333 16201712 : for (d = l - 1; d > 0; --d) {
1334 13203936 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1335 :
1336 13203936 : asm volatile ("pxor %xmm11,%xmm11");
1337 13203936 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1338 13203936 : asm volatile ("paddb %xmm1,%xmm1");
1339 13203936 : asm volatile ("pand %xmm14,%xmm11");
1340 13203936 : asm volatile ("pxor %xmm11,%xmm1");
1341 :
1342 13203936 : asm volatile ("pxor %xmm10,%xmm0");
1343 13203936 : asm volatile ("pxor %xmm10,%xmm1");
1344 :
1345 13203936 : asm volatile ("movdqa %xmm10,%xmm11");
1346 13203936 : asm volatile ("psrlw $4,%xmm11");
1347 13203936 : asm volatile ("pand %xmm15,%xmm10");
1348 13203936 : asm volatile ("pand %xmm15,%xmm11");
1349 :
1350 13203936 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1351 13203936 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1352 13203936 : asm volatile ("pshufb %xmm10,%xmm12");
1353 13203936 : asm volatile ("pshufb %xmm11,%xmm13");
1354 13203936 : asm volatile ("pxor %xmm12,%xmm2");
1355 13203936 : asm volatile ("pxor %xmm13,%xmm2");
1356 :
1357 13203936 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1358 13203936 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1359 13203936 : asm volatile ("pshufb %xmm10,%xmm12");
1360 13203936 : asm volatile ("pshufb %xmm11,%xmm13");
1361 13203936 : asm volatile ("pxor %xmm12,%xmm3");
1362 13203936 : asm volatile ("pxor %xmm13,%xmm3");
1363 :
1364 13203936 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1365 13203936 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1366 13203936 : asm volatile ("pshufb %xmm10,%xmm12");
1367 13203936 : asm volatile ("pshufb %xmm11,%xmm13");
1368 13203936 : asm volatile ("pxor %xmm12,%xmm4");
1369 13203936 : asm volatile ("pxor %xmm13,%xmm4");
1370 : }
1371 :
1372 : /* first disk with all coefficients at 1 */
1373 2997776 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1374 :
1375 2997776 : asm volatile ("pxor %xmm11,%xmm11");
1376 2997776 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1377 2997776 : asm volatile ("paddb %xmm1,%xmm1");
1378 2997776 : asm volatile ("pand %xmm14,%xmm11");
1379 2997776 : asm volatile ("pxor %xmm11,%xmm1");
1380 :
1381 2997776 : asm volatile ("pxor %xmm10,%xmm0");
1382 2997776 : asm volatile ("pxor %xmm10,%xmm1");
1383 2997776 : asm volatile ("pxor %xmm10,%xmm2");
1384 2997776 : asm volatile ("pxor %xmm10,%xmm3");
1385 2997776 : asm volatile ("pxor %xmm10,%xmm4");
1386 :
1387 2997776 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1388 2997776 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1389 2997776 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1390 2997776 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1391 2997776 : 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 5 : void raid_gen6_ssse3(int nd, size_t size, void **vv)
1533 : {
1534 5 : 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 5 : uint8_t *pd = __align_ptr(buffer, 16);
1545 :
1546 5 : l = nd - 1;
1547 5 : p = v[nd];
1548 5 : q = v[nd + 1];
1549 5 : r = v[nd + 2];
1550 5 : s = v[nd + 3];
1551 5 : t = v[nd + 4];
1552 5 : u = v[nd + 5];
1553 :
1554 : /* special case with only one data disk */
1555 5 : 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 49172 : for (i = 0; i < size; i += 16) {
1565 : /* last disk without the by two multiplication */
1566 49168 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1567 :
1568 49168 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1569 49168 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[16]));
1570 :
1571 49168 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1572 49168 : asm volatile ("movdqa %xmm4,%xmm5");
1573 49168 : asm volatile ("psrlw $4,%xmm5");
1574 49168 : asm volatile ("pand %xmm7,%xmm4");
1575 49168 : asm volatile ("pand %xmm7,%xmm5");
1576 :
1577 49168 : asm volatile ("movdqa %0,%%xmm0" : : "m" (gfgenpshufb[l][0][0][0]));
1578 49168 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1579 49168 : asm volatile ("pshufb %xmm4,%xmm0");
1580 49168 : asm volatile ("pshufb %xmm5,%xmm7");
1581 49168 : asm volatile ("pxor %xmm7,%xmm0");
1582 :
1583 49168 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][1][0][0]));
1584 49168 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1585 49168 : asm volatile ("pshufb %xmm4,%xmm1");
1586 49168 : asm volatile ("pshufb %xmm5,%xmm7");
1587 49168 : asm volatile ("pxor %xmm7,%xmm1");
1588 :
1589 49168 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][2][0][0]));
1590 49168 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1591 49168 : asm volatile ("pshufb %xmm4,%xmm2");
1592 49168 : asm volatile ("pshufb %xmm5,%xmm7");
1593 49168 : asm volatile ("pxor %xmm7,%xmm2");
1594 :
1595 49168 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][3][0][0]));
1596 49168 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][3][1][0]));
1597 49168 : asm volatile ("pshufb %xmm4,%xmm3");
1598 49168 : asm volatile ("pshufb %xmm5,%xmm7");
1599 49168 : asm volatile ("pxor %xmm7,%xmm3");
1600 :
1601 : /* intermediate disks */
1602 344560 : for (d = l - 1; d > 0; --d) {
1603 295392 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
1604 295392 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
1605 295392 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1606 :
1607 295392 : asm volatile ("pxor %xmm4,%xmm4");
1608 295392 : asm volatile ("pcmpgtb %xmm6,%xmm4");
1609 295392 : asm volatile ("paddb %xmm6,%xmm6");
1610 295392 : asm volatile ("pand %xmm7,%xmm4");
1611 295392 : asm volatile ("pxor %xmm4,%xmm6");
1612 :
1613 295392 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1614 :
1615 295392 : asm volatile ("pxor %xmm4,%xmm5");
1616 295392 : asm volatile ("pxor %xmm4,%xmm6");
1617 295392 : asm volatile ("movdqa %%xmm5,%0" : "=m" (pd[0]));
1618 295392 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[16]));
1619 :
1620 295392 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1621 295392 : asm volatile ("movdqa %xmm4,%xmm5");
1622 295392 : asm volatile ("psrlw $4,%xmm5");
1623 295392 : asm volatile ("pand %xmm7,%xmm4");
1624 295392 : asm volatile ("pand %xmm7,%xmm5");
1625 :
1626 295392 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1627 295392 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1628 295392 : asm volatile ("pshufb %xmm4,%xmm6");
1629 295392 : asm volatile ("pshufb %xmm5,%xmm7");
1630 295392 : asm volatile ("pxor %xmm6,%xmm0");
1631 295392 : asm volatile ("pxor %xmm7,%xmm0");
1632 :
1633 295392 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1634 295392 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1635 295392 : asm volatile ("pshufb %xmm4,%xmm6");
1636 295392 : asm volatile ("pshufb %xmm5,%xmm7");
1637 295392 : asm volatile ("pxor %xmm6,%xmm1");
1638 295392 : asm volatile ("pxor %xmm7,%xmm1");
1639 :
1640 295392 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1641 295392 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1642 295392 : asm volatile ("pshufb %xmm4,%xmm6");
1643 295392 : asm volatile ("pshufb %xmm5,%xmm7");
1644 295392 : asm volatile ("pxor %xmm6,%xmm2");
1645 295392 : asm volatile ("pxor %xmm7,%xmm2");
1646 :
1647 295392 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][3][0][0]));
1648 295392 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][3][1][0]));
1649 295392 : asm volatile ("pshufb %xmm4,%xmm6");
1650 295392 : asm volatile ("pshufb %xmm5,%xmm7");
1651 295392 : asm volatile ("pxor %xmm6,%xmm3");
1652 295392 : asm volatile ("pxor %xmm7,%xmm3");
1653 : }
1654 :
1655 : /* first disk with all coefficients at 1 */
1656 49168 : asm volatile ("movdqa %0,%%xmm5" : : "m" (pd[0]));
1657 49168 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[16]));
1658 49168 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1659 :
1660 49168 : asm volatile ("pxor %xmm4,%xmm4");
1661 49168 : asm volatile ("pcmpgtb %xmm6,%xmm4");
1662 49168 : asm volatile ("paddb %xmm6,%xmm6");
1663 49168 : asm volatile ("pand %xmm7,%xmm4");
1664 49168 : asm volatile ("pxor %xmm4,%xmm6");
1665 :
1666 49168 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1667 49168 : asm volatile ("pxor %xmm4,%xmm0");
1668 49168 : asm volatile ("pxor %xmm4,%xmm1");
1669 49168 : asm volatile ("pxor %xmm4,%xmm2");
1670 49168 : asm volatile ("pxor %xmm4,%xmm3");
1671 49168 : asm volatile ("pxor %xmm4,%xmm5");
1672 49168 : asm volatile ("pxor %xmm4,%xmm6");
1673 :
1674 49168 : asm volatile ("movntdq %%xmm5,%0" : "=m" (p[i]));
1675 49168 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i]));
1676 49168 : asm volatile ("movntdq %%xmm0,%0" : "=m" (r[i]));
1677 49168 : asm volatile ("movntdq %%xmm1,%0" : "=m" (s[i]));
1678 49168 : asm volatile ("movntdq %%xmm2,%0" : "=m" (t[i]));
1679 49168 : 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 537736 : void raid_gen6_ssse3ext(int nd, size_t size, void **vv)
1693 : {
1694 537736 : 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 537736 : l = nd - 1;
1705 537736 : p = v[nd];
1706 537736 : q = v[nd + 1];
1707 537736 : r = v[nd + 2];
1708 537736 : s = v[nd + 3];
1709 537736 : t = v[nd + 4];
1710 537736 : u = v[nd + 5];
1711 :
1712 : /* special case with only one data disk */
1713 537736 : 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 537735 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1723 537735 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1724 :
1725 35523927 : for (i = 0; i < size; i += 16) {
1726 : /* last disk without the by two multiplication */
1727 34986192 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1728 :
1729 34986192 : asm volatile ("movdqa %xmm10,%xmm0");
1730 34986192 : asm volatile ("movdqa %xmm10,%xmm1");
1731 :
1732 34986192 : asm volatile ("movdqa %xmm10,%xmm11");
1733 34986192 : asm volatile ("psrlw $4,%xmm11");
1734 34986192 : asm volatile ("pand %xmm15,%xmm10");
1735 34986192 : asm volatile ("pand %xmm15,%xmm11");
1736 :
1737 34986192 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1738 34986192 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1739 34986192 : asm volatile ("pshufb %xmm10,%xmm2");
1740 34986192 : asm volatile ("pshufb %xmm11,%xmm13");
1741 34986192 : asm volatile ("pxor %xmm13,%xmm2");
1742 :
1743 34986192 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1744 34986192 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1745 34986192 : asm volatile ("pshufb %xmm10,%xmm3");
1746 34986192 : asm volatile ("pshufb %xmm11,%xmm13");
1747 34986192 : asm volatile ("pxor %xmm13,%xmm3");
1748 :
1749 34986192 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1750 34986192 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1751 34986192 : asm volatile ("pshufb %xmm10,%xmm4");
1752 34986192 : asm volatile ("pshufb %xmm11,%xmm13");
1753 34986192 : asm volatile ("pxor %xmm13,%xmm4");
1754 :
1755 34986192 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfgenpshufb[l][3][0][0]));
1756 34986192 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][3][1][0]));
1757 34986192 : asm volatile ("pshufb %xmm10,%xmm5");
1758 34986192 : asm volatile ("pshufb %xmm11,%xmm13");
1759 34986192 : asm volatile ("pxor %xmm13,%xmm5");
1760 :
1761 : /* intermediate disks */
1762 176078256 : for (d = l - 1; d > 0; --d) {
1763 141092064 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1764 :
1765 141092064 : asm volatile ("pxor %xmm11,%xmm11");
1766 141092064 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1767 141092064 : asm volatile ("paddb %xmm1,%xmm1");
1768 141092064 : asm volatile ("pand %xmm14,%xmm11");
1769 141092064 : asm volatile ("pxor %xmm11,%xmm1");
1770 :
1771 141092064 : asm volatile ("pxor %xmm10,%xmm0");
1772 141092064 : asm volatile ("pxor %xmm10,%xmm1");
1773 :
1774 141092064 : asm volatile ("movdqa %xmm10,%xmm11");
1775 141092064 : asm volatile ("psrlw $4,%xmm11");
1776 141092064 : asm volatile ("pand %xmm15,%xmm10");
1777 141092064 : asm volatile ("pand %xmm15,%xmm11");
1778 :
1779 141092064 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1780 141092064 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1781 141092064 : asm volatile ("pshufb %xmm10,%xmm12");
1782 141092064 : asm volatile ("pshufb %xmm11,%xmm13");
1783 141092064 : asm volatile ("pxor %xmm12,%xmm2");
1784 141092064 : asm volatile ("pxor %xmm13,%xmm2");
1785 :
1786 141092064 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1787 141092064 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1788 141092064 : asm volatile ("pshufb %xmm10,%xmm12");
1789 141092064 : asm volatile ("pshufb %xmm11,%xmm13");
1790 141092064 : asm volatile ("pxor %xmm12,%xmm3");
1791 141092064 : asm volatile ("pxor %xmm13,%xmm3");
1792 :
1793 141092064 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1794 141092064 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1795 141092064 : asm volatile ("pshufb %xmm10,%xmm12");
1796 141092064 : asm volatile ("pshufb %xmm11,%xmm13");
1797 141092064 : asm volatile ("pxor %xmm12,%xmm4");
1798 141092064 : asm volatile ("pxor %xmm13,%xmm4");
1799 :
1800 141092064 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][3][0][0]));
1801 141092064 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][3][1][0]));
1802 141092064 : asm volatile ("pshufb %xmm10,%xmm12");
1803 141092064 : asm volatile ("pshufb %xmm11,%xmm13");
1804 141092064 : asm volatile ("pxor %xmm12,%xmm5");
1805 141092064 : asm volatile ("pxor %xmm13,%xmm5");
1806 : }
1807 :
1808 : /* first disk with all coefficients at 1 */
1809 34986192 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1810 :
1811 34986192 : asm volatile ("pxor %xmm11,%xmm11");
1812 34986192 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1813 34986192 : asm volatile ("paddb %xmm1,%xmm1");
1814 34986192 : asm volatile ("pand %xmm14,%xmm11");
1815 34986192 : asm volatile ("pxor %xmm11,%xmm1");
1816 :
1817 34986192 : asm volatile ("pxor %xmm10,%xmm0");
1818 34986192 : asm volatile ("pxor %xmm10,%xmm1");
1819 34986192 : asm volatile ("pxor %xmm10,%xmm2");
1820 34986192 : asm volatile ("pxor %xmm10,%xmm3");
1821 34986192 : asm volatile ("pxor %xmm10,%xmm4");
1822 34986192 : asm volatile ("pxor %xmm10,%xmm5");
1823 :
1824 34986192 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1825 34986192 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1826 34986192 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1827 34986192 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1828 34986192 : asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
1829 34986192 : 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 106547 : void raid_rec1_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
1988 : {
1989 106547 : 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 106547 : if (ip[0] == 0) {
2000 96481 : raid_rec1of1(id, nd, size, vv);
2001 96481 : return;
2002 : }
2003 :
2004 : /* setup the coefficients matrix */
2005 10066 : G = A(ip[0], id[0]);
2006 :
2007 : /* invert it to solve the system of linear equations */
2008 10066 : V = inv(G);
2009 :
2010 : /* compute delta parity */
2011 10066 : raid_delta_gen(1, id, ip, nd, size, vv);
2012 :
2013 10066 : p = v[nd + ip[0]];
2014 10066 : pa = v[id[0]];
2015 :
2016 : raid_sse_begin();
2017 :
2018 10066 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2019 10066 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfmulpshufb[V][0][0]));
2020 10066 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfmulpshufb[V][1][0]));
2021 :
2022 1041938 : for (i = 0; i < size; i += 16) {
2023 1031872 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[i]));
2024 1031872 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[i]));
2025 1031872 : asm volatile ("movdqa %xmm4,%xmm2");
2026 1031872 : asm volatile ("movdqa %xmm5,%xmm3");
2027 1031872 : asm volatile ("pxor %xmm0,%xmm1");
2028 1031872 : asm volatile ("movdqa %xmm1,%xmm0");
2029 1031872 : asm volatile ("psrlw $4,%xmm1");
2030 1031872 : asm volatile ("pand %xmm7,%xmm0");
2031 1031872 : asm volatile ("pand %xmm7,%xmm1");
2032 1031872 : asm volatile ("pshufb %xmm0,%xmm2");
2033 1031872 : asm volatile ("pshufb %xmm1,%xmm3");
2034 1031872 : asm volatile ("pxor %xmm3,%xmm2");
2035 1031872 : 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 43725 : void raid_rec2_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2047 43725 : {
2048 43725 : uint8_t **v = (uint8_t **)vv;
2049 43725 : const int N = 2;
2050 43725 : uint8_t *p[N];
2051 43725 : uint8_t *pa[N];
2052 43725 : uint8_t G[N * N];
2053 43725 : 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 131175 : for (j = 0; j < N; ++j)
2061 262350 : for (k = 0; k < N; ++k)
2062 349800 : G[j * N + k] = A(ip[j], id[k]);
2063 :
2064 : /* invert it to solve the system of linear equations */
2065 43725 : raid_invert(G, V, N);
2066 :
2067 : /* compute delta parity */
2068 43725 : raid_delta_gen(N, id, ip, nd, size, vv);
2069 :
2070 131175 : for (j = 0; j < N; ++j) {
2071 87450 : p[j] = v[nd + ip[j]];
2072 87450 : pa[j] = v[id[j]];
2073 : }
2074 :
2075 : raid_sse_begin();
2076 :
2077 43725 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2078 :
2079 3176781 : for (i = 0; i < size; i += 16) {
2080 3133056 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[0][i]));
2081 3133056 : asm volatile ("movdqa %0,%%xmm2" : : "m" (pa[0][i]));
2082 3133056 : asm volatile ("movdqa %0,%%xmm1" : : "m" (p[1][i]));
2083 3133056 : asm volatile ("movdqa %0,%%xmm3" : : "m" (pa[1][i]));
2084 3133056 : asm volatile ("pxor %xmm2,%xmm0");
2085 3133056 : asm volatile ("pxor %xmm3,%xmm1");
2086 :
2087 3133056 : asm volatile ("pxor %xmm6,%xmm6");
2088 :
2089 3133056 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[0]][0][0]));
2090 3133056 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[0]][1][0]));
2091 3133056 : asm volatile ("movdqa %xmm0,%xmm4");
2092 3133056 : asm volatile ("movdqa %xmm0,%xmm5");
2093 3133056 : asm volatile ("psrlw $4,%xmm5");
2094 3133056 : asm volatile ("pand %xmm7,%xmm4");
2095 3133056 : asm volatile ("pand %xmm7,%xmm5");
2096 3133056 : asm volatile ("pshufb %xmm4,%xmm2");
2097 3133056 : asm volatile ("pshufb %xmm5,%xmm3");
2098 3133056 : asm volatile ("pxor %xmm2,%xmm6");
2099 3133056 : asm volatile ("pxor %xmm3,%xmm6");
2100 :
2101 3133056 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[1]][0][0]));
2102 3133056 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[1]][1][0]));
2103 3133056 : asm volatile ("movdqa %xmm1,%xmm4");
2104 3133056 : asm volatile ("movdqa %xmm1,%xmm5");
2105 3133056 : asm volatile ("psrlw $4,%xmm5");
2106 3133056 : asm volatile ("pand %xmm7,%xmm4");
2107 3133056 : asm volatile ("pand %xmm7,%xmm5");
2108 3133056 : asm volatile ("pshufb %xmm4,%xmm2");
2109 3133056 : asm volatile ("pshufb %xmm5,%xmm3");
2110 3133056 : asm volatile ("pxor %xmm2,%xmm6");
2111 3133056 : asm volatile ("pxor %xmm3,%xmm6");
2112 :
2113 3133056 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[0][i]));
2114 :
2115 3133056 : asm volatile ("pxor %xmm6,%xmm6");
2116 :
2117 3133056 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[2]][0][0]));
2118 3133056 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[2]][1][0]));
2119 3133056 : asm volatile ("movdqa %xmm0,%xmm4");
2120 3133056 : asm volatile ("movdqa %xmm0,%xmm5");
2121 3133056 : asm volatile ("psrlw $4,%xmm5");
2122 3133056 : asm volatile ("pand %xmm7,%xmm4");
2123 3133056 : asm volatile ("pand %xmm7,%xmm5");
2124 3133056 : asm volatile ("pshufb %xmm4,%xmm2");
2125 3133056 : asm volatile ("pshufb %xmm5,%xmm3");
2126 3133056 : asm volatile ("pxor %xmm2,%xmm6");
2127 3133056 : asm volatile ("pxor %xmm3,%xmm6");
2128 :
2129 3133056 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[3]][0][0]));
2130 3133056 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[3]][1][0]));
2131 3133056 : asm volatile ("movdqa %xmm1,%xmm4");
2132 3133056 : asm volatile ("movdqa %xmm1,%xmm5");
2133 3133056 : asm volatile ("psrlw $4,%xmm5");
2134 3133056 : asm volatile ("pand %xmm7,%xmm4");
2135 3133056 : asm volatile ("pand %xmm7,%xmm5");
2136 3133056 : asm volatile ("pshufb %xmm4,%xmm2");
2137 3133056 : asm volatile ("pshufb %xmm5,%xmm3");
2138 3133056 : asm volatile ("pxor %xmm2,%xmm6");
2139 3133056 : asm volatile ("pxor %xmm3,%xmm6");
2140 :
2141 3133056 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[1][i]));
2142 : }
2143 :
2144 : raid_sse_end();
2145 43725 : }
2146 : #endif
2147 :
2148 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
2149 : /*
2150 : * RAID recovering SSSE3 implementation
2151 : */
2152 92594 : void raid_recX_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2153 : {
2154 92594 : uint8_t **v = (uint8_t **)vv;
2155 92594 : 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 92594 : uint8_t *pd = __align_ptr(buffer, 16);
2162 : size_t i;
2163 : int j, k;
2164 :
2165 : /* setup the coefficients matrix */
2166 487938 : for (j = 0; j < N; ++j)
2167 2202574 : for (k = 0; k < N; ++k)
2168 3614460 : G[j * N + k] = A(ip[j], id[k]);
2169 :
2170 : /* invert it to solve the system of linear equations */
2171 92594 : raid_invert(G, V, N);
2172 :
2173 : /* compute delta parity */
2174 92594 : raid_delta_gen(N, id, ip, nd, size, vv);
2175 :
2176 487938 : for (j = 0; j < N; ++j) {
2177 395344 : p[j] = v[nd + ip[j]];
2178 395344 : pa[j] = v[id[j]];
2179 : }
2180 :
2181 : raid_sse_begin();
2182 :
2183 92594 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2184 :
2185 6734722 : for (i = 0; i < size; i += 16) {
2186 : /* delta */
2187 35496912 : for (j = 0; j < N; ++j) {
2188 28854784 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[j][i]));
2189 28854784 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[j][i]));
2190 28854784 : asm volatile ("pxor %xmm1,%xmm0");
2191 28854784 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pd[j*16]));
2192 : }
2193 :
2194 : /* reconstruct */
2195 35496912 : for (j = 0; j < N; ++j) {
2196 28854784 : asm volatile ("pxor %xmm0,%xmm0");
2197 28854784 : asm volatile ("pxor %xmm1,%xmm1");
2198 :
2199 163204672 : for (k = 0; k < N; ++k) {
2200 134349888 : uint8_t m = V[j * N + k];
2201 :
2202 134349888 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[m][0][0]));
2203 134349888 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[m][1][0]));
2204 134349888 : asm volatile ("movdqa %0,%%xmm4" : : "m" (pd[k*16]));
2205 134349888 : asm volatile ("movdqa %xmm4,%xmm5");
2206 134349888 : asm volatile ("psrlw $4,%xmm5");
2207 134349888 : asm volatile ("pand %xmm7,%xmm4");
2208 134349888 : asm volatile ("pand %xmm7,%xmm5");
2209 134349888 : asm volatile ("pshufb %xmm4,%xmm2");
2210 134349888 : asm volatile ("pshufb %xmm5,%xmm3");
2211 134349888 : asm volatile ("pxor %xmm2,%xmm0");
2212 134349888 : asm volatile ("pxor %xmm3,%xmm1");
2213 : }
2214 :
2215 28854784 : asm volatile ("pxor %xmm1,%xmm0");
2216 28854784 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pa[j][i]));
2217 : }
2218 : }
2219 :
2220 : raid_sse_end();
2221 92594 : }
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 96 : G = A(ip[0], id[0]);
2247 :
2248 : /* invert it to solve the system of linear equations */
2249 96 : 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 :
|
