]>
git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/isa-l/erasure_code/gf_6vect_dot_prod_sse_test.c
1 /**********************************************************************
2 Copyright(c) 2011-2015 Intel Corporation All rights reserved.
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions
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
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.
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 **********************************************************************/
32 #include <string.h> // for memset, memcmp
33 #include "erasure_code.h"
36 #ifndef FUNCTION_UNDER_TEST
37 # define FUNCTION_UNDER_TEST gf_6vect_dot_prod_sse
40 # define TEST_MIN_SIZE 16
44 #define xstr(s) str(s)
47 #define TEST_SIZE (TEST_LEN/2)
48 #define TEST_MEM TEST_SIZE
49 #define TEST_LOOPS 20000
50 #define TEST_TYPE_STR ""
53 # define TEST_SOURCES 16
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
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
69 typedef unsigned char u8
;
71 void dump(unsigned char *buf
, int len
)
74 for (i
= 0; i
< len
;) {
75 printf(" %2x", 0xff & buf
[i
++]);
82 void dump_matrix(unsigned char **s
, int k
, int m
)
85 for (i
= 0; i
< k
; i
++) {
86 for (j
= 0; j
< m
; j
++) {
87 printf(" %2x", s
[i
][j
]);
94 void dump_u8xu8(unsigned char *s
, int k
, int m
)
97 for (i
= 0; i
< k
; i
++) {
98 for (j
= 0; j
< m
; j
++) {
99 printf(" %2x", 0xff & s
[j
+ (i
* m
)]);
106 int main(int argc
, char *argv
[])
108 int i
, j
, rtest
, srcs
;
110 u8 g1
[TEST_SOURCES
], g2
[TEST_SOURCES
], g3
[TEST_SOURCES
];
111 u8 g4
[TEST_SOURCES
], g5
[TEST_SOURCES
], g6
[TEST_SOURCES
], *g_tbls
;
112 u8
*dest1
, *dest2
, *dest3
, *dest4
, *dest5
, *dest6
, *dest_ref1
;
113 u8
*dest_ref2
, *dest_ref3
, *dest_ref4
, *dest_ref5
, *dest_ref6
;
114 u8
*dest_ptrs
[6], *buffs
[TEST_SOURCES
];
117 unsigned char *efence_buffs
[TEST_SOURCES
];
119 u8
*ubuffs
[TEST_SOURCES
];
121 printf(xstr(FUNCTION_UNDER_TEST
) ": %dx%d ", TEST_SOURCES
, TEST_LEN
);
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");
132 if (posix_memalign(&buf
, 16, 2 * (6 * TEST_SOURCES
* 32))) {
133 printf("alloc error: Fail");
138 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
139 printf("alloc error: Fail");
144 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
145 printf("alloc error: Fail");
150 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
151 printf("alloc error: Fail");
156 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
157 printf("alloc error: Fail");
162 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
163 printf("alloc error: Fail");
168 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
169 printf("alloc error: Fail");
174 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
175 printf("alloc error: Fail");
180 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
181 printf("alloc error: Fail");
186 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
187 printf("alloc error: Fail");
192 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
193 printf("alloc error: Fail");
198 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
199 printf("alloc error: Fail");
204 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
205 printf("alloc error: Fail");
210 dest_ptrs
[0] = dest1
;
211 dest_ptrs
[1] = dest2
;
212 dest_ptrs
[2] = dest3
;
213 dest_ptrs
[3] = dest4
;
214 dest_ptrs
[4] = dest5
;
215 dest_ptrs
[5] = dest6
;
218 for (i
= 0; i
< TEST_SOURCES
; i
++)
219 memset(buffs
[i
], 0, TEST_LEN
);
221 memset(dest1
, 0, TEST_LEN
);
222 memset(dest2
, 0, TEST_LEN
);
223 memset(dest3
, 0, TEST_LEN
);
224 memset(dest4
, 0, TEST_LEN
);
225 memset(dest5
, 0, TEST_LEN
);
226 memset(dest6
, 0, TEST_LEN
);
227 memset(dest_ref1
, 0, TEST_LEN
);
228 memset(dest_ref2
, 0, TEST_LEN
);
229 memset(dest_ref3
, 0, TEST_LEN
);
230 memset(dest_ref4
, 0, TEST_LEN
);
231 memset(dest_ref5
, 0, TEST_LEN
);
232 memset(dest_ref6
, 0, TEST_LEN
);
233 memset(g1
, 2, TEST_SOURCES
);
234 memset(g2
, 1, TEST_SOURCES
);
235 memset(g3
, 7, TEST_SOURCES
);
236 memset(g4
, 9, TEST_SOURCES
);
237 memset(g5
, 4, TEST_SOURCES
);
238 memset(g6
, 0xe6, TEST_SOURCES
);
240 for (i
= 0; i
< TEST_SOURCES
; i
++) {
241 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
242 gf_vect_mul_init(g2
[i
], &g_tbls
[32 * TEST_SOURCES
+ i
* 32]);
243 gf_vect_mul_init(g3
[i
], &g_tbls
[64 * TEST_SOURCES
+ i
* 32]);
244 gf_vect_mul_init(g4
[i
], &g_tbls
[96 * TEST_SOURCES
+ i
* 32]);
245 gf_vect_mul_init(g5
[i
], &g_tbls
[128 * TEST_SOURCES
+ i
* 32]);
246 gf_vect_mul_init(g6
[i
], &g_tbls
[160 * TEST_SOURCES
+ i
* 32]);
249 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[0], buffs
, dest_ref1
);
250 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[32 * TEST_SOURCES
], buffs
,
252 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[64 * TEST_SOURCES
], buffs
,
254 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[96 * TEST_SOURCES
], buffs
,
256 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[128 * TEST_SOURCES
], buffs
,
258 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[160 * TEST_SOURCES
], buffs
,
261 FUNCTION_UNDER_TEST(TEST_LEN
, TEST_SOURCES
, g_tbls
, buffs
, dest_ptrs
);
263 if (0 != memcmp(dest_ref1
, dest1
, TEST_LEN
)) {
264 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test1\n");
265 dump_matrix(buffs
, 5, TEST_SOURCES
);
266 printf("dprod_base:");
268 printf("dprod_dut:");
272 if (0 != memcmp(dest_ref2
, dest2
, TEST_LEN
)) {
273 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test2\n");
274 dump_matrix(buffs
, 5, TEST_SOURCES
);
275 printf("dprod_base:");
277 printf("dprod_dut:");
281 if (0 != memcmp(dest_ref3
, dest3
, TEST_LEN
)) {
282 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test3\n");
283 dump_matrix(buffs
, 5, TEST_SOURCES
);
284 printf("dprod_base:");
286 printf("dprod_dut:");
290 if (0 != memcmp(dest_ref4
, dest4
, TEST_LEN
)) {
291 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test4\n");
292 dump_matrix(buffs
, 5, TEST_SOURCES
);
293 printf("dprod_base:");
295 printf("dprod_dut:");
299 if (0 != memcmp(dest_ref5
, dest5
, TEST_LEN
)) {
300 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test5\n");
301 dump_matrix(buffs
, 5, TEST_SOURCES
);
302 printf("dprod_base:");
304 printf("dprod_dut:");
308 if (0 != memcmp(dest_ref6
, dest6
, TEST_LEN
)) {
309 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test6\n");
310 dump_matrix(buffs
, 5, TEST_SOURCES
);
311 printf("dprod_base:");
313 printf("dprod_dut:");
321 for (rtest
= 0; rtest
< RANDOMS
; rtest
++) {
322 for (i
= 0; i
< TEST_SOURCES
; i
++)
323 for (j
= 0; j
< TEST_LEN
; j
++)
324 buffs
[i
][j
] = rand();
326 for (i
= 0; i
< TEST_SOURCES
; i
++) {
335 for (i
= 0; i
< TEST_SOURCES
; i
++) {
336 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
337 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * TEST_SOURCES
) + (i
* 32)]);
338 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * TEST_SOURCES
) + (i
* 32)]);
339 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * TEST_SOURCES
) + (i
* 32)]);
340 gf_vect_mul_init(g5
[i
], &g_tbls
[(128 * TEST_SOURCES
) + (i
* 32)]);
341 gf_vect_mul_init(g6
[i
], &g_tbls
[(160 * TEST_SOURCES
) + (i
* 32)]);
344 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[0], buffs
, dest_ref1
);
345 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[32 * TEST_SOURCES
],
347 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[64 * TEST_SOURCES
],
349 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[96 * TEST_SOURCES
],
351 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[128 * TEST_SOURCES
],
353 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[160 * TEST_SOURCES
],
356 FUNCTION_UNDER_TEST(TEST_LEN
, TEST_SOURCES
, g_tbls
, buffs
, dest_ptrs
);
358 if (0 != memcmp(dest_ref1
, dest1
, TEST_LEN
)) {
359 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test1 %d\n", rtest
);
360 dump_matrix(buffs
, 5, TEST_SOURCES
);
361 printf("dprod_base:");
363 printf("dprod_dut:");
367 if (0 != memcmp(dest_ref2
, dest2
, TEST_LEN
)) {
368 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test2 %d\n", rtest
);
369 dump_matrix(buffs
, 5, TEST_SOURCES
);
370 printf("dprod_base:");
372 printf("dprod_dut:");
376 if (0 != memcmp(dest_ref3
, dest3
, TEST_LEN
)) {
377 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test3 %d\n", rtest
);
378 dump_matrix(buffs
, 5, TEST_SOURCES
);
379 printf("dprod_base:");
381 printf("dprod_dut:");
385 if (0 != memcmp(dest_ref4
, dest4
, TEST_LEN
)) {
386 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test4 %d\n", rtest
);
387 dump_matrix(buffs
, 5, TEST_SOURCES
);
388 printf("dprod_base:");
390 printf("dprod_dut:");
394 if (0 != memcmp(dest_ref5
, dest5
, TEST_LEN
)) {
395 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test5 %d\n", rtest
);
396 dump_matrix(buffs
, 5, TEST_SOURCES
);
397 printf("dprod_base:");
399 printf("dprod_dut:");
403 if (0 != memcmp(dest_ref6
, dest6
, TEST_LEN
)) {
404 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test6 %d\n", rtest
);
405 dump_matrix(buffs
, 5, TEST_SOURCES
);
406 printf("dprod_base:");
408 printf("dprod_dut:");
416 // Rand data test with varied parameters
417 for (rtest
= 0; rtest
< RANDOMS
; rtest
++) {
418 for (srcs
= TEST_SOURCES
; srcs
> 0; srcs
--) {
419 for (i
= 0; i
< srcs
; i
++)
420 for (j
= 0; j
< TEST_LEN
; j
++)
421 buffs
[i
][j
] = rand();
423 for (i
= 0; i
< srcs
; i
++) {
432 for (i
= 0; i
< srcs
; i
++) {
433 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
434 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * srcs
) + (i
* 32)]);
435 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * srcs
) + (i
* 32)]);
436 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * srcs
) + (i
* 32)]);
437 gf_vect_mul_init(g5
[i
], &g_tbls
[(128 * srcs
) + (i
* 32)]);
438 gf_vect_mul_init(g6
[i
], &g_tbls
[(160 * srcs
) + (i
* 32)]);
441 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[0], buffs
, dest_ref1
);
442 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[32 * srcs
], buffs
,
444 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[64 * srcs
], buffs
,
446 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[96 * srcs
], buffs
,
448 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[128 * srcs
], buffs
,
450 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[160 * srcs
], buffs
,
453 FUNCTION_UNDER_TEST(TEST_LEN
, srcs
, g_tbls
, buffs
, dest_ptrs
);
455 if (0 != memcmp(dest_ref1
, dest1
, TEST_LEN
)) {
456 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
457 " test1 srcs=%d\n", srcs
);
458 dump_matrix(buffs
, 5, TEST_SOURCES
);
459 printf("dprod_base:");
461 printf("dprod_dut:");
465 if (0 != memcmp(dest_ref2
, dest2
, TEST_LEN
)) {
466 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
467 " test2 srcs=%d\n", srcs
);
468 dump_matrix(buffs
, 5, TEST_SOURCES
);
469 printf("dprod_base:");
471 printf("dprod_dut:");
475 if (0 != memcmp(dest_ref3
, dest3
, TEST_LEN
)) {
476 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
477 " test3 srcs=%d\n", srcs
);
478 dump_matrix(buffs
, 5, TEST_SOURCES
);
479 printf("dprod_base:");
481 printf("dprod_dut:");
485 if (0 != memcmp(dest_ref4
, dest4
, TEST_LEN
)) {
486 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
487 " test4 srcs=%d\n", srcs
);
488 dump_matrix(buffs
, 5, TEST_SOURCES
);
489 printf("dprod_base:");
491 printf("dprod_dut:");
495 if (0 != memcmp(dest_ref5
, dest5
, TEST_LEN
)) {
496 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
497 " test5 srcs=%d\n", srcs
);
498 dump_matrix(buffs
, 5, TEST_SOURCES
);
499 printf("dprod_base:");
501 printf("dprod_dut:");
505 if (0 != memcmp(dest_ref6
, dest6
, TEST_LEN
)) {
506 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
507 " test6 srcs=%d\n", srcs
);
508 dump_matrix(buffs
, 5, TEST_SOURCES
);
509 printf("dprod_base:");
511 printf("dprod_dut:");
520 // Run tests at end of buffer for Electric Fence
521 align
= (LEN_ALIGN_CHK_B
!= 0) ? 1 : 16;
522 for (size
= TEST_MIN_SIZE
; size
<= TEST_SIZE
; size
+= align
) {
523 for (i
= 0; i
< TEST_SOURCES
; i
++)
524 for (j
= 0; j
< TEST_LEN
; j
++)
525 buffs
[i
][j
] = rand();
527 for (i
= 0; i
< TEST_SOURCES
; i
++) // Line up TEST_SIZE from end
528 efence_buffs
[i
] = buffs
[i
] + TEST_LEN
- size
;
530 for (i
= 0; i
< TEST_SOURCES
; i
++) {
539 for (i
= 0; i
< TEST_SOURCES
; i
++) {
540 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
541 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * TEST_SOURCES
) + (i
* 32)]);
542 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * TEST_SOURCES
) + (i
* 32)]);
543 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * TEST_SOURCES
) + (i
* 32)]);
544 gf_vect_mul_init(g5
[i
], &g_tbls
[(128 * TEST_SOURCES
) + (i
* 32)]);
545 gf_vect_mul_init(g6
[i
], &g_tbls
[(160 * TEST_SOURCES
) + (i
* 32)]);
548 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[0], efence_buffs
, dest_ref1
);
549 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[32 * TEST_SOURCES
],
550 efence_buffs
, dest_ref2
);
551 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[64 * TEST_SOURCES
],
552 efence_buffs
, dest_ref3
);
553 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[96 * TEST_SOURCES
],
554 efence_buffs
, dest_ref4
);
555 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[128 * TEST_SOURCES
],
556 efence_buffs
, dest_ref5
);
557 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[160 * TEST_SOURCES
],
558 efence_buffs
, dest_ref6
);
560 FUNCTION_UNDER_TEST(size
, TEST_SOURCES
, g_tbls
, efence_buffs
, dest_ptrs
);
562 if (0 != memcmp(dest_ref1
, dest1
, size
)) {
563 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test1 %d\n", rtest
);
564 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
565 printf("dprod_base:");
566 dump(dest_ref1
, align
);
567 printf("dprod_dut:");
572 if (0 != memcmp(dest_ref2
, dest2
, size
)) {
573 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test2 %d\n", rtest
);
574 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
575 printf("dprod_base:");
576 dump(dest_ref2
, align
);
577 printf("dprod_dut:");
582 if (0 != memcmp(dest_ref3
, dest3
, size
)) {
583 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test3 %d\n", rtest
);
584 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
585 printf("dprod_base:");
586 dump(dest_ref3
, align
);
587 printf("dprod_dut:");
592 if (0 != memcmp(dest_ref4
, dest4
, size
)) {
593 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test4 %d\n", rtest
);
594 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
595 printf("dprod_base:");
596 dump(dest_ref4
, align
);
597 printf("dprod_dut:");
602 if (0 != memcmp(dest_ref5
, dest5
, size
)) {
603 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test5 %d\n", rtest
);
604 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
605 printf("dprod_base:");
606 dump(dest_ref5
, align
);
607 printf("dprod_dut:");
612 if (0 != memcmp(dest_ref6
, dest6
, size
)) {
613 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test6 %d\n", rtest
);
614 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
615 printf("dprod_base:");
616 dump(dest_ref6
, align
);
617 printf("dprod_dut:");
625 // Test rand ptr alignment if available
627 for (rtest
= 0; rtest
< RANDOMS
; rtest
++) {
628 size
= (TEST_LEN
- PTR_ALIGN_CHK_B
) & ~(TEST_MIN_SIZE
- 1);
629 srcs
= rand() % TEST_SOURCES
;
633 offset
= (PTR_ALIGN_CHK_B
!= 0) ? 1 : PTR_ALIGN_CHK_B
;
634 // Add random offsets
635 for (i
= 0; i
< srcs
; i
++)
636 ubuffs
[i
] = buffs
[i
] + (rand() & (PTR_ALIGN_CHK_B
- offset
));
638 udest_ptrs
[0] = dest1
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
639 udest_ptrs
[1] = dest2
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
640 udest_ptrs
[2] = dest3
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
641 udest_ptrs
[3] = dest4
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
642 udest_ptrs
[4] = dest5
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
643 udest_ptrs
[5] = dest6
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
645 memset(dest1
, 0, TEST_LEN
); // zero pad to check write-over
646 memset(dest2
, 0, TEST_LEN
);
647 memset(dest3
, 0, TEST_LEN
);
648 memset(dest4
, 0, TEST_LEN
);
649 memset(dest5
, 0, TEST_LEN
);
650 memset(dest6
, 0, TEST_LEN
);
652 for (i
= 0; i
< srcs
; i
++)
653 for (j
= 0; j
< size
; j
++)
654 ubuffs
[i
][j
] = rand();
656 for (i
= 0; i
< srcs
; i
++) {
665 for (i
= 0; i
< srcs
; i
++) {
666 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
667 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * srcs
) + (i
* 32)]);
668 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * srcs
) + (i
* 32)]);
669 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * srcs
) + (i
* 32)]);
670 gf_vect_mul_init(g5
[i
], &g_tbls
[(128 * srcs
) + (i
* 32)]);
671 gf_vect_mul_init(g6
[i
], &g_tbls
[(160 * srcs
) + (i
* 32)]);
674 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[0], ubuffs
, dest_ref1
);
675 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[32 * srcs
], ubuffs
, dest_ref2
);
676 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[64 * srcs
], ubuffs
, dest_ref3
);
677 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[96 * srcs
], ubuffs
, dest_ref4
);
678 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[128 * srcs
], ubuffs
, dest_ref5
);
679 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[160 * srcs
], ubuffs
, dest_ref6
);
681 FUNCTION_UNDER_TEST(size
, srcs
, g_tbls
, ubuffs
, udest_ptrs
);
683 if (memcmp(dest_ref1
, udest_ptrs
[0], size
)) {
684 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
686 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
687 printf("dprod_base:");
689 printf("dprod_dut:");
690 dump(udest_ptrs
[0], 25);
693 if (memcmp(dest_ref2
, udest_ptrs
[1], size
)) {
694 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
696 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
697 printf("dprod_base:");
699 printf("dprod_dut:");
700 dump(udest_ptrs
[1], 25);
703 if (memcmp(dest_ref3
, udest_ptrs
[2], size
)) {
704 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
706 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
707 printf("dprod_base:");
709 printf("dprod_dut:");
710 dump(udest_ptrs
[2], 25);
713 if (memcmp(dest_ref4
, udest_ptrs
[3], size
)) {
714 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
716 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
717 printf("dprod_base:");
719 printf("dprod_dut:");
720 dump(udest_ptrs
[3], 25);
723 if (memcmp(dest_ref5
, udest_ptrs
[4], size
)) {
724 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
726 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
727 printf("dprod_base:");
729 printf("dprod_dut:");
730 dump(udest_ptrs
[4], 25);
733 if (memcmp(dest_ref6
, udest_ptrs
[5], size
)) {
734 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
736 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
737 printf("dprod_base:");
739 printf("dprod_dut:");
740 dump(udest_ptrs
[5], 25);
743 // Confirm that padding around dests is unchanged
744 memset(dest_ref1
, 0, PTR_ALIGN_CHK_B
); // Make reference zero buff
745 offset
= udest_ptrs
[0] - dest1
;
747 if (memcmp(dest1
, dest_ref1
, offset
)) {
748 printf("Fail rand ualign pad1 start\n");
751 if (memcmp(dest1
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
752 printf("Fail rand ualign pad1 end\n");
756 offset
= udest_ptrs
[1] - dest2
;
757 if (memcmp(dest2
, dest_ref1
, offset
)) {
758 printf("Fail rand ualign pad2 start\n");
761 if (memcmp(dest2
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
762 printf("Fail rand ualign pad2 end\n");
766 offset
= udest_ptrs
[2] - dest3
;
767 if (memcmp(dest3
, dest_ref1
, offset
)) {
768 printf("Fail rand ualign pad3 start\n");
771 if (memcmp(dest3
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
772 printf("Fail rand ualign pad3 end\n");
776 offset
= udest_ptrs
[3] - dest4
;
777 if (memcmp(dest4
, dest_ref1
, offset
)) {
778 printf("Fail rand ualign pad4 start\n");
781 if (memcmp(dest4
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
782 printf("Fail rand ualign pad4 end\n");
786 offset
= udest_ptrs
[4] - dest5
;
787 if (memcmp(dest5
, dest_ref1
, offset
)) {
788 printf("Fail rand ualign pad5 start\n");
791 if (memcmp(dest5
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
792 printf("Fail rand ualign pad5 end\n");
796 offset
= udest_ptrs
[5] - dest6
;
797 if (memcmp(dest6
, dest_ref1
, offset
)) {
798 printf("Fail rand ualign pad6 start\n");
801 if (memcmp(dest6
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
802 printf("Fail rand ualign pad6 end\n");
809 // Test all size alignment
810 align
= (LEN_ALIGN_CHK_B
!= 0) ? 1 : 16;
812 for (size
= TEST_LEN
; size
>= TEST_MIN_SIZE
; size
-= align
) {
815 for (i
= 0; i
< srcs
; i
++)
816 for (j
= 0; j
< size
; j
++)
817 buffs
[i
][j
] = rand();
819 for (i
= 0; i
< srcs
; i
++) {
828 for (i
= 0; i
< srcs
; i
++) {
829 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
830 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * srcs
) + (i
* 32)]);
831 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * srcs
) + (i
* 32)]);
832 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * srcs
) + (i
* 32)]);
833 gf_vect_mul_init(g5
[i
], &g_tbls
[(128 * srcs
) + (i
* 32)]);
834 gf_vect_mul_init(g6
[i
], &g_tbls
[(160 * srcs
) + (i
* 32)]);
837 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[0], buffs
, dest_ref1
);
838 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[32 * srcs
], buffs
, dest_ref2
);
839 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[64 * srcs
], buffs
, dest_ref3
);
840 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[96 * srcs
], buffs
, dest_ref4
);
841 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[128 * srcs
], buffs
, dest_ref5
);
842 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[160 * srcs
], buffs
, dest_ref6
);
844 FUNCTION_UNDER_TEST(size
, srcs
, g_tbls
, buffs
, dest_ptrs
);
846 if (memcmp(dest_ref1
, dest_ptrs
[0], size
)) {
847 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
849 dump_matrix(buffs
, 5, TEST_SOURCES
);
850 printf("dprod_base:");
852 printf("dprod_dut:");
853 dump(dest_ptrs
[0], 25);
856 if (memcmp(dest_ref2
, dest_ptrs
[1], size
)) {
857 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
859 dump_matrix(buffs
, 5, TEST_SOURCES
);
860 printf("dprod_base:");
862 printf("dprod_dut:");
863 dump(dest_ptrs
[1], 25);
866 if (memcmp(dest_ref3
, dest_ptrs
[2], size
)) {
867 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
869 dump_matrix(buffs
, 5, TEST_SOURCES
);
870 printf("dprod_base:");
872 printf("dprod_dut:");
873 dump(dest_ptrs
[2], 25);
876 if (memcmp(dest_ref4
, dest_ptrs
[3], size
)) {
877 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
879 dump_matrix(buffs
, 5, TEST_SOURCES
);
880 printf("dprod_base:");
882 printf("dprod_dut:");
883 dump(dest_ptrs
[3], 25);
886 if (memcmp(dest_ref5
, dest_ptrs
[4], size
)) {
887 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
889 dump_matrix(buffs
, 5, TEST_SOURCES
);
890 printf("dprod_base:");
892 printf("dprod_dut:");
893 dump(dest_ptrs
[4], 25);
896 if (memcmp(dest_ref6
, dest_ptrs
[5], size
)) {
897 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
899 dump_matrix(buffs
, 5, TEST_SOURCES
);
900 printf("dprod_base:");
902 printf("dprod_dut:");
903 dump(dest_ptrs
[5], 25);