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 283829 : void raid_gen1_sse2(int nd, size_t size, void **vv)
37 : {
38 283829 : uint8_t **v = (uint8_t **)vv;
39 : uint8_t *p;
40 : int d, l;
41 : size_t i;
42 :
43 283829 : l = nd - 1;
44 283829 : p = v[nd];
45 :
46 : raid_sse_begin();
47 :
48 5033137 : for (i = 0; i < size; i += 64) {
49 4749308 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
50 4749308 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
51 4749308 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
52 4749308 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
53 28913828 : for (d = l - 1; d >= 0; --d) {
54 24164520 : asm volatile ("pxor %0,%%xmm0" : : "m" (v[d][i]));
55 24164520 : asm volatile ("pxor %0,%%xmm1" : : "m" (v[d][i + 16]));
56 24164520 : asm volatile ("pxor %0,%%xmm2" : : "m" (v[d][i + 32]));
57 24164520 : asm volatile ("pxor %0,%%xmm3" : : "m" (v[d][i + 48]));
58 : }
59 4749308 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
60 4749308 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
61 4749308 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
62 4749308 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
63 : }
64 :
65 : raid_sse_end();
66 283829 : }
67 : #endif
68 :
69 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
70 : /*
71 : * GEN1 (RAID5 with xor) AVX2 implementation
72 : *
73 : * Intentionally don't process more than 64 bytes because 64 is the typical
74 : * cache block, and processing 128 bytes doesn't increase performance, and in
75 : * some cases it even decreases it.
76 : */
77 97 : void raid_gen1_avx2(int nd, size_t size, void **vv)
78 : {
79 97 : uint8_t **v = (uint8_t **)vv;
80 : uint8_t *p;
81 : int d, l;
82 : size_t i;
83 :
84 97 : l = nd - 1;
85 97 : p = v[nd];
86 :
87 : raid_avx_begin();
88 :
89 50189 : for (i = 0; i < size; i += 64) {
90 50092 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
91 50092 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
92 407172 : for (d = l - 1; d >= 0; --d) {
93 357080 : asm volatile ("vpxor %0,%%ymm0,%%ymm0" : : "m" (v[d][i]));
94 357080 : asm volatile ("vpxor %0,%%ymm1,%%ymm1" : : "m" (v[d][i + 32]));
95 : }
96 50092 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
97 50092 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
98 : }
99 :
100 : raid_avx_end();
101 97 : }
102 : #endif
103 :
104 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
105 : static const struct gfconst16 {
106 : uint8_t poly[16];
107 : uint8_t low4[16];
108 : } gfconst16 __aligned(32) = {
109 : {
110 : 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
111 : 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d
112 : },
113 : {
114 : 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
115 : 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f
116 : },
117 : };
118 : #endif
119 :
120 : #if defined(CONFIG_X86) && defined(CONFIG_SSE2)
121 : /*
122 : * GEN2 (RAID6 with powers of 2) SSE2 implementation
123 : */
124 23 : void raid_gen2_sse2(int nd, size_t size, void **vv)
125 : {
126 23 : uint8_t **v = (uint8_t **)vv;
127 : uint8_t *p;
128 : uint8_t *q;
129 : int d, l;
130 : size_t i;
131 :
132 23 : l = nd - 1;
133 23 : p = v[nd];
134 23 : q = v[nd + 1];
135 :
136 : raid_sse_begin();
137 :
138 23 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
139 :
140 163887 : for (i = 0; i < size; i += 32) {
141 163864 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
142 163864 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
143 163864 : asm volatile ("movdqa %xmm0,%xmm2");
144 163864 : asm volatile ("movdqa %xmm1,%xmm3");
145 1311240 : for (d = l - 1; d >= 0; --d) {
146 1147376 : asm volatile ("pxor %xmm4,%xmm4");
147 1147376 : asm volatile ("pxor %xmm5,%xmm5");
148 1147376 : asm volatile ("pcmpgtb %xmm2,%xmm4");
149 1147376 : asm volatile ("pcmpgtb %xmm3,%xmm5");
150 1147376 : asm volatile ("paddb %xmm2,%xmm2");
151 1147376 : asm volatile ("paddb %xmm3,%xmm3");
152 1147376 : asm volatile ("pand %xmm7,%xmm4");
153 1147376 : asm volatile ("pand %xmm7,%xmm5");
154 1147376 : asm volatile ("pxor %xmm4,%xmm2");
155 1147376 : asm volatile ("pxor %xmm5,%xmm3");
156 :
157 1147376 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
158 1147376 : asm volatile ("movdqa %0,%%xmm5" : : "m" (v[d][i + 16]));
159 1147376 : asm volatile ("pxor %xmm4,%xmm0");
160 1147376 : asm volatile ("pxor %xmm5,%xmm1");
161 1147376 : asm volatile ("pxor %xmm4,%xmm2");
162 1147376 : asm volatile ("pxor %xmm5,%xmm3");
163 : }
164 163864 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
165 163864 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
166 163864 : asm volatile ("movntdq %%xmm2,%0" : "=m" (q[i]));
167 163864 : asm volatile ("movntdq %%xmm3,%0" : "=m" (q[i + 16]));
168 : }
169 :
170 : raid_sse_end();
171 23 : }
172 : #endif
173 :
174 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
175 : /*
176 : * GEN2 (RAID6 with powers of 2) AVX2 implementation
177 : */
178 511 : void raid_gen2_avx2(int nd, size_t size, void **vv)
179 : {
180 511 : uint8_t **v = (uint8_t **)vv;
181 : uint8_t *p;
182 : uint8_t *q;
183 : int d, l;
184 : size_t i;
185 :
186 511 : l = nd - 1;
187 511 : p = v[nd];
188 511 : q = v[nd + 1];
189 :
190 : raid_avx_begin();
191 :
192 511 : asm volatile ("vbroadcasti128 %0, %%ymm7" : : "m" (gfconst16.poly[0]));
193 511 : asm volatile ("vpxor %ymm6,%ymm6,%ymm6");
194 :
195 117851 : for (i = 0; i < size; i += 64) {
196 117340 : asm volatile ("vmovdqa %0,%%ymm0" : : "m" (v[l][i]));
197 117340 : asm volatile ("vmovdqa %0,%%ymm1" : : "m" (v[l][i + 32]));
198 117340 : asm volatile ("vmovdqa %ymm0,%ymm2");
199 117340 : asm volatile ("vmovdqa %ymm1,%ymm3");
200 952516 : for (d = l - 1; d >= 0; --d) {
201 835176 : asm volatile ("vpcmpgtb %ymm2,%ymm6,%ymm4");
202 835176 : asm volatile ("vpcmpgtb %ymm3,%ymm6,%ymm5");
203 835176 : asm volatile ("vpaddb %ymm2,%ymm2,%ymm2");
204 835176 : asm volatile ("vpaddb %ymm3,%ymm3,%ymm3");
205 835176 : asm volatile ("vpand %ymm7,%ymm4,%ymm4");
206 835176 : asm volatile ("vpand %ymm7,%ymm5,%ymm5");
207 835176 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
208 835176 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
209 :
210 835176 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
211 835176 : asm volatile ("vmovdqa %0,%%ymm5" : : "m" (v[d][i + 32]));
212 835176 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
213 835176 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
214 835176 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
215 835176 : asm volatile ("vpxor %ymm5,%ymm3,%ymm3");
216 : }
217 117340 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
218 117340 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (p[i + 32]));
219 117340 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (q[i]));
220 117340 : asm volatile ("vmovntdq %%ymm3,%0" : "=m" (q[i + 32]));
221 : }
222 :
223 : raid_avx_end();
224 511 : }
225 : #endif
226 :
227 : #if defined(CONFIG_X86_64) && defined(CONFIG_SSE2)
228 : /*
229 : * GEN2 (RAID6 with powers of 2) SSE2 implementation
230 : *
231 : * Note that it uses 16 registers, meaning that x64 is required.
232 : */
233 268682 : void raid_gen2_sse2ext(int nd, size_t size, void **vv)
234 : {
235 268682 : uint8_t **v = (uint8_t **)vv;
236 : uint8_t *p;
237 : uint8_t *q;
238 : int d, l;
239 : size_t i;
240 :
241 268682 : l = nd - 1;
242 268682 : p = v[nd];
243 268682 : q = v[nd + 1];
244 :
245 : raid_sse_begin();
246 :
247 268682 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.poly[0]));
248 :
249 4808278 : for (i = 0; i < size; i += 64) {
250 4539596 : asm volatile ("movdqa %0,%%xmm0" : : "m" (v[l][i]));
251 4539596 : asm volatile ("movdqa %0,%%xmm1" : : "m" (v[l][i + 16]));
252 4539596 : asm volatile ("movdqa %0,%%xmm2" : : "m" (v[l][i + 32]));
253 4539596 : asm volatile ("movdqa %0,%%xmm3" : : "m" (v[l][i + 48]));
254 4539596 : asm volatile ("movdqa %xmm0,%xmm4");
255 4539596 : asm volatile ("movdqa %xmm1,%xmm5");
256 4539596 : asm volatile ("movdqa %xmm2,%xmm6");
257 4539596 : asm volatile ("movdqa %xmm3,%xmm7");
258 27721092 : for (d = l - 1; d >= 0; --d) {
259 23181496 : asm volatile ("pxor %xmm8,%xmm8");
260 23181496 : asm volatile ("pxor %xmm9,%xmm9");
261 23181496 : asm volatile ("pxor %xmm10,%xmm10");
262 23181496 : asm volatile ("pxor %xmm11,%xmm11");
263 23181496 : asm volatile ("pcmpgtb %xmm4,%xmm8");
264 23181496 : asm volatile ("pcmpgtb %xmm5,%xmm9");
265 23181496 : asm volatile ("pcmpgtb %xmm6,%xmm10");
266 23181496 : asm volatile ("pcmpgtb %xmm7,%xmm11");
267 23181496 : asm volatile ("paddb %xmm4,%xmm4");
268 23181496 : asm volatile ("paddb %xmm5,%xmm5");
269 23181496 : asm volatile ("paddb %xmm6,%xmm6");
270 23181496 : asm volatile ("paddb %xmm7,%xmm7");
271 23181496 : asm volatile ("pand %xmm15,%xmm8");
272 23181496 : asm volatile ("pand %xmm15,%xmm9");
273 23181496 : asm volatile ("pand %xmm15,%xmm10");
274 23181496 : asm volatile ("pand %xmm15,%xmm11");
275 23181496 : asm volatile ("pxor %xmm8,%xmm4");
276 23181496 : asm volatile ("pxor %xmm9,%xmm5");
277 23181496 : asm volatile ("pxor %xmm10,%xmm6");
278 23181496 : asm volatile ("pxor %xmm11,%xmm7");
279 :
280 23181496 : asm volatile ("movdqa %0,%%xmm8" : : "m" (v[d][i]));
281 23181496 : asm volatile ("movdqa %0,%%xmm9" : : "m" (v[d][i + 16]));
282 23181496 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i + 32]));
283 23181496 : asm volatile ("movdqa %0,%%xmm11" : : "m" (v[d][i + 48]));
284 23181496 : asm volatile ("pxor %xmm8,%xmm0");
285 23181496 : asm volatile ("pxor %xmm9,%xmm1");
286 23181496 : asm volatile ("pxor %xmm10,%xmm2");
287 23181496 : asm volatile ("pxor %xmm11,%xmm3");
288 23181496 : asm volatile ("pxor %xmm8,%xmm4");
289 23181496 : asm volatile ("pxor %xmm9,%xmm5");
290 23181496 : asm volatile ("pxor %xmm10,%xmm6");
291 23181496 : asm volatile ("pxor %xmm11,%xmm7");
292 : }
293 4539596 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
294 4539596 : asm volatile ("movntdq %%xmm1,%0" : "=m" (p[i + 16]));
295 4539596 : asm volatile ("movntdq %%xmm2,%0" : "=m" (p[i + 32]));
296 4539596 : asm volatile ("movntdq %%xmm3,%0" : "=m" (p[i + 48]));
297 4539596 : asm volatile ("movntdq %%xmm4,%0" : "=m" (q[i]));
298 4539596 : asm volatile ("movntdq %%xmm5,%0" : "=m" (q[i + 16]));
299 4539596 : asm volatile ("movntdq %%xmm6,%0" : "=m" (q[i + 32]));
300 4539596 : asm volatile ("movntdq %%xmm7,%0" : "=m" (q[i + 48]));
301 : }
302 :
303 : raid_sse_end();
304 268682 : }
305 : #endif
306 :
307 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
308 : /*
309 : * GEN3 (triple parity with Cauchy matrix) SSSE3 implementation
310 : */
311 10 : void raid_gen3_ssse3(int nd, size_t size, void **vv)
312 : {
313 10 : 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 10 : l = nd - 1;
321 10 : p = v[nd];
322 10 : q = v[nd + 1];
323 10 : r = v[nd + 2];
324 :
325 : /* special case with only one data disk */
326 10 : 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 9 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
336 9 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
337 :
338 131097 : for (i = 0; i < size; i += 16) {
339 : /* last disk without the by two multiplication */
340 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
341 :
342 131088 : asm volatile ("movdqa %xmm4,%xmm0");
343 131088 : asm volatile ("movdqa %xmm4,%xmm1");
344 :
345 131088 : asm volatile ("movdqa %xmm4,%xmm5");
346 131088 : asm volatile ("psrlw $4,%xmm5");
347 131088 : asm volatile ("pand %xmm7,%xmm4");
348 131088 : asm volatile ("pand %xmm7,%xmm5");
349 :
350 131088 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
351 131088 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[l][0][1][0]));
352 131088 : asm volatile ("pshufb %xmm4,%xmm2");
353 131088 : asm volatile ("pshufb %xmm5,%xmm6");
354 131088 : asm volatile ("pxor %xmm6,%xmm2");
355 :
356 : /* intermediate disks */
357 918000 : for (d = l - 1; d > 0; --d) {
358 786912 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
359 :
360 786912 : asm volatile ("pxor %xmm5,%xmm5");
361 786912 : asm volatile ("pcmpgtb %xmm1,%xmm5");
362 786912 : asm volatile ("paddb %xmm1,%xmm1");
363 786912 : asm volatile ("pand %xmm3,%xmm5");
364 786912 : asm volatile ("pxor %xmm5,%xmm1");
365 :
366 786912 : asm volatile ("pxor %xmm4,%xmm0");
367 786912 : asm volatile ("pxor %xmm4,%xmm1");
368 :
369 786912 : asm volatile ("movdqa %xmm4,%xmm5");
370 786912 : asm volatile ("psrlw $4,%xmm5");
371 786912 : asm volatile ("pand %xmm7,%xmm4");
372 786912 : asm volatile ("pand %xmm7,%xmm5");
373 :
374 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
375 786912 : asm volatile ("pshufb %xmm4,%xmm6");
376 786912 : asm volatile ("pxor %xmm6,%xmm2");
377 786912 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][1][0]));
378 786912 : asm volatile ("pshufb %xmm5,%xmm6");
379 786912 : asm volatile ("pxor %xmm6,%xmm2");
380 : }
381 :
382 : /* first disk with all coefficients at 1 */
383 131088 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
384 :
385 131088 : asm volatile ("pxor %xmm5,%xmm5");
386 131088 : asm volatile ("pcmpgtb %xmm1,%xmm5");
387 131088 : asm volatile ("paddb %xmm1,%xmm1");
388 131088 : asm volatile ("pand %xmm3,%xmm5");
389 131088 : asm volatile ("pxor %xmm5,%xmm1");
390 :
391 131088 : asm volatile ("pxor %xmm4,%xmm0");
392 131088 : asm volatile ("pxor %xmm4,%xmm1");
393 131088 : asm volatile ("pxor %xmm4,%xmm2");
394 :
395 131088 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
396 131088 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
397 131088 : 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 28328 : void raid_gen3_ssse3ext(int nd, size_t size, void **vv)
411 : {
412 28328 : 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 28328 : l = nd - 1;
420 28328 : p = v[nd];
421 28328 : q = v[nd + 1];
422 28328 : r = v[nd + 2];
423 :
424 : /* special case with only one data disk */
425 28328 : 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 28327 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfconst16.poly[0]));
435 28327 : asm volatile ("movdqa %0,%%xmm11" : : "m" (gfconst16.low4[0]));
436 :
437 1530447 : for (i = 0; i < size; i += 32) {
438 : /* last disk without the by two multiplication */
439 1502120 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
440 1502120 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
441 :
442 1502120 : asm volatile ("movdqa %xmm4,%xmm0");
443 1502120 : asm volatile ("movdqa %xmm4,%xmm1");
444 1502120 : asm volatile ("movdqa %xmm12,%xmm8");
445 1502120 : asm volatile ("movdqa %xmm12,%xmm9");
446 :
447 1502120 : asm volatile ("movdqa %xmm4,%xmm5");
448 1502120 : asm volatile ("movdqa %xmm12,%xmm13");
449 1502120 : asm volatile ("psrlw $4,%xmm5");
450 1502120 : asm volatile ("psrlw $4,%xmm13");
451 1502120 : asm volatile ("pand %xmm11,%xmm4");
452 1502120 : asm volatile ("pand %xmm11,%xmm12");
453 1502120 : asm volatile ("pand %xmm11,%xmm5");
454 1502120 : asm volatile ("pand %xmm11,%xmm13");
455 :
456 1502120 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
457 1502120 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
458 1502120 : asm volatile ("movdqa %xmm2,%xmm10");
459 1502120 : asm volatile ("movdqa %xmm7,%xmm15");
460 1502120 : asm volatile ("pshufb %xmm4,%xmm2");
461 1502120 : asm volatile ("pshufb %xmm12,%xmm10");
462 1502120 : asm volatile ("pshufb %xmm5,%xmm7");
463 1502120 : asm volatile ("pshufb %xmm13,%xmm15");
464 1502120 : asm volatile ("pxor %xmm7,%xmm2");
465 1502120 : asm volatile ("pxor %xmm15,%xmm10");
466 :
467 : /* intermediate disks */
468 8706840 : for (d = l - 1; d > 0; --d) {
469 7204720 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
470 7204720 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
471 :
472 7204720 : asm volatile ("pxor %xmm5,%xmm5");
473 7204720 : asm volatile ("pxor %xmm13,%xmm13");
474 7204720 : asm volatile ("pcmpgtb %xmm1,%xmm5");
475 7204720 : asm volatile ("pcmpgtb %xmm9,%xmm13");
476 7204720 : asm volatile ("paddb %xmm1,%xmm1");
477 7204720 : asm volatile ("paddb %xmm9,%xmm9");
478 7204720 : asm volatile ("pand %xmm3,%xmm5");
479 7204720 : asm volatile ("pand %xmm3,%xmm13");
480 7204720 : asm volatile ("pxor %xmm5,%xmm1");
481 7204720 : asm volatile ("pxor %xmm13,%xmm9");
482 :
483 7204720 : asm volatile ("pxor %xmm4,%xmm0");
484 7204720 : asm volatile ("pxor %xmm4,%xmm1");
485 7204720 : asm volatile ("pxor %xmm12,%xmm8");
486 7204720 : asm volatile ("pxor %xmm12,%xmm9");
487 :
488 7204720 : asm volatile ("movdqa %xmm4,%xmm5");
489 7204720 : asm volatile ("movdqa %xmm12,%xmm13");
490 7204720 : asm volatile ("psrlw $4,%xmm5");
491 7204720 : asm volatile ("psrlw $4,%xmm13");
492 7204720 : asm volatile ("pand %xmm11,%xmm4");
493 7204720 : asm volatile ("pand %xmm11,%xmm12");
494 7204720 : asm volatile ("pand %xmm11,%xmm5");
495 7204720 : asm volatile ("pand %xmm11,%xmm13");
496 :
497 7204720 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
498 7204720 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
499 7204720 : asm volatile ("movdqa %xmm6,%xmm14");
500 7204720 : asm volatile ("movdqa %xmm7,%xmm15");
501 7204720 : asm volatile ("pshufb %xmm4,%xmm6");
502 7204720 : asm volatile ("pshufb %xmm12,%xmm14");
503 7204720 : asm volatile ("pshufb %xmm5,%xmm7");
504 7204720 : asm volatile ("pshufb %xmm13,%xmm15");
505 7204720 : asm volatile ("pxor %xmm6,%xmm2");
506 7204720 : asm volatile ("pxor %xmm14,%xmm10");
507 7204720 : asm volatile ("pxor %xmm7,%xmm2");
508 7204720 : asm volatile ("pxor %xmm15,%xmm10");
509 : }
510 :
511 : /* first disk with all coefficients at 1 */
512 1502120 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
513 1502120 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
514 :
515 1502120 : asm volatile ("pxor %xmm5,%xmm5");
516 1502120 : asm volatile ("pxor %xmm13,%xmm13");
517 1502120 : asm volatile ("pcmpgtb %xmm1,%xmm5");
518 1502120 : asm volatile ("pcmpgtb %xmm9,%xmm13");
519 1502120 : asm volatile ("paddb %xmm1,%xmm1");
520 1502120 : asm volatile ("paddb %xmm9,%xmm9");
521 1502120 : asm volatile ("pand %xmm3,%xmm5");
522 1502120 : asm volatile ("pand %xmm3,%xmm13");
523 1502120 : asm volatile ("pxor %xmm5,%xmm1");
524 1502120 : asm volatile ("pxor %xmm13,%xmm9");
525 :
526 1502120 : asm volatile ("pxor %xmm4,%xmm0");
527 1502120 : asm volatile ("pxor %xmm4,%xmm1");
528 1502120 : asm volatile ("pxor %xmm4,%xmm2");
529 1502120 : asm volatile ("pxor %xmm12,%xmm8");
530 1502120 : asm volatile ("pxor %xmm12,%xmm9");
531 1502120 : asm volatile ("pxor %xmm12,%xmm10");
532 :
533 1502120 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
534 1502120 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
535 1502120 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
536 1502120 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
537 1502120 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
538 1502120 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
539 : }
540 :
541 : raid_sse_end();
542 : }
543 : #endif
544 :
545 : #if defined(CONFIG_X86_64) && defined(CONFIG_AVX2)
546 : /*
547 : * GEN3 (triple parity with Cauchy matrix) AVX2 implementation
548 : *
549 : * Note that it uses 16 registers, meaning that x64 is required.
550 : */
551 1154 : void raid_gen3_avx2ext(int nd, size_t size, void **vv)
552 : {
553 1154 : uint8_t **v = (uint8_t **)vv;
554 : uint8_t *p;
555 : uint8_t *q;
556 : uint8_t *r;
557 : int d, l;
558 : size_t i;
559 :
560 1154 : l = nd - 1;
561 1154 : p = v[nd];
562 1154 : q = v[nd + 1];
563 1154 : r = v[nd + 2];
564 :
565 : /* special case with only one data disk */
566 1154 : if (l == 0) {
567 4 : for (i = 0; i < 3; ++i)
568 3 : memcpy(v[1 + i], v[0], size);
569 1 : return;
570 : }
571 :
572 : raid_avx_begin();
573 :
574 : /* generic case with at least two data disks */
575 1153 : asm volatile ("vbroadcasti128 %0, %%ymm3" : : "m" (gfconst16.poly[0]));
576 1153 : asm volatile ("vbroadcasti128 %0, %%ymm11" : : "m" (gfconst16.low4[0]));
577 :
578 210965 : for (i = 0; i < size; i += 64) {
579 : /* last disk without the by two multiplication */
580 209812 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[l][i]));
581 209812 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[l][i + 32]));
582 :
583 209812 : asm volatile ("vmovdqa %ymm4,%ymm0");
584 209812 : asm volatile ("vmovdqa %ymm4,%ymm1");
585 209812 : asm volatile ("vmovdqa %ymm12,%ymm8");
586 209812 : asm volatile ("vmovdqa %ymm12,%ymm9");
587 :
588 209812 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
589 209812 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
590 209812 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
591 209812 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
592 209812 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
593 209812 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
594 :
595 209812 : asm volatile ("vbroadcasti128 %0,%%ymm10" : : "m" (gfgenpshufb[l][0][0][0]));
596 209812 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[l][0][1][0]));
597 209812 : asm volatile ("vpshufb %ymm4,%ymm10,%ymm2");
598 209812 : asm volatile ("vpshufb %ymm12,%ymm10,%ymm10");
599 209812 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
600 209812 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
601 209812 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
602 209812 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
603 :
604 : /* intermediate disks */
605 1491372 : for (d = l - 1; d > 0; --d) {
606 1281560 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[d][i]));
607 1281560 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[d][i + 32]));
608 :
609 1281560 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
610 1281560 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
611 1281560 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
612 1281560 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
613 1281560 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
614 1281560 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
615 1281560 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
616 1281560 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
617 1281560 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
618 1281560 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
619 :
620 1281560 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
621 1281560 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
622 1281560 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
623 1281560 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
624 :
625 1281560 : asm volatile ("vpsrlw $4,%ymm4,%ymm5");
626 1281560 : asm volatile ("vpsrlw $4,%ymm12,%ymm13");
627 1281560 : asm volatile ("vpand %ymm11,%ymm4,%ymm4");
628 1281560 : asm volatile ("vpand %ymm11,%ymm12,%ymm12");
629 1281560 : asm volatile ("vpand %ymm11,%ymm5,%ymm5");
630 1281560 : asm volatile ("vpand %ymm11,%ymm13,%ymm13");
631 :
632 1281560 : asm volatile ("vbroadcasti128 %0,%%ymm14" : : "m" (gfgenpshufb[d][0][0][0]));
633 1281560 : asm volatile ("vbroadcasti128 %0,%%ymm15" : : "m" (gfgenpshufb[d][0][1][0]));
634 1281560 : asm volatile ("vpshufb %ymm4,%ymm14,%ymm6");
635 1281560 : asm volatile ("vpshufb %ymm12,%ymm14,%ymm14");
636 1281560 : asm volatile ("vpshufb %ymm5,%ymm15,%ymm7");
637 1281560 : asm volatile ("vpshufb %ymm13,%ymm15,%ymm15");
638 1281560 : asm volatile ("vpxor %ymm6,%ymm2,%ymm2");
639 1281560 : asm volatile ("vpxor %ymm14,%ymm10,%ymm10");
640 1281560 : asm volatile ("vpxor %ymm7,%ymm2,%ymm2");
641 1281560 : asm volatile ("vpxor %ymm15,%ymm10,%ymm10");
642 : }
643 :
644 : /* first disk with all coefficients at 1 */
645 209812 : asm volatile ("vmovdqa %0,%%ymm4" : : "m" (v[0][i]));
646 209812 : asm volatile ("vmovdqa %0,%%ymm12" : : "m" (v[0][i + 32]));
647 :
648 209812 : asm volatile ("vpxor %ymm5,%ymm5,%ymm5");
649 209812 : asm volatile ("vpxor %ymm13,%ymm13,%ymm13");
650 209812 : asm volatile ("vpcmpgtb %ymm1,%ymm5,%ymm5");
651 209812 : asm volatile ("vpcmpgtb %ymm9,%ymm13,%ymm13");
652 209812 : asm volatile ("vpaddb %ymm1,%ymm1,%ymm1");
653 209812 : asm volatile ("vpaddb %ymm9,%ymm9,%ymm9");
654 209812 : asm volatile ("vpand %ymm3,%ymm5,%ymm5");
655 209812 : asm volatile ("vpand %ymm3,%ymm13,%ymm13");
656 209812 : asm volatile ("vpxor %ymm5,%ymm1,%ymm1");
657 209812 : asm volatile ("vpxor %ymm13,%ymm9,%ymm9");
658 :
659 209812 : asm volatile ("vpxor %ymm4,%ymm0,%ymm0");
660 209812 : asm volatile ("vpxor %ymm4,%ymm1,%ymm1");
661 209812 : asm volatile ("vpxor %ymm4,%ymm2,%ymm2");
662 209812 : asm volatile ("vpxor %ymm12,%ymm8,%ymm8");
663 209812 : asm volatile ("vpxor %ymm12,%ymm9,%ymm9");
664 209812 : asm volatile ("vpxor %ymm12,%ymm10,%ymm10");
665 :
666 209812 : asm volatile ("vmovntdq %%ymm0,%0" : "=m" (p[i]));
667 209812 : asm volatile ("vmovntdq %%ymm8,%0" : "=m" (p[i + 32]));
668 209812 : asm volatile ("vmovntdq %%ymm1,%0" : "=m" (q[i]));
669 209812 : asm volatile ("vmovntdq %%ymm9,%0" : "=m" (q[i + 32]));
670 209812 : asm volatile ("vmovntdq %%ymm2,%0" : "=m" (r[i]));
671 209812 : asm volatile ("vmovntdq %%ymm10,%0" : "=m" (r[i + 32]));
672 : }
673 :
674 : raid_avx_end();
675 : }
676 : #endif
677 :
678 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
679 : /*
680 : * GEN4 (quad parity with Cauchy matrix) SSSE3 implementation
681 : */
682 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 28319 : void raid_gen4_ssse3ext(int nd, size_t size, void **vv)
801 : {
802 28319 : 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 28319 : l = nd - 1;
811 28319 : p = v[nd];
812 28319 : q = v[nd + 1];
813 28319 : r = v[nd + 2];
814 28319 : s = v[nd + 3];
815 :
816 : /* special case with only one data disk */
817 28319 : 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 1244550 : for (i = 0; i < size; i += 32) {
827 : /* last disk without the by two multiplication */
828 1216232 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
829 1216232 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
830 1216232 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[l][i + 16]));
831 :
832 1216232 : asm volatile ("movdqa %xmm4,%xmm0");
833 1216232 : asm volatile ("movdqa %xmm4,%xmm1");
834 1216232 : asm volatile ("movdqa %xmm12,%xmm8");
835 1216232 : asm volatile ("movdqa %xmm12,%xmm9");
836 :
837 1216232 : asm volatile ("movdqa %xmm4,%xmm5");
838 1216232 : asm volatile ("movdqa %xmm12,%xmm13");
839 1216232 : asm volatile ("psrlw $4,%xmm5");
840 1216232 : asm volatile ("psrlw $4,%xmm13");
841 1216232 : asm volatile ("pand %xmm15,%xmm4");
842 1216232 : asm volatile ("pand %xmm15,%xmm12");
843 1216232 : asm volatile ("pand %xmm15,%xmm5");
844 1216232 : asm volatile ("pand %xmm15,%xmm13");
845 :
846 1216232 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
847 1216232 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
848 1216232 : asm volatile ("movdqa %xmm2,%xmm10");
849 1216232 : asm volatile ("movdqa %xmm7,%xmm15");
850 1216232 : asm volatile ("pshufb %xmm4,%xmm2");
851 1216232 : asm volatile ("pshufb %xmm12,%xmm10");
852 1216232 : asm volatile ("pshufb %xmm5,%xmm7");
853 1216232 : asm volatile ("pshufb %xmm13,%xmm15");
854 1216232 : asm volatile ("pxor %xmm7,%xmm2");
855 1216232 : asm volatile ("pxor %xmm15,%xmm10");
856 :
857 1216232 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
858 1216232 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
859 1216232 : asm volatile ("movdqa %xmm3,%xmm11");
860 1216232 : asm volatile ("movdqa %xmm7,%xmm15");
861 1216232 : asm volatile ("pshufb %xmm4,%xmm3");
862 1216232 : asm volatile ("pshufb %xmm12,%xmm11");
863 1216232 : asm volatile ("pshufb %xmm5,%xmm7");
864 1216232 : asm volatile ("pshufb %xmm13,%xmm15");
865 1216232 : asm volatile ("pxor %xmm7,%xmm3");
866 1216232 : asm volatile ("pxor %xmm15,%xmm11");
867 :
868 : /* intermediate disks */
869 6703960 : for (d = l - 1; d > 0; --d) {
870 5487728 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
871 5487728 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
872 5487728 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
873 5487728 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[d][i + 16]));
874 :
875 5487728 : asm volatile ("pxor %xmm5,%xmm5");
876 5487728 : asm volatile ("pxor %xmm13,%xmm13");
877 5487728 : asm volatile ("pcmpgtb %xmm1,%xmm5");
878 5487728 : asm volatile ("pcmpgtb %xmm9,%xmm13");
879 5487728 : asm volatile ("paddb %xmm1,%xmm1");
880 5487728 : asm volatile ("paddb %xmm9,%xmm9");
881 5487728 : asm volatile ("pand %xmm7,%xmm5");
882 5487728 : asm volatile ("pand %xmm7,%xmm13");
883 5487728 : asm volatile ("pxor %xmm5,%xmm1");
884 5487728 : asm volatile ("pxor %xmm13,%xmm9");
885 :
886 5487728 : asm volatile ("pxor %xmm4,%xmm0");
887 5487728 : asm volatile ("pxor %xmm4,%xmm1");
888 5487728 : asm volatile ("pxor %xmm12,%xmm8");
889 5487728 : asm volatile ("pxor %xmm12,%xmm9");
890 :
891 5487728 : asm volatile ("movdqa %xmm4,%xmm5");
892 5487728 : asm volatile ("movdqa %xmm12,%xmm13");
893 5487728 : asm volatile ("psrlw $4,%xmm5");
894 5487728 : asm volatile ("psrlw $4,%xmm13");
895 5487728 : asm volatile ("pand %xmm15,%xmm4");
896 5487728 : asm volatile ("pand %xmm15,%xmm12");
897 5487728 : asm volatile ("pand %xmm15,%xmm5");
898 5487728 : asm volatile ("pand %xmm15,%xmm13");
899 :
900 5487728 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
901 5487728 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
902 5487728 : asm volatile ("movdqa %xmm6,%xmm14");
903 5487728 : asm volatile ("movdqa %xmm7,%xmm15");
904 5487728 : asm volatile ("pshufb %xmm4,%xmm6");
905 5487728 : asm volatile ("pshufb %xmm12,%xmm14");
906 5487728 : asm volatile ("pshufb %xmm5,%xmm7");
907 5487728 : asm volatile ("pshufb %xmm13,%xmm15");
908 5487728 : asm volatile ("pxor %xmm6,%xmm2");
909 5487728 : asm volatile ("pxor %xmm14,%xmm10");
910 5487728 : asm volatile ("pxor %xmm7,%xmm2");
911 5487728 : asm volatile ("pxor %xmm15,%xmm10");
912 :
913 5487728 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
914 5487728 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
915 5487728 : asm volatile ("movdqa %xmm6,%xmm14");
916 5487728 : asm volatile ("movdqa %xmm7,%xmm15");
917 5487728 : asm volatile ("pshufb %xmm4,%xmm6");
918 5487728 : asm volatile ("pshufb %xmm12,%xmm14");
919 5487728 : asm volatile ("pshufb %xmm5,%xmm7");
920 5487728 : asm volatile ("pshufb %xmm13,%xmm15");
921 5487728 : asm volatile ("pxor %xmm6,%xmm3");
922 5487728 : asm volatile ("pxor %xmm14,%xmm11");
923 5487728 : asm volatile ("pxor %xmm7,%xmm3");
924 5487728 : asm volatile ("pxor %xmm15,%xmm11");
925 : }
926 :
927 : /* first disk with all coefficients at 1 */
928 1216232 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
929 1216232 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
930 1216232 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
931 1216232 : asm volatile ("movdqa %0,%%xmm12" : : "m" (v[0][i + 16]));
932 :
933 1216232 : asm volatile ("pxor %xmm5,%xmm5");
934 1216232 : asm volatile ("pxor %xmm13,%xmm13");
935 1216232 : asm volatile ("pcmpgtb %xmm1,%xmm5");
936 1216232 : asm volatile ("pcmpgtb %xmm9,%xmm13");
937 1216232 : asm volatile ("paddb %xmm1,%xmm1");
938 1216232 : asm volatile ("paddb %xmm9,%xmm9");
939 1216232 : asm volatile ("pand %xmm7,%xmm5");
940 1216232 : asm volatile ("pand %xmm7,%xmm13");
941 1216232 : asm volatile ("pxor %xmm5,%xmm1");
942 1216232 : asm volatile ("pxor %xmm13,%xmm9");
943 :
944 1216232 : asm volatile ("pxor %xmm4,%xmm0");
945 1216232 : asm volatile ("pxor %xmm4,%xmm1");
946 1216232 : asm volatile ("pxor %xmm4,%xmm2");
947 1216232 : asm volatile ("pxor %xmm4,%xmm3");
948 1216232 : asm volatile ("pxor %xmm12,%xmm8");
949 1216232 : asm volatile ("pxor %xmm12,%xmm9");
950 1216232 : asm volatile ("pxor %xmm12,%xmm10");
951 1216232 : asm volatile ("pxor %xmm12,%xmm11");
952 :
953 1216232 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
954 1216232 : asm volatile ("movntdq %%xmm8,%0" : "=m" (p[i + 16]));
955 1216232 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
956 1216232 : asm volatile ("movntdq %%xmm9,%0" : "=m" (q[i + 16]));
957 1216232 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
958 1216232 : asm volatile ("movntdq %%xmm10,%0" : "=m" (r[i + 16]));
959 1216232 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
960 1216232 : 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 8 : void raid_gen5_ssse3(int nd, size_t size, void **vv)
1133 : {
1134 8 : 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 8 : uint8_t *pd = __align_ptr(buffer, 16);
1144 :
1145 8 : l = nd - 1;
1146 8 : p = v[nd];
1147 8 : q = v[nd + 1];
1148 8 : r = v[nd + 2];
1149 8 : s = v[nd + 3];
1150 8 : t = v[nd + 4];
1151 :
1152 : /* special case with only one data disk */
1153 8 : 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 98327 : for (i = 0; i < size; i += 16) {
1163 : /* last disk without the by two multiplication */
1164 98320 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i]));
1165 :
1166 98320 : asm volatile ("movdqa %xmm4,%xmm0");
1167 98320 : asm volatile ("movdqa %%xmm4,%0" : "=m" (pd[0]));
1168 :
1169 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1170 98320 : asm volatile ("movdqa %xmm4,%xmm5");
1171 98320 : asm volatile ("psrlw $4,%xmm5");
1172 98320 : asm volatile ("pand %xmm7,%xmm4");
1173 98320 : asm volatile ("pand %xmm7,%xmm5");
1174 :
1175 98320 : asm volatile ("movdqa %0,%%xmm1" : : "m" (gfgenpshufb[l][0][0][0]));
1176 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][0][1][0]));
1177 98320 : asm volatile ("pshufb %xmm4,%xmm1");
1178 98320 : asm volatile ("pshufb %xmm5,%xmm7");
1179 98320 : asm volatile ("pxor %xmm7,%xmm1");
1180 :
1181 98320 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][1][0][0]));
1182 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][1][1][0]));
1183 98320 : asm volatile ("pshufb %xmm4,%xmm2");
1184 98320 : asm volatile ("pshufb %xmm5,%xmm7");
1185 98320 : asm volatile ("pxor %xmm7,%xmm2");
1186 :
1187 98320 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][2][0][0]));
1188 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[l][2][1][0]));
1189 98320 : asm volatile ("pshufb %xmm4,%xmm3");
1190 98320 : asm volatile ("pshufb %xmm5,%xmm7");
1191 98320 : asm volatile ("pxor %xmm7,%xmm3");
1192 :
1193 : /* intermediate disks */
1194 688624 : for (d = l - 1; d > 0; --d) {
1195 590304 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[d][i]));
1196 590304 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1197 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1198 :
1199 590304 : asm volatile ("pxor %xmm5,%xmm5");
1200 590304 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1201 590304 : asm volatile ("paddb %xmm0,%xmm0");
1202 590304 : asm volatile ("pand %xmm7,%xmm5");
1203 590304 : asm volatile ("pxor %xmm5,%xmm0");
1204 :
1205 590304 : asm volatile ("pxor %xmm4,%xmm0");
1206 590304 : asm volatile ("pxor %xmm4,%xmm6");
1207 590304 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pd[0]));
1208 :
1209 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
1210 590304 : asm volatile ("movdqa %xmm4,%xmm5");
1211 590304 : asm volatile ("psrlw $4,%xmm5");
1212 590304 : asm volatile ("pand %xmm7,%xmm4");
1213 590304 : asm volatile ("pand %xmm7,%xmm5");
1214 :
1215 590304 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][0][0][0]));
1216 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][0][1][0]));
1217 590304 : asm volatile ("pshufb %xmm4,%xmm6");
1218 590304 : asm volatile ("pshufb %xmm5,%xmm7");
1219 590304 : asm volatile ("pxor %xmm6,%xmm1");
1220 590304 : asm volatile ("pxor %xmm7,%xmm1");
1221 :
1222 590304 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][1][0][0]));
1223 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][1][1][0]));
1224 590304 : asm volatile ("pshufb %xmm4,%xmm6");
1225 590304 : asm volatile ("pshufb %xmm5,%xmm7");
1226 590304 : asm volatile ("pxor %xmm6,%xmm2");
1227 590304 : asm volatile ("pxor %xmm7,%xmm2");
1228 :
1229 590304 : asm volatile ("movdqa %0,%%xmm6" : : "m" (gfgenpshufb[d][2][0][0]));
1230 590304 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfgenpshufb[d][2][1][0]));
1231 590304 : asm volatile ("pshufb %xmm4,%xmm6");
1232 590304 : asm volatile ("pshufb %xmm5,%xmm7");
1233 590304 : asm volatile ("pxor %xmm6,%xmm3");
1234 590304 : asm volatile ("pxor %xmm7,%xmm3");
1235 : }
1236 :
1237 : /* first disk with all coefficients at 1 */
1238 98320 : asm volatile ("movdqa %0,%%xmm4" : : "m" (v[0][i]));
1239 98320 : asm volatile ("movdqa %0,%%xmm6" : : "m" (pd[0]));
1240 98320 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.poly[0]));
1241 :
1242 98320 : asm volatile ("pxor %xmm5,%xmm5");
1243 98320 : asm volatile ("pcmpgtb %xmm0,%xmm5");
1244 98320 : asm volatile ("paddb %xmm0,%xmm0");
1245 98320 : asm volatile ("pand %xmm7,%xmm5");
1246 98320 : asm volatile ("pxor %xmm5,%xmm0");
1247 :
1248 98320 : asm volatile ("pxor %xmm4,%xmm0");
1249 98320 : asm volatile ("pxor %xmm4,%xmm1");
1250 98320 : asm volatile ("pxor %xmm4,%xmm2");
1251 98320 : asm volatile ("pxor %xmm4,%xmm3");
1252 98320 : asm volatile ("pxor %xmm4,%xmm6");
1253 :
1254 98320 : asm volatile ("movntdq %%xmm6,%0" : "=m" (p[i]));
1255 98320 : asm volatile ("movntdq %%xmm0,%0" : "=m" (q[i]));
1256 98320 : asm volatile ("movntdq %%xmm1,%0" : "=m" (r[i]));
1257 98320 : asm volatile ("movntdq %%xmm2,%0" : "=m" (s[i]));
1258 98320 : 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 37504 : void raid_gen5_ssse3ext(int nd, size_t size, void **vv)
1272 : {
1273 37504 : 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 37504 : l = nd - 1;
1283 37504 : p = v[nd];
1284 37504 : q = v[nd + 1];
1285 37504 : r = v[nd + 2];
1286 37504 : s = v[nd + 3];
1287 37504 : t = v[nd + 4];
1288 :
1289 : /* special case with only one data disk */
1290 37504 : 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 37503 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1300 37503 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1301 :
1302 3057807 : for (i = 0; i < size; i += 16) {
1303 : /* last disk without the by two multiplication */
1304 3020304 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1305 :
1306 3020304 : asm volatile ("movdqa %xmm10,%xmm0");
1307 3020304 : asm volatile ("movdqa %xmm10,%xmm1");
1308 :
1309 3020304 : asm volatile ("movdqa %xmm10,%xmm11");
1310 3020304 : asm volatile ("psrlw $4,%xmm11");
1311 3020304 : asm volatile ("pand %xmm15,%xmm10");
1312 3020304 : asm volatile ("pand %xmm15,%xmm11");
1313 :
1314 3020304 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1315 3020304 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1316 3020304 : asm volatile ("pshufb %xmm10,%xmm2");
1317 3020304 : asm volatile ("pshufb %xmm11,%xmm13");
1318 3020304 : asm volatile ("pxor %xmm13,%xmm2");
1319 :
1320 3020304 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1321 3020304 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1322 3020304 : asm volatile ("pshufb %xmm10,%xmm3");
1323 3020304 : asm volatile ("pshufb %xmm11,%xmm13");
1324 3020304 : asm volatile ("pxor %xmm13,%xmm3");
1325 :
1326 3020304 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1327 3020304 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1328 3020304 : asm volatile ("pshufb %xmm10,%xmm4");
1329 3020304 : asm volatile ("pshufb %xmm11,%xmm13");
1330 3020304 : asm volatile ("pxor %xmm13,%xmm4");
1331 :
1332 : /* intermediate disks */
1333 16347120 : for (d = l - 1; d > 0; --d) {
1334 13326816 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1335 :
1336 13326816 : asm volatile ("pxor %xmm11,%xmm11");
1337 13326816 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1338 13326816 : asm volatile ("paddb %xmm1,%xmm1");
1339 13326816 : asm volatile ("pand %xmm14,%xmm11");
1340 13326816 : asm volatile ("pxor %xmm11,%xmm1");
1341 :
1342 13326816 : asm volatile ("pxor %xmm10,%xmm0");
1343 13326816 : asm volatile ("pxor %xmm10,%xmm1");
1344 :
1345 13326816 : asm volatile ("movdqa %xmm10,%xmm11");
1346 13326816 : asm volatile ("psrlw $4,%xmm11");
1347 13326816 : asm volatile ("pand %xmm15,%xmm10");
1348 13326816 : asm volatile ("pand %xmm15,%xmm11");
1349 :
1350 13326816 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1351 13326816 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1352 13326816 : asm volatile ("pshufb %xmm10,%xmm12");
1353 13326816 : asm volatile ("pshufb %xmm11,%xmm13");
1354 13326816 : asm volatile ("pxor %xmm12,%xmm2");
1355 13326816 : asm volatile ("pxor %xmm13,%xmm2");
1356 :
1357 13326816 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1358 13326816 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1359 13326816 : asm volatile ("pshufb %xmm10,%xmm12");
1360 13326816 : asm volatile ("pshufb %xmm11,%xmm13");
1361 13326816 : asm volatile ("pxor %xmm12,%xmm3");
1362 13326816 : asm volatile ("pxor %xmm13,%xmm3");
1363 :
1364 13326816 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1365 13326816 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1366 13326816 : asm volatile ("pshufb %xmm10,%xmm12");
1367 13326816 : asm volatile ("pshufb %xmm11,%xmm13");
1368 13326816 : asm volatile ("pxor %xmm12,%xmm4");
1369 13326816 : asm volatile ("pxor %xmm13,%xmm4");
1370 : }
1371 :
1372 : /* first disk with all coefficients at 1 */
1373 3020304 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1374 :
1375 3020304 : asm volatile ("pxor %xmm11,%xmm11");
1376 3020304 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1377 3020304 : asm volatile ("paddb %xmm1,%xmm1");
1378 3020304 : asm volatile ("pand %xmm14,%xmm11");
1379 3020304 : asm volatile ("pxor %xmm11,%xmm1");
1380 :
1381 3020304 : asm volatile ("pxor %xmm10,%xmm0");
1382 3020304 : asm volatile ("pxor %xmm10,%xmm1");
1383 3020304 : asm volatile ("pxor %xmm10,%xmm2");
1384 3020304 : asm volatile ("pxor %xmm10,%xmm3");
1385 3020304 : asm volatile ("pxor %xmm10,%xmm4");
1386 :
1387 3020304 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1388 3020304 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1389 3020304 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1390 3020304 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1391 3020304 : 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 526432 : void raid_gen6_ssse3ext(int nd, size_t size, void **vv)
1693 : {
1694 526432 : 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 526432 : l = nd - 1;
1705 526432 : p = v[nd];
1706 526432 : q = v[nd + 1];
1707 526432 : r = v[nd + 2];
1708 526432 : s = v[nd + 3];
1709 526432 : t = v[nd + 4];
1710 526432 : u = v[nd + 5];
1711 :
1712 : /* special case with only one data disk */
1713 526432 : 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 526431 : asm volatile ("movdqa %0,%%xmm14" : : "m" (gfconst16.poly[0]));
1723 526431 : asm volatile ("movdqa %0,%%xmm15" : : "m" (gfconst16.low4[0]));
1724 :
1725 34805487 : for (i = 0; i < size; i += 16) {
1726 : /* last disk without the by two multiplication */
1727 34279056 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[l][i]));
1728 :
1729 34279056 : asm volatile ("movdqa %xmm10,%xmm0");
1730 34279056 : asm volatile ("movdqa %xmm10,%xmm1");
1731 :
1732 34279056 : asm volatile ("movdqa %xmm10,%xmm11");
1733 34279056 : asm volatile ("psrlw $4,%xmm11");
1734 34279056 : asm volatile ("pand %xmm15,%xmm10");
1735 34279056 : asm volatile ("pand %xmm15,%xmm11");
1736 :
1737 34279056 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfgenpshufb[l][0][0][0]));
1738 34279056 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][0][1][0]));
1739 34279056 : asm volatile ("pshufb %xmm10,%xmm2");
1740 34279056 : asm volatile ("pshufb %xmm11,%xmm13");
1741 34279056 : asm volatile ("pxor %xmm13,%xmm2");
1742 :
1743 34279056 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfgenpshufb[l][1][0][0]));
1744 34279056 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][1][1][0]));
1745 34279056 : asm volatile ("pshufb %xmm10,%xmm3");
1746 34279056 : asm volatile ("pshufb %xmm11,%xmm13");
1747 34279056 : asm volatile ("pxor %xmm13,%xmm3");
1748 :
1749 34279056 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfgenpshufb[l][2][0][0]));
1750 34279056 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][2][1][0]));
1751 34279056 : asm volatile ("pshufb %xmm10,%xmm4");
1752 34279056 : asm volatile ("pshufb %xmm11,%xmm13");
1753 34279056 : asm volatile ("pxor %xmm13,%xmm4");
1754 :
1755 34279056 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfgenpshufb[l][3][0][0]));
1756 34279056 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[l][3][1][0]));
1757 34279056 : asm volatile ("pshufb %xmm10,%xmm5");
1758 34279056 : asm volatile ("pshufb %xmm11,%xmm13");
1759 34279056 : asm volatile ("pxor %xmm13,%xmm5");
1760 :
1761 : /* intermediate disks */
1762 172575344 : for (d = l - 1; d > 0; --d) {
1763 138296288 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[d][i]));
1764 :
1765 138296288 : asm volatile ("pxor %xmm11,%xmm11");
1766 138296288 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1767 138296288 : asm volatile ("paddb %xmm1,%xmm1");
1768 138296288 : asm volatile ("pand %xmm14,%xmm11");
1769 138296288 : asm volatile ("pxor %xmm11,%xmm1");
1770 :
1771 138296288 : asm volatile ("pxor %xmm10,%xmm0");
1772 138296288 : asm volatile ("pxor %xmm10,%xmm1");
1773 :
1774 138296288 : asm volatile ("movdqa %xmm10,%xmm11");
1775 138296288 : asm volatile ("psrlw $4,%xmm11");
1776 138296288 : asm volatile ("pand %xmm15,%xmm10");
1777 138296288 : asm volatile ("pand %xmm15,%xmm11");
1778 :
1779 138296288 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][0][0][0]));
1780 138296288 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][0][1][0]));
1781 138296288 : asm volatile ("pshufb %xmm10,%xmm12");
1782 138296288 : asm volatile ("pshufb %xmm11,%xmm13");
1783 138296288 : asm volatile ("pxor %xmm12,%xmm2");
1784 138296288 : asm volatile ("pxor %xmm13,%xmm2");
1785 :
1786 138296288 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][1][0][0]));
1787 138296288 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][1][1][0]));
1788 138296288 : asm volatile ("pshufb %xmm10,%xmm12");
1789 138296288 : asm volatile ("pshufb %xmm11,%xmm13");
1790 138296288 : asm volatile ("pxor %xmm12,%xmm3");
1791 138296288 : asm volatile ("pxor %xmm13,%xmm3");
1792 :
1793 138296288 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][2][0][0]));
1794 138296288 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][2][1][0]));
1795 138296288 : asm volatile ("pshufb %xmm10,%xmm12");
1796 138296288 : asm volatile ("pshufb %xmm11,%xmm13");
1797 138296288 : asm volatile ("pxor %xmm12,%xmm4");
1798 138296288 : asm volatile ("pxor %xmm13,%xmm4");
1799 :
1800 138296288 : asm volatile ("movdqa %0,%%xmm12" : : "m" (gfgenpshufb[d][3][0][0]));
1801 138296288 : asm volatile ("movdqa %0,%%xmm13" : : "m" (gfgenpshufb[d][3][1][0]));
1802 138296288 : asm volatile ("pshufb %xmm10,%xmm12");
1803 138296288 : asm volatile ("pshufb %xmm11,%xmm13");
1804 138296288 : asm volatile ("pxor %xmm12,%xmm5");
1805 138296288 : asm volatile ("pxor %xmm13,%xmm5");
1806 : }
1807 :
1808 : /* first disk with all coefficients at 1 */
1809 34279056 : asm volatile ("movdqa %0,%%xmm10" : : "m" (v[0][i]));
1810 :
1811 34279056 : asm volatile ("pxor %xmm11,%xmm11");
1812 34279056 : asm volatile ("pcmpgtb %xmm1,%xmm11");
1813 34279056 : asm volatile ("paddb %xmm1,%xmm1");
1814 34279056 : asm volatile ("pand %xmm14,%xmm11");
1815 34279056 : asm volatile ("pxor %xmm11,%xmm1");
1816 :
1817 34279056 : asm volatile ("pxor %xmm10,%xmm0");
1818 34279056 : asm volatile ("pxor %xmm10,%xmm1");
1819 34279056 : asm volatile ("pxor %xmm10,%xmm2");
1820 34279056 : asm volatile ("pxor %xmm10,%xmm3");
1821 34279056 : asm volatile ("pxor %xmm10,%xmm4");
1822 34279056 : asm volatile ("pxor %xmm10,%xmm5");
1823 :
1824 34279056 : asm volatile ("movntdq %%xmm0,%0" : "=m" (p[i]));
1825 34279056 : asm volatile ("movntdq %%xmm1,%0" : "=m" (q[i]));
1826 34279056 : asm volatile ("movntdq %%xmm2,%0" : "=m" (r[i]));
1827 34279056 : asm volatile ("movntdq %%xmm3,%0" : "=m" (s[i]));
1828 34279056 : asm volatile ("movntdq %%xmm4,%0" : "=m" (t[i]));
1829 34279056 : 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 106618 : void raid_rec1_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
1988 : {
1989 106618 : 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 106618 : if (ip[0] == 0) {
2000 96721 : raid_rec1of1(id, nd, size, vv);
2001 96721 : return;
2002 : }
2003 :
2004 : /* setup the coefficients matrix */
2005 9897 : G = A(ip[0], id[0]);
2006 :
2007 : /* invert it to solve the system of linear equations */
2008 9897 : V = inv(G);
2009 :
2010 : /* compute delta parity */
2011 9897 : raid_delta_gen(1, id, ip, nd, size, vv);
2012 :
2013 9897 : p = v[nd + ip[0]];
2014 9897 : pa = v[id[0]];
2015 :
2016 : raid_sse_begin();
2017 :
2018 9897 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2019 9897 : asm volatile ("movdqa %0,%%xmm4" : : "m" (gfmulpshufb[V][0][0]));
2020 9897 : asm volatile ("movdqa %0,%%xmm5" : : "m" (gfmulpshufb[V][1][0]));
2021 :
2022 1030953 : for (i = 0; i < size; i += 16) {
2023 1021056 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[i]));
2024 1021056 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[i]));
2025 1021056 : asm volatile ("movdqa %xmm4,%xmm2");
2026 1021056 : asm volatile ("movdqa %xmm5,%xmm3");
2027 1021056 : asm volatile ("pxor %xmm0,%xmm1");
2028 1021056 : asm volatile ("movdqa %xmm1,%xmm0");
2029 1021056 : asm volatile ("psrlw $4,%xmm1");
2030 1021056 : asm volatile ("pand %xmm7,%xmm0");
2031 1021056 : asm volatile ("pand %xmm7,%xmm1");
2032 1021056 : asm volatile ("pshufb %xmm0,%xmm2");
2033 1021056 : asm volatile ("pshufb %xmm1,%xmm3");
2034 1021056 : asm volatile ("pxor %xmm3,%xmm2");
2035 1021056 : 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 44116 : void raid_rec2_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2047 44116 : {
2048 44116 : uint8_t **v = (uint8_t **)vv;
2049 44116 : const int N = 2;
2050 44116 : uint8_t *p[N];
2051 44116 : uint8_t *pa[N];
2052 44116 : uint8_t G[N * N];
2053 44116 : 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 132348 : for (j = 0; j < N; ++j)
2061 264696 : for (k = 0; k < N; ++k)
2062 352928 : G[j * N + k] = A(ip[j], id[k]);
2063 :
2064 : /* invert it to solve the system of linear equations */
2065 44116 : raid_invert(G, V, N);
2066 :
2067 : /* compute delta parity */
2068 44116 : raid_delta_gen(N, id, ip, nd, size, vv);
2069 :
2070 132348 : for (j = 0; j < N; ++j) {
2071 88232 : p[j] = v[nd + ip[j]];
2072 88232 : pa[j] = v[id[j]];
2073 : }
2074 :
2075 : raid_sse_begin();
2076 :
2077 44116 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2078 :
2079 3202196 : for (i = 0; i < size; i += 16) {
2080 3158080 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[0][i]));
2081 3158080 : asm volatile ("movdqa %0,%%xmm2" : : "m" (pa[0][i]));
2082 3158080 : asm volatile ("movdqa %0,%%xmm1" : : "m" (p[1][i]));
2083 3158080 : asm volatile ("movdqa %0,%%xmm3" : : "m" (pa[1][i]));
2084 3158080 : asm volatile ("pxor %xmm2,%xmm0");
2085 3158080 : asm volatile ("pxor %xmm3,%xmm1");
2086 :
2087 3158080 : asm volatile ("pxor %xmm6,%xmm6");
2088 :
2089 3158080 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[0]][0][0]));
2090 3158080 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[0]][1][0]));
2091 3158080 : asm volatile ("movdqa %xmm0,%xmm4");
2092 3158080 : asm volatile ("movdqa %xmm0,%xmm5");
2093 3158080 : asm volatile ("psrlw $4,%xmm5");
2094 3158080 : asm volatile ("pand %xmm7,%xmm4");
2095 3158080 : asm volatile ("pand %xmm7,%xmm5");
2096 3158080 : asm volatile ("pshufb %xmm4,%xmm2");
2097 3158080 : asm volatile ("pshufb %xmm5,%xmm3");
2098 3158080 : asm volatile ("pxor %xmm2,%xmm6");
2099 3158080 : asm volatile ("pxor %xmm3,%xmm6");
2100 :
2101 3158080 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[1]][0][0]));
2102 3158080 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[1]][1][0]));
2103 3158080 : asm volatile ("movdqa %xmm1,%xmm4");
2104 3158080 : asm volatile ("movdqa %xmm1,%xmm5");
2105 3158080 : asm volatile ("psrlw $4,%xmm5");
2106 3158080 : asm volatile ("pand %xmm7,%xmm4");
2107 3158080 : asm volatile ("pand %xmm7,%xmm5");
2108 3158080 : asm volatile ("pshufb %xmm4,%xmm2");
2109 3158080 : asm volatile ("pshufb %xmm5,%xmm3");
2110 3158080 : asm volatile ("pxor %xmm2,%xmm6");
2111 3158080 : asm volatile ("pxor %xmm3,%xmm6");
2112 :
2113 3158080 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[0][i]));
2114 :
2115 3158080 : asm volatile ("pxor %xmm6,%xmm6");
2116 :
2117 3158080 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[2]][0][0]));
2118 3158080 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[2]][1][0]));
2119 3158080 : asm volatile ("movdqa %xmm0,%xmm4");
2120 3158080 : asm volatile ("movdqa %xmm0,%xmm5");
2121 3158080 : asm volatile ("psrlw $4,%xmm5");
2122 3158080 : asm volatile ("pand %xmm7,%xmm4");
2123 3158080 : asm volatile ("pand %xmm7,%xmm5");
2124 3158080 : asm volatile ("pshufb %xmm4,%xmm2");
2125 3158080 : asm volatile ("pshufb %xmm5,%xmm3");
2126 3158080 : asm volatile ("pxor %xmm2,%xmm6");
2127 3158080 : asm volatile ("pxor %xmm3,%xmm6");
2128 :
2129 3158080 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[V[3]][0][0]));
2130 3158080 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[V[3]][1][0]));
2131 3158080 : asm volatile ("movdqa %xmm1,%xmm4");
2132 3158080 : asm volatile ("movdqa %xmm1,%xmm5");
2133 3158080 : asm volatile ("psrlw $4,%xmm5");
2134 3158080 : asm volatile ("pand %xmm7,%xmm4");
2135 3158080 : asm volatile ("pand %xmm7,%xmm5");
2136 3158080 : asm volatile ("pshufb %xmm4,%xmm2");
2137 3158080 : asm volatile ("pshufb %xmm5,%xmm3");
2138 3158080 : asm volatile ("pxor %xmm2,%xmm6");
2139 3158080 : asm volatile ("pxor %xmm3,%xmm6");
2140 :
2141 3158080 : asm volatile ("movdqa %%xmm6,%0" : "=m" (pa[1][i]));
2142 : }
2143 :
2144 : raid_sse_end();
2145 44116 : }
2146 : #endif
2147 :
2148 : #if defined(CONFIG_X86) && defined(CONFIG_SSSE3)
2149 : /*
2150 : * RAID recovering SSSE3 implementation
2151 : */
2152 79288 : void raid_recX_ssse3(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2153 : {
2154 79288 : uint8_t **v = (uint8_t **)vv;
2155 79288 : int N = nr;
2156 : uint8_t *p[RAID_PARITY_MAX];
2157 : uint8_t *pa[RAID_PARITY_MAX];
2158 : uint8_t G[RAID_PARITY_MAX * RAID_PARITY_MAX];
2159 : uint8_t V[RAID_PARITY_MAX * RAID_PARITY_MAX];
2160 : uint8_t buffer[RAID_PARITY_MAX*16+16];
2161 79288 : uint8_t *pd = __align_ptr(buffer, 16);
2162 : size_t i;
2163 : int j, k;
2164 :
2165 : /* setup the coefficients matrix */
2166 435102 : for (j = 0; j < N; ++j)
2167 2046374 : for (k = 0; k < N; ++k)
2168 3381120 : G[j * N + k] = A(ip[j], id[k]);
2169 :
2170 : /* invert it to solve the system of linear equations */
2171 79288 : raid_invert(G, V, N);
2172 :
2173 : /* compute delta parity */
2174 79288 : raid_delta_gen(N, id, ip, nd, size, vv);
2175 :
2176 435102 : for (j = 0; j < N; ++j) {
2177 355814 : p[j] = v[nd + ip[j]];
2178 355814 : pa[j] = v[id[j]];
2179 : }
2180 :
2181 : raid_sse_begin();
2182 :
2183 79288 : asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0]));
2184 :
2185 5869832 : for (i = 0; i < size; i += 16) {
2186 : /* delta */
2187 32115408 : for (j = 0; j < N; ++j) {
2188 26324864 : asm volatile ("movdqa %0,%%xmm0" : : "m" (p[j][i]));
2189 26324864 : asm volatile ("movdqa %0,%%xmm1" : : "m" (pa[j][i]));
2190 26324864 : asm volatile ("pxor %xmm1,%xmm0");
2191 26324864 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pd[j*16]));
2192 : }
2193 :
2194 : /* reconstruct */
2195 32115408 : for (j = 0; j < N; ++j) {
2196 26324864 : asm volatile ("pxor %xmm0,%xmm0");
2197 26324864 : asm volatile ("pxor %xmm1,%xmm1");
2198 :
2199 153207872 : for (k = 0; k < N; ++k) {
2200 126883008 : uint8_t m = V[j * N + k];
2201 :
2202 126883008 : asm volatile ("movdqa %0,%%xmm2" : : "m" (gfmulpshufb[m][0][0]));
2203 126883008 : asm volatile ("movdqa %0,%%xmm3" : : "m" (gfmulpshufb[m][1][0]));
2204 126883008 : asm volatile ("movdqa %0,%%xmm4" : : "m" (pd[k*16]));
2205 126883008 : asm volatile ("movdqa %xmm4,%xmm5");
2206 126883008 : asm volatile ("psrlw $4,%xmm5");
2207 126883008 : asm volatile ("pand %xmm7,%xmm4");
2208 126883008 : asm volatile ("pand %xmm7,%xmm5");
2209 126883008 : asm volatile ("pshufb %xmm4,%xmm2");
2210 126883008 : asm volatile ("pshufb %xmm5,%xmm3");
2211 126883008 : asm volatile ("pxor %xmm2,%xmm0");
2212 126883008 : asm volatile ("pxor %xmm3,%xmm1");
2213 : }
2214 :
2215 26324864 : asm volatile ("pxor %xmm1,%xmm0");
2216 26324864 : asm volatile ("movdqa %%xmm0,%0" : "=m" (pa[j][i]));
2217 : }
2218 : }
2219 :
2220 : raid_sse_end();
2221 79288 : }
2222 : #endif
2223 :
2224 : #if defined(CONFIG_X86) && defined(CONFIG_AVX2)
2225 : /*
2226 : * RAID recovering for one disk AVX2 implementation
2227 : */
2228 126 : void raid_rec1_avx2(int nr, int *id, int *ip, int nd, size_t size, void **vv)
2229 : {
2230 126 : uint8_t **v = (uint8_t **)vv;
2231 : uint8_t *p;
2232 : uint8_t *pa;
2233 : uint8_t G;
2234 : uint8_t V;
2235 : size_t i;
2236 :
2237 : (void)nr; /* unused, it's always 1 */
2238 :
2239 : /* if it's RAID5 uses the faster function */
2240 126 : if (ip[0] == 0) {
2241 30 : raid_rec1of1(id, nd, size, vv);
2242 30 : return;
2243 : }
2244 :
2245 : /* setup the coefficients matrix */
2246 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 :
|
