]> git.proxmox.com Git - ceph.git/blame - ceph/src/isa-l/erasure_code/gf_5vect_dot_prod_sse_test.c
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
buildsys: switch source download to quincy
[ceph.git] / ceph / src / isa-l / erasure_code / gf_5vect_dot_prod_sse_test.c
CommitLineData
7c673cae
FG		 1/**********************************************************************
2 Copyright(c) 2011-2015 Intel Corporation All rights reserved.
3
4 Redistribution and use in source and binary forms, with or without
f91f0fd5 5 modification, are permitted provided that the following conditions
7c673cae
FG		 6 are met:
7 * Redistributions of source code must retain the above copyright
8 notice, this list of conditions and the following disclaimer.
9 * Redistributions in binary form must reproduce the above copyright
10 notice, this list of conditions and the following disclaimer in
11 the documentation and/or other materials provided with the
12 distribution.
13 * Neither the name of Intel Corporation nor the names of its
14 contributors may be used to endorse or promote products derived
15 from this software without specific prior written permission.
16
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28**********************************************************************/
29
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h> // for memset, memcmp
33#include "erasure_code.h"
34#include "types.h"
35
36#ifndef FUNCTION_UNDER_TEST
37# define FUNCTION_UNDER_TEST gf_5vect_dot_prod_sse
38#endif
39#ifndef TEST_MIN_SIZE
40# define TEST_MIN_SIZE 16
41#endif
42
43#define str(s) #s
44#define xstr(s) str(s)
45
46#define TEST_LEN 8192
47#define TEST_SIZE (TEST_LEN/2)
48#define TEST_MEM TEST_SIZE
49#define TEST_LOOPS 20000
50#define TEST_TYPE_STR ""
51
52#ifndef TEST_SOURCES
53# define TEST_SOURCES 16
54#endif
55#ifndef RANDOMS
56# define RANDOMS 20
57#endif
58
59#ifdef EC_ALIGNED_ADDR
60// Define power of 2 range to check ptr, len alignment
61# define PTR_ALIGN_CHK_B 0
62# define LEN_ALIGN_CHK_B 0 // 0 for aligned only
63#else
64// Define power of 2 range to check ptr, len alignment
65# define PTR_ALIGN_CHK_B 32
66# define LEN_ALIGN_CHK_B 32 // 0 for aligned only
67#endif
68
69typedef unsigned char u8;
70
71void dump(unsigned char *buf, int len)
72{
73 int i;
74 for (i = 0; i < len;) {
75 printf(" %2x", 0xff & buf[i++]);
76 if (i % 32 == 0)
77 printf("\n");
78 }
79 printf("\n");
80}
81
82void dump_matrix(unsigned char **s, int k, int m)
83{
84 int i, j;
85 for (i = 0; i < k; i++) {
86 for (j = 0; j < m; j++) {
87 printf(" %2x", s[i][j]);
88 }
89 printf("\n");
90 }
91 printf("\n");
92}
93
94void dump_u8xu8(unsigned char *s, int k, int m)
95{
96 int i, j;
97 for (i = 0; i < k; i++) {
98 for (j = 0; j < m; j++) {
99 printf(" %2x", 0xff & s[j + (i * m)]);
100 }
101 printf("\n");
102 }
103 printf("\n");
104}
105
106int main(int argc, char *argv[])
107{
108 int i, j, rtest, srcs;
109 void *buf;
110 u8 g1[TEST_SOURCES], g2[TEST_SOURCES], g3[TEST_SOURCES];
111 u8 g4[TEST_SOURCES], g5[TEST_SOURCES], *g_tbls;
112 u8 *dest1, *dest2, *dest3, *dest4, *dest5, *buffs[TEST_SOURCES];
113 u8 *dest_ref1, *dest_ref2, *dest_ref3, *dest_ref4, *dest_ref5;
114 u8 *dest_ptrs[5];
115
116 int align, size;
117 unsigned char *efence_buffs[TEST_SOURCES];
118 unsigned int offset;
119 u8 *ubuffs[TEST_SOURCES];
120 u8 *udest_ptrs[5];
121 printf(xstr(FUNCTION_UNDER_TEST) ": %dx%d ", TEST_SOURCES, TEST_LEN);
122
123 // Allocate the arrays
124 for (i = 0; i < TEST_SOURCES; i++) {
125 if (posix_memalign(&buf, 64, TEST_LEN)) {
126 printf("alloc error: Fail");
127 return -1;
128 }
129 buffs[i] = buf;
130 }
131
132 if (posix_memalign(&buf, 16, 2 * (6 * TEST_SOURCES * 32))) {
133 printf("alloc error: Fail");
134 return -1;
135 }
136 g_tbls = buf;
137
138 if (posix_memalign(&buf, 64, TEST_LEN)) {
139 printf("alloc error: Fail");
140 return -1;
141 }
142 dest1 = buf;
143
144 if (posix_memalign(&buf, 64, TEST_LEN)) {
145 printf("alloc error: Fail");
146 return -1;
147 }
148 dest2 = buf;
149
150 if (posix_memalign(&buf, 64, TEST_LEN)) {
151 printf("alloc error: Fail");
152 return -1;
153 }
154 dest3 = buf;
155
156 if (posix_memalign(&buf, 64, TEST_LEN)) {
157 printf("alloc error: Fail");
158 return -1;
159 }
160 dest4 = buf;
161
162 if (posix_memalign(&buf, 64, TEST_LEN)) {
163 printf("alloc error: Fail");
164 return -1;
165 }
166 dest5 = buf;
167
168 if (posix_memalign(&buf, 64, TEST_LEN)) {
169 printf("alloc error: Fail");
170 return -1;
171 }
172 dest_ref1 = buf;
173
174 if (posix_memalign(&buf, 64, TEST_LEN)) {
175 printf("alloc error: Fail");
176 return -1;
177 }
178 dest_ref2 = buf;
179
180 if (posix_memalign(&buf, 64, TEST_LEN)) {
181 printf("alloc error: Fail");
182 return -1;
183 }
184 dest_ref3 = buf;
185
186 if (posix_memalign(&buf, 64, TEST_LEN)) {
187 printf("alloc error: Fail");
188 return -1;
189 }
190 dest_ref4 = buf;
191
192 if (posix_memalign(&buf, 64, TEST_LEN)) {
193 printf("alloc error: Fail");
194 return -1;
195 }
196 dest_ref5 = buf;
197
198 dest_ptrs[0] = dest1;
199 dest_ptrs[1] = dest2;
200 dest_ptrs[2] = dest3;
201 dest_ptrs[3] = dest4;
202 dest_ptrs[4] = dest5;
203
204 // Test of all zeros
205 for (i = 0; i < TEST_SOURCES; i++)
206 memset(buffs[i], 0, TEST_LEN);
207
208 memset(dest1, 0, TEST_LEN);
209 memset(dest2, 0, TEST_LEN);
210 memset(dest3, 0, TEST_LEN);
211 memset(dest4, 0, TEST_LEN);
212 memset(dest5, 0, TEST_LEN);
213 memset(dest_ref1, 0, TEST_LEN);
214 memset(dest_ref2, 0, TEST_LEN);
215 memset(dest_ref3, 0, TEST_LEN);
216 memset(dest_ref4, 0, TEST_LEN);
217 memset(dest_ref5, 0, TEST_LEN);
218 memset(g1, 2, TEST_SOURCES);
219 memset(g2, 1, TEST_SOURCES);
220 memset(g3, 7, TEST_SOURCES);
221 memset(g4, 9, TEST_SOURCES);
222 memset(g5, 4, TEST_SOURCES);
223
224 for (i = 0; i < TEST_SOURCES; i++) {
225 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
226 gf_vect_mul_init(g2[i], &g_tbls[32 * TEST_SOURCES + i * 32]);
227 gf_vect_mul_init(g3[i], &g_tbls[64 * TEST_SOURCES + i * 32]);
228 gf_vect_mul_init(g4[i], &g_tbls[96 * TEST_SOURCES + i * 32]);
229 gf_vect_mul_init(g5[i], &g_tbls[128 * TEST_SOURCES + i * 32]);
230 }
231
232 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1);
233 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES], buffs,
234 dest_ref2);
235 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES], buffs,
236 dest_ref3);
237 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES], buffs,
238 dest_ref4);
239 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[128 * TEST_SOURCES], buffs,
240 dest_ref5);
241
242 FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
243
244 if (0 != memcmp(dest_ref1, dest1, TEST_LEN)) {
245 printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test1\n");
246 dump_matrix(buffs, 5, TEST_SOURCES);
247 printf("dprod_base:");
248 dump(dest_ref1, 25);
249 printf("dprod_dut:");
250 dump(dest1, 25);
251 return -1;
252 }
253 if (0 != memcmp(dest_ref2, dest2, TEST_LEN)) {
254 printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test2\n");
255 dump_matrix(buffs, 5, TEST_SOURCES);
256 printf("dprod_base:");
257 dump(dest_ref2, 25);
258 printf("dprod_dut:");
259 dump(dest2, 25);
260 return -1;
261 }
262 if (0 != memcmp(dest_ref3, dest3, TEST_LEN)) {
263 printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test3\n");
264 dump_matrix(buffs, 5, TEST_SOURCES);
265 printf("dprod_base:");
266 dump(dest_ref3, 25);
267 printf("dprod_dut:");
268 dump(dest3, 25);
269 return -1;
270 }
271 if (0 != memcmp(dest_ref4, dest4, TEST_LEN)) {
272 printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test4\n");
273 dump_matrix(buffs, 5, TEST_SOURCES);
274 printf("dprod_base:");
275 dump(dest_ref4, 25);
276 printf("dprod_dut:");
277 dump(dest4, 25);
278 return -1;
279 }
280 if (0 != memcmp(dest_ref5, dest5, TEST_LEN)) {
281 printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test5\n");
282 dump_matrix(buffs, 5, TEST_SOURCES);
283 printf("dprod_base:");
284 dump(dest_ref5, 25);
285 printf("dprod_dut:");
286 dump(dest5, 25);
287 return -1;
288 }
289 putchar('.');
290
291 // Rand data test
292
293 for (rtest = 0; rtest < RANDOMS; rtest++) {
294 for (i = 0; i < TEST_SOURCES; i++)
295 for (j = 0; j < TEST_LEN; j++)
296 buffs[i][j] = rand();
297
298 for (i = 0; i < TEST_SOURCES; i++) {
299 g1[i] = rand();
300 g2[i] = rand();
301 g3[i] = rand();
302 g4[i] = rand();
303 g5[i] = rand();
304 }
305
306 for (i = 0; i < TEST_SOURCES; i++) {
307 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
308 gf_vect_mul_init(g2[i], &g_tbls[(32 * TEST_SOURCES) + (i * 32)]);
309 gf_vect_mul_init(g3[i], &g_tbls[(64 * TEST_SOURCES) + (i * 32)]);
310 gf_vect_mul_init(g4[i], &g_tbls[(96 * TEST_SOURCES) + (i * 32)]);
311 gf_vect_mul_init(g5[i], &g_tbls[(128 * TEST_SOURCES) + (i * 32)]);
312 }
313
314 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1);
315 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES],
316 buffs, dest_ref2);
317 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES],
318 buffs, dest_ref3);
319 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES],
320 buffs, dest_ref4);
321 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[128 * TEST_SOURCES],
322 buffs, dest_ref5);
323
324 FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
325
326 if (0 != memcmp(dest_ref1, dest1, TEST_LEN)) {
327 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test1 %d\n", rtest);
328 dump_matrix(buffs, 5, TEST_SOURCES);
329 printf("dprod_base:");
330 dump(dest_ref1, 25);
331 printf("dprod_dut:");
332 dump(dest1, 25);
333 return -1;
334 }
335 if (0 != memcmp(dest_ref2, dest2, TEST_LEN)) {
336 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test2 %d\n", rtest);
337 dump_matrix(buffs, 5, TEST_SOURCES);
338 printf("dprod_base:");
339 dump(dest_ref2, 25);
340 printf("dprod_dut:");
341 dump(dest2, 25);
342 return -1;
343 }
344 if (0 != memcmp(dest_ref3, dest3, TEST_LEN)) {
345 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test3 %d\n", rtest);
346 dump_matrix(buffs, 5, TEST_SOURCES);
347 printf("dprod_base:");
348 dump(dest_ref3, 25);
349 printf("dprod_dut:");
350 dump(dest3, 25);
351 return -1;
352 }
353 if (0 != memcmp(dest_ref4, dest4, TEST_LEN)) {
354 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test4 %d\n", rtest);
355 dump_matrix(buffs, 5, TEST_SOURCES);
356 printf("dprod_base:");
357 dump(dest_ref4, 25);
358 printf("dprod_dut:");
359 dump(dest4, 25);
360 return -1;
361 }
362 if (0 != memcmp(dest_ref5, dest5, TEST_LEN)) {
363 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test5 %d\n", rtest);
364 dump_matrix(buffs, 5, TEST_SOURCES);
365 printf("dprod_base:");
366 dump(dest_ref5, 25);
367 printf("dprod_dut:");
368 dump(dest5, 25);
369 return -1;
370 }
371
372 putchar('.');
373 }
374
375 // Rand data test with varied parameters
376 for (rtest = 0; rtest < RANDOMS; rtest++) {
377 for (srcs = TEST_SOURCES; srcs > 0; srcs--) {
378 for (i = 0; i < srcs; i++)
379 for (j = 0; j < TEST_LEN; j++)
380 buffs[i][j] = rand();
381
382 for (i = 0; i < srcs; i++) {
383 g1[i] = rand();
384 g2[i] = rand();
385 g3[i] = rand();
386 g4[i] = rand();
387 g5[i] = rand();
388 }
389
390 for (i = 0; i < srcs; i++) {
391 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
392 gf_vect_mul_init(g2[i], &g_tbls[(32 * srcs) + (i * 32)]);
393 gf_vect_mul_init(g3[i], &g_tbls[(64 * srcs) + (i * 32)]);
394 gf_vect_mul_init(g4[i], &g_tbls[(96 * srcs) + (i * 32)]);
395 gf_vect_mul_init(g5[i], &g_tbls[(128 * srcs) + (i * 32)]);
396 }
397
398 gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[0], buffs, dest_ref1);
399 gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[32 * srcs], buffs,
400 dest_ref2);
401 gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[64 * srcs], buffs,
402 dest_ref3);
403 gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[96 * srcs], buffs,
404 dest_ref4);
405 gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[128 * srcs], buffs,
406 dest_ref5);
407
408 FUNCTION_UNDER_TEST(TEST_LEN, srcs, g_tbls, buffs, dest_ptrs);
409
410 if (0 != memcmp(dest_ref1, dest1, TEST_LEN)) {
411 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
412 " test1 srcs=%d\n", srcs);
413 dump_matrix(buffs, 5, TEST_SOURCES);
414 printf("dprod_base:");
415 dump(dest_ref1, 25);
416 printf("dprod_dut:");
417 dump(dest1, 25);
418 return -1;
419 }
420 if (0 != memcmp(dest_ref2, dest2, TEST_LEN)) {
421 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
422 " test2 srcs=%d\n", srcs);
423 dump_matrix(buffs, 5, TEST_SOURCES);
424 printf("dprod_base:");
425 dump(dest_ref2, 25);
426 printf("dprod_dut:");
427 dump(dest2, 25);
428 return -1;
429 }
430 if (0 != memcmp(dest_ref3, dest3, TEST_LEN)) {
431 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
432 " test3 srcs=%d\n", srcs);
433 dump_matrix(buffs, 5, TEST_SOURCES);
434 printf("dprod_base:");
435 dump(dest_ref3, 25);
436 printf("dprod_dut:");
437 dump(dest3, 25);
438 return -1;
439 }
440 if (0 != memcmp(dest_ref4, dest4, TEST_LEN)) {
441 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
442 " test4 srcs=%d\n", srcs);
443 dump_matrix(buffs, 5, TEST_SOURCES);
444 printf("dprod_base:");
445 dump(dest_ref4, 25);
446 printf("dprod_dut:");
447 dump(dest4, 25);
448 return -1;
449 }
450 if (0 != memcmp(dest_ref5, dest5, TEST_LEN)) {
451 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
452 " test5 srcs=%d\n", srcs);
453 dump_matrix(buffs, 5, TEST_SOURCES);
454 printf("dprod_base:");
455 dump(dest_ref5, 25);
456 printf("dprod_dut:");
457 dump(dest5, 25);
458 return -1;
459 }
460
461 putchar('.');
462 }
463 }
464
465 // Run tests at end of buffer for Electric Fence
466 align = (LEN_ALIGN_CHK_B != 0) ? 1 : 16;
467 for (size = TEST_MIN_SIZE; size <= TEST_SIZE; size += align) {
468 for (i = 0; i < TEST_SOURCES; i++)
469 for (j = 0; j < TEST_LEN; j++)
470 buffs[i][j] = rand();
471
472 for (i = 0; i < TEST_SOURCES; i++) // Line up TEST_SIZE from end
473 efence_buffs[i] = buffs[i] + TEST_LEN - size;
474
475 for (i = 0; i < TEST_SOURCES; i++) {
476 g1[i] = rand();
477 g2[i] = rand();
478 g3[i] = rand();
479 g4[i] = rand();
480 g5[i] = rand();
481 }
482
483 for (i = 0; i < TEST_SOURCES; i++) {
484 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
485 gf_vect_mul_init(g2[i], &g_tbls[(32 * TEST_SOURCES) + (i * 32)]);
486 gf_vect_mul_init(g3[i], &g_tbls[(64 * TEST_SOURCES) + (i * 32)]);
487 gf_vect_mul_init(g4[i], &g_tbls[(96 * TEST_SOURCES) + (i * 32)]);
488 gf_vect_mul_init(g5[i], &g_tbls[(128 * TEST_SOURCES) + (i * 32)]);
489 }
490
491 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[0], efence_buffs, dest_ref1);
492 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES],
493 efence_buffs, dest_ref2);
494 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES],
495 efence_buffs, dest_ref3);
496 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES],
497 efence_buffs, dest_ref4);
498 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[128 * TEST_SOURCES],
499 efence_buffs, dest_ref5);
500
501 FUNCTION_UNDER_TEST(size, TEST_SOURCES, g_tbls, efence_buffs, dest_ptrs);
502
503 if (0 != memcmp(dest_ref1, dest1, size)) {
504 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test1 %d\n", rtest);
505 dump_matrix(efence_buffs, 5, TEST_SOURCES);
506 printf("dprod_base:");
507 dump(dest_ref1, align);
508 printf("dprod_dut:");
509 dump(dest1, align);
510 return -1;
511 }
512
513 if (0 != memcmp(dest_ref2, dest2, size)) {
514 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test2 %d\n", rtest);
515 dump_matrix(efence_buffs, 5, TEST_SOURCES);
516 printf("dprod_base:");
517 dump(dest_ref2, align);
518 printf("dprod_dut:");
519 dump(dest2, align);
520 return -1;
521 }
522
523 if (0 != memcmp(dest_ref3, dest3, size)) {
524 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test3 %d\n", rtest);
525 dump_matrix(efence_buffs, 5, TEST_SOURCES);
526 printf("dprod_base:");
527 dump(dest_ref3, align);
528 printf("dprod_dut:");
529 dump(dest3, align);
530 return -1;
531 }
532
533 if (0 != memcmp(dest_ref4, dest4, size)) {
534 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test4 %d\n", rtest);
535 dump_matrix(efence_buffs, 5, TEST_SOURCES);
536 printf("dprod_base:");
537 dump(dest_ref4, align);
538 printf("dprod_dut:");
539 dump(dest4, align);
540 return -1;
541 }
542
543 if (0 != memcmp(dest_ref5, dest5, size)) {
544 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test5 %d\n", rtest);
545 dump_matrix(efence_buffs, 5, TEST_SOURCES);
546 printf("dprod_base:");
547 dump(dest_ref5, align);
548 printf("dprod_dut:");
549 dump(dest5, align);
550 return -1;
551 }
552
553 putchar('.');
554 }
555
556 // Test rand ptr alignment if available
557
558 for (rtest = 0; rtest < RANDOMS; rtest++) {
559 size = (TEST_LEN - PTR_ALIGN_CHK_B) & ~(TEST_MIN_SIZE - 1);
560 srcs = rand() % TEST_SOURCES;
561 if (srcs == 0)
562 continue;
563
564 offset = (PTR_ALIGN_CHK_B != 0) ? 1 : PTR_ALIGN_CHK_B;
565 // Add random offsets
566 for (i = 0; i < srcs; i++)
567 ubuffs[i] = buffs[i] + (rand() & (PTR_ALIGN_CHK_B - offset));
568
569 udest_ptrs[0] = dest1 + (rand() & (PTR_ALIGN_CHK_B - offset));
570 udest_ptrs[1] = dest2 + (rand() & (PTR_ALIGN_CHK_B - offset));
571 udest_ptrs[2] = dest3 + (rand() & (PTR_ALIGN_CHK_B - offset));
572 udest_ptrs[3] = dest4 + (rand() & (PTR_ALIGN_CHK_B - offset));
573 udest_ptrs[4] = dest5 + (rand() & (PTR_ALIGN_CHK_B - offset));
574
575 memset(dest1, 0, TEST_LEN); // zero pad to check write-over
576 memset(dest2, 0, TEST_LEN);
577 memset(dest3, 0, TEST_LEN);
578 memset(dest4, 0, TEST_LEN);
579 memset(dest5, 0, TEST_LEN);
580
581 for (i = 0; i < srcs; i++)
582 for (j = 0; j < size; j++)
583 ubuffs[i][j] = rand();
584
585 for (i = 0; i < srcs; i++) {
586 g1[i] = rand();
587 g2[i] = rand();
588 g3[i] = rand();
589 g4[i] = rand();
590 g5[i] = rand();
591 }
592
593 for (i = 0; i < srcs; i++) {
594 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
595 gf_vect_mul_init(g2[i], &g_tbls[(32 * srcs) + (i * 32)]);
596 gf_vect_mul_init(g3[i], &g_tbls[(64 * srcs) + (i * 32)]);
597 gf_vect_mul_init(g4[i], &g_tbls[(96 * srcs) + (i * 32)]);
598 gf_vect_mul_init(g5[i], &g_tbls[(128 * srcs) + (i * 32)]);
599 }
600
601 gf_vect_dot_prod_base(size, srcs, &g_tbls[0], ubuffs, dest_ref1);
602 gf_vect_dot_prod_base(size, srcs, &g_tbls[32 * srcs], ubuffs, dest_ref2);
603 gf_vect_dot_prod_base(size, srcs, &g_tbls[64 * srcs], ubuffs, dest_ref3);
604 gf_vect_dot_prod_base(size, srcs, &g_tbls[96 * srcs], ubuffs, dest_ref4);
605 gf_vect_dot_prod_base(size, srcs, &g_tbls[128 * srcs], ubuffs, dest_ref5);
606
607 FUNCTION_UNDER_TEST(size, srcs, g_tbls, ubuffs, udest_ptrs);
608
609 if (memcmp(dest_ref1, udest_ptrs[0], size)) {
610 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
611 srcs);
612 dump_matrix(ubuffs, 5, TEST_SOURCES);
613 printf("dprod_base:");
614 dump(dest_ref1, 25);
615 printf("dprod_dut:");
616 dump(udest_ptrs[0], 25);
617 return -1;
618 }
619 if (memcmp(dest_ref2, udest_ptrs[1], size)) {
620 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
621 srcs);
622 dump_matrix(ubuffs, 5, TEST_SOURCES);
623 printf("dprod_base:");
624 dump(dest_ref2, 25);
625 printf("dprod_dut:");
626 dump(udest_ptrs[1], 25);
627 return -1;
628 }
629 if (memcmp(dest_ref3, udest_ptrs[2], size)) {
630 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
631 srcs);
632 dump_matrix(ubuffs, 5, TEST_SOURCES);
633 printf("dprod_base:");
634 dump(dest_ref3, 25);
635 printf("dprod_dut:");
636 dump(udest_ptrs[2], 25);
637 return -1;
638 }
639 if (memcmp(dest_ref4, udest_ptrs[3], size)) {
640 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
641 srcs);
642 dump_matrix(ubuffs, 5, TEST_SOURCES);
643 printf("dprod_base:");
644 dump(dest_ref4, 25);
645 printf("dprod_dut:");
646 dump(udest_ptrs[3], 25);
647 return -1;
648 }
649 if (memcmp(dest_ref5, udest_ptrs[4], size)) {
650 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
651 srcs);
652 dump_matrix(ubuffs, 5, TEST_SOURCES);
653 printf("dprod_base:");
654 dump(dest_ref5, 25);
655 printf("dprod_dut:");
656 dump(udest_ptrs[4], 25);
657 return -1;
658 }
659 // Confirm that padding around dests is unchanged
660 memset(dest_ref1, 0, PTR_ALIGN_CHK_B); // Make reference zero buff
661 offset = udest_ptrs[0] - dest1;
662
663 if (memcmp(dest1, dest_ref1, offset)) {
664 printf("Fail rand ualign pad1 start\n");
665 return -1;
666 }
667 if (memcmp(dest1 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
668 printf("Fail rand ualign pad1 end\n");
669 return -1;
670 }
671
672 offset = udest_ptrs[1] - dest2;
673 if (memcmp(dest2, dest_ref1, offset)) {
674 printf("Fail rand ualign pad2 start\n");
675 return -1;
676 }
677 if (memcmp(dest2 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
678 printf("Fail rand ualign pad2 end\n");
679 return -1;
680 }
681
682 offset = udest_ptrs[2] - dest3;
683 if (memcmp(dest3, dest_ref1, offset)) {
684 printf("Fail rand ualign pad3 start\n");
685 return -1;
686 }
687 if (memcmp(dest3 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
688 printf("Fail rand ualign pad3 end\n");
689 return -1;
690 }
691
692 offset = udest_ptrs[3] - dest4;
693 if (memcmp(dest4, dest_ref1, offset)) {
694 printf("Fail rand ualign pad4 start\n");
695 return -1;
696 }
697 if (memcmp(dest4 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
698 printf("Fail rand ualign pad4 end\n");
699 return -1;
700 }
701
702 offset = udest_ptrs[4] - dest5;
703 if (memcmp(dest5, dest_ref1, offset)) {
704 printf("Fail rand ualign pad5 start\n");
705 return -1;
706 }
707 if (memcmp(dest5 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
708 printf("Fail rand ualign pad5 end\n");
709 return -1;
710 }
711
712 putchar('.');
713 }
714
715 // Test all size alignment
716 align = (LEN_ALIGN_CHK_B != 0) ? 1 : 16;
717
718 for (size = TEST_LEN; size >= TEST_MIN_SIZE; size -= align) {
719 srcs = TEST_SOURCES;
720
721 for (i = 0; i < srcs; i++)
722 for (j = 0; j < size; j++)
723 buffs[i][j] = rand();
724
725 for (i = 0; i < srcs; i++) {
726 g1[i] = rand();
727 g2[i] = rand();
728 g3[i] = rand();
729 g4[i] = rand();
730 g5[i] = rand();
731 }
732
733 for (i = 0; i < srcs; i++) {
734 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
735 gf_vect_mul_init(g2[i], &g_tbls[(32 * srcs) + (i * 32)]);
736 gf_vect_mul_init(g3[i], &g_tbls[(64 * srcs) + (i * 32)]);
737 gf_vect_mul_init(g4[i], &g_tbls[(96 * srcs) + (i * 32)]);
738 gf_vect_mul_init(g5[i], &g_tbls[(128 * srcs) + (i * 32)]);
739 }
740
741 gf_vect_dot_prod_base(size, srcs, &g_tbls[0], buffs, dest_ref1);
742 gf_vect_dot_prod_base(size, srcs, &g_tbls[32 * srcs], buffs, dest_ref2);
743 gf_vect_dot_prod_base(size, srcs, &g_tbls[64 * srcs], buffs, dest_ref3);
744 gf_vect_dot_prod_base(size, srcs, &g_tbls[96 * srcs], buffs, dest_ref4);
745 gf_vect_dot_prod_base(size, srcs, &g_tbls[128 * srcs], buffs, dest_ref5);
746
747 FUNCTION_UNDER_TEST(size, srcs, g_tbls, buffs, dest_ptrs);
748
749 if (memcmp(dest_ref1, dest_ptrs[0], size)) {
750 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
751 size);
752 dump_matrix(buffs, 5, TEST_SOURCES);
753 printf("dprod_base:");
754 dump(dest_ref1, 25);
755 printf("dprod_dut:");
756 dump(dest_ptrs[0], 25);
757
758 return -1;
759 }
760 if (memcmp(dest_ref2, dest_ptrs[1], size)) {
761 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
762 size);
763 dump_matrix(buffs, 5, TEST_SOURCES);
764 printf("dprod_base:");
765 dump(dest_ref2, 25);
766 printf("dprod_dut:");
767 dump(dest_ptrs[1], 25);
768 return -1;
769 }
770 if (memcmp(dest_ref3, dest_ptrs[2], size)) {
771 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
772 size);
773 dump_matrix(buffs, 5, TEST_SOURCES);
774 printf("dprod_base:");
775 dump(dest_ref3, 25);
776 printf("dprod_dut:");
777 dump(dest_ptrs[2], 25);
778 return -1;
779 }
780 if (memcmp(dest_ref4, dest_ptrs[3], size)) {
781 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
782 size);
783 dump_matrix(buffs, 5, TEST_SOURCES);
784 printf("dprod_base:");
785 dump(dest_ref4, 25);
786 printf("dprod_dut:");
787 dump(dest_ptrs[3], 25);
788 return -1;
789 }
790 if (memcmp(dest_ref5, dest_ptrs[4], size)) {
791 printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
792 size);
793 dump_matrix(buffs, 5, TEST_SOURCES);
794 printf("dprod_base:");
795 dump(dest_ref5, 25);
796 printf("dprod_dut:");
797 dump(dest_ptrs[4], 25);
798 return -1;
799 }
800 }
801
802 printf("Pass\n");
803 return 0;
804
805}
Ceph