]>
git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/isa-l/erasure_code/gf_4vect_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_4vect_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 10000
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 extern void FUNCTION_UNDER_TEST(int len
, int vlen
, unsigned char *gftbls
,
72 unsigned char **src
, unsigned char **dest
);
74 void dump(unsigned char *buf
, int len
)
77 for (i
= 0; i
< len
;) {
78 printf(" %2x", 0xff & buf
[i
++]);
85 void dump_matrix(unsigned char **s
, int k
, int m
)
88 for (i
= 0; i
< k
; i
++) {
89 for (j
= 0; j
< m
; j
++) {
90 printf(" %2x", s
[i
][j
]);
97 void dump_u8xu8(unsigned char *s
, int k
, int m
)
100 for (i
= 0; i
< k
; i
++) {
101 for (j
= 0; j
< m
; j
++) {
102 printf(" %2x", 0xff & s
[j
+ (i
* m
)]);
109 int main(int argc
, char *argv
[])
111 int i
, j
, rtest
, srcs
;
113 u8 g1
[TEST_SOURCES
], g2
[TEST_SOURCES
], g3
[TEST_SOURCES
];
114 u8 g4
[TEST_SOURCES
], g_tbls
[4 * TEST_SOURCES
* 32], *buffs
[TEST_SOURCES
];
115 u8
*dest1
, *dest2
, *dest3
, *dest4
, *dest_ref1
, *dest_ref2
, *dest_ref3
;
116 u8
*dest_ref4
, *dest_ptrs
[4];
119 unsigned char *efence_buffs
[TEST_SOURCES
];
121 u8
*ubuffs
[TEST_SOURCES
];
123 printf(xstr(FUNCTION_UNDER_TEST
) ": %dx%d ", TEST_SOURCES
, TEST_LEN
);
125 // Allocate the arrays
126 for (i
= 0; i
< TEST_SOURCES
; i
++) {
127 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
128 printf("alloc error: Fail");
134 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
135 printf("alloc error: Fail");
140 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
141 printf("alloc error: Fail");
146 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
147 printf("alloc error: Fail");
152 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
153 printf("alloc error: Fail");
158 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
159 printf("alloc error: Fail");
164 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
165 printf("alloc error: Fail");
170 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
171 printf("alloc error: Fail");
176 if (posix_memalign(&buf
, 64, TEST_LEN
)) {
177 printf("alloc error: Fail");
182 dest_ptrs
[0] = dest1
;
183 dest_ptrs
[1] = dest2
;
184 dest_ptrs
[2] = dest3
;
185 dest_ptrs
[3] = dest4
;
188 for (i
= 0; i
< TEST_SOURCES
; i
++)
189 memset(buffs
[i
], 0, TEST_LEN
);
191 memset(dest1
, 0, TEST_LEN
);
192 memset(dest2
, 0, TEST_LEN
);
193 memset(dest3
, 0, TEST_LEN
);
194 memset(dest4
, 0, TEST_LEN
);
195 memset(dest_ref1
, 0, TEST_LEN
);
196 memset(dest_ref2
, 0, TEST_LEN
);
197 memset(dest_ref3
, 0, TEST_LEN
);
198 memset(dest_ref4
, 0, TEST_LEN
);
199 memset(g1
, 2, TEST_SOURCES
);
200 memset(g2
, 1, TEST_SOURCES
);
201 memset(g3
, 7, TEST_SOURCES
);
202 memset(g4
, 3, TEST_SOURCES
);
204 for (i
= 0; i
< TEST_SOURCES
; i
++) {
205 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
206 gf_vect_mul_init(g2
[i
], &g_tbls
[32 * TEST_SOURCES
+ i
* 32]);
207 gf_vect_mul_init(g3
[i
], &g_tbls
[64 * TEST_SOURCES
+ i
* 32]);
208 gf_vect_mul_init(g4
[i
], &g_tbls
[96 * TEST_SOURCES
+ i
* 32]);
211 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[0], buffs
, dest_ref1
);
212 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[32 * TEST_SOURCES
], buffs
,
214 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[64 * TEST_SOURCES
], buffs
,
216 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[96 * TEST_SOURCES
], buffs
,
219 FUNCTION_UNDER_TEST(TEST_LEN
, TEST_SOURCES
, g_tbls
, buffs
, dest_ptrs
);
221 if (0 != memcmp(dest_ref1
, dest1
, TEST_LEN
)) {
222 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test1\n");
223 dump_matrix(buffs
, 5, TEST_SOURCES
);
224 printf("dprod_base:");
226 printf("dprod_dut:");
230 if (0 != memcmp(dest_ref2
, dest2
, TEST_LEN
)) {
231 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test2\n");
232 dump_matrix(buffs
, 5, TEST_SOURCES
);
233 printf("dprod_base:");
235 printf("dprod_dut:");
239 if (0 != memcmp(dest_ref3
, dest3
, TEST_LEN
)) {
240 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test3\n");
241 dump_matrix(buffs
, 5, TEST_SOURCES
);
242 printf("dprod_base:");
244 printf("dprod_dut:");
248 if (0 != memcmp(dest_ref4
, dest4
, TEST_LEN
)) {
249 printf("Fail zero " xstr(FUNCTION_UNDER_TEST
) " test4\n");
250 dump_matrix(buffs
, 5, TEST_SOURCES
);
251 printf("dprod_base:");
253 printf("dprod_dut:");
262 for (rtest
= 0; rtest
< RANDOMS
; rtest
++) {
263 for (i
= 0; i
< TEST_SOURCES
; i
++)
264 for (j
= 0; j
< TEST_LEN
; j
++)
265 buffs
[i
][j
] = rand();
267 for (i
= 0; i
< TEST_SOURCES
; i
++) {
274 for (i
= 0; i
< TEST_SOURCES
; i
++) {
275 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
276 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * TEST_SOURCES
) + (i
* 32)]);
277 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * TEST_SOURCES
) + (i
* 32)]);
278 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * TEST_SOURCES
) + (i
* 32)]);
281 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[0], buffs
, dest_ref1
);
282 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[32 * TEST_SOURCES
],
284 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[64 * TEST_SOURCES
],
286 gf_vect_dot_prod_base(TEST_LEN
, TEST_SOURCES
, &g_tbls
[96 * TEST_SOURCES
],
289 FUNCTION_UNDER_TEST(TEST_LEN
, TEST_SOURCES
, g_tbls
, buffs
, dest_ptrs
);
291 if (0 != memcmp(dest_ref1
, dest1
, TEST_LEN
)) {
292 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test1 %d\n", rtest
);
293 dump_matrix(buffs
, 5, TEST_SOURCES
);
294 printf("dprod_base:");
296 printf("dprod_dut:");
300 if (0 != memcmp(dest_ref2
, dest2
, TEST_LEN
)) {
301 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test2 %d\n", rtest
);
302 dump_matrix(buffs
, 5, TEST_SOURCES
);
303 printf("dprod_base:");
305 printf("dprod_dut:");
309 if (0 != memcmp(dest_ref3
, dest3
, TEST_LEN
)) {
310 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test3 %d\n", rtest
);
311 dump_matrix(buffs
, 5, TEST_SOURCES
);
312 printf("dprod_base:");
314 printf("dprod_dut:");
318 if (0 != memcmp(dest_ref4
, dest4
, TEST_LEN
)) {
319 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test4 %d\n", rtest
);
320 dump_matrix(buffs
, 5, TEST_SOURCES
);
321 printf("dprod_base:");
323 printf("dprod_dut:");
331 // Rand data test with varied parameters
332 for (rtest
= 0; rtest
< RANDOMS
; rtest
++) {
333 for (srcs
= TEST_SOURCES
; srcs
> 0; srcs
--) {
334 for (i
= 0; i
< srcs
; i
++)
335 for (j
= 0; j
< TEST_LEN
; j
++)
336 buffs
[i
][j
] = rand();
338 for (i
= 0; i
< srcs
; i
++) {
345 for (i
= 0; i
< srcs
; i
++) {
346 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
347 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * srcs
) + (i
* 32)]);
348 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * srcs
) + (i
* 32)]);
349 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * srcs
) + (i
* 32)]);
352 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[0], buffs
, dest_ref1
);
353 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[32 * srcs
], buffs
,
355 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[64 * srcs
], buffs
,
357 gf_vect_dot_prod_base(TEST_LEN
, srcs
, &g_tbls
[96 * srcs
], buffs
,
360 FUNCTION_UNDER_TEST(TEST_LEN
, srcs
, g_tbls
, buffs
, dest_ptrs
);
362 if (0 != memcmp(dest_ref1
, dest1
, TEST_LEN
)) {
363 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
364 " test1 srcs=%d\n", srcs
);
365 dump_matrix(buffs
, 5, TEST_SOURCES
);
366 printf("dprod_base:");
368 printf("dprod_dut:");
372 if (0 != memcmp(dest_ref2
, dest2
, TEST_LEN
)) {
373 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
374 " test2 srcs=%d\n", srcs
);
375 dump_matrix(buffs
, 5, TEST_SOURCES
);
376 printf("dprod_base:");
378 printf("dprod_dut:");
382 if (0 != memcmp(dest_ref3
, dest3
, TEST_LEN
)) {
383 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
384 " test3 srcs=%d\n", srcs
);
385 dump_matrix(buffs
, 5, TEST_SOURCES
);
386 printf("dprod_base:");
388 printf("dprod_dut:");
392 if (0 != memcmp(dest_ref4
, dest4
, TEST_LEN
)) {
393 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
)
394 " test4 srcs=%d\n", srcs
);
395 dump_matrix(buffs
, 5, TEST_SOURCES
);
396 printf("dprod_base:");
398 printf("dprod_dut:");
407 // Run tests at end of buffer for Electric Fence
408 align
= (LEN_ALIGN_CHK_B
!= 0) ? 1 : 32;
409 for (size
= TEST_MIN_SIZE
; size
<= TEST_SIZE
; size
+= align
) {
410 for (i
= 0; i
< TEST_SOURCES
; i
++)
411 for (j
= 0; j
< TEST_LEN
; j
++)
412 buffs
[i
][j
] = rand();
414 for (i
= 0; i
< TEST_SOURCES
; i
++) // Line up TEST_SIZE from end
415 efence_buffs
[i
] = buffs
[i
] + TEST_LEN
- size
;
417 for (i
= 0; i
< TEST_SOURCES
; i
++) {
424 for (i
= 0; i
< TEST_SOURCES
; i
++) {
425 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
426 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * TEST_SOURCES
) + (i
* 32)]);
427 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * TEST_SOURCES
) + (i
* 32)]);
428 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * TEST_SOURCES
) + (i
* 32)]);
431 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[0], efence_buffs
, dest_ref1
);
432 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[32 * TEST_SOURCES
],
433 efence_buffs
, dest_ref2
);
434 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[64 * TEST_SOURCES
],
435 efence_buffs
, dest_ref3
);
436 gf_vect_dot_prod_base(size
, TEST_SOURCES
, &g_tbls
[96 * TEST_SOURCES
],
437 efence_buffs
, dest_ref4
);
439 FUNCTION_UNDER_TEST(size
, TEST_SOURCES
, g_tbls
, efence_buffs
, dest_ptrs
);
441 if (0 != memcmp(dest_ref1
, dest1
, size
)) {
442 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test1 %d\n", rtest
);
443 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
444 printf("dprod_base:");
445 dump(dest_ref1
, align
);
446 printf("dprod_dut:");
451 if (0 != memcmp(dest_ref2
, dest2
, size
)) {
452 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test2 %d\n", rtest
);
453 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
454 printf("dprod_base:");
455 dump(dest_ref2
, align
);
456 printf("dprod_dut:");
461 if (0 != memcmp(dest_ref3
, dest3
, size
)) {
462 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test3 %d\n", rtest
);
463 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
464 printf("dprod_base:");
465 dump(dest_ref3
, align
);
466 printf("dprod_dut:");
471 if (0 != memcmp(dest_ref4
, dest4
, size
)) {
472 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test4 %d\n", rtest
);
473 dump_matrix(efence_buffs
, 5, TEST_SOURCES
);
474 printf("dprod_base:");
475 dump(dest_ref4
, align
);
476 printf("dprod_dut:");
484 // Test rand ptr alignment if available
486 for (rtest
= 0; rtest
< RANDOMS
; rtest
++) {
487 size
= (TEST_LEN
- PTR_ALIGN_CHK_B
) & ~(TEST_MIN_SIZE
- 1);
488 srcs
= rand() % TEST_SOURCES
;
492 offset
= (PTR_ALIGN_CHK_B
!= 0) ? 1 : PTR_ALIGN_CHK_B
;
493 // Add random offsets
494 for (i
= 0; i
< srcs
; i
++)
495 ubuffs
[i
] = buffs
[i
] + (rand() & (PTR_ALIGN_CHK_B
- offset
));
497 udest_ptrs
[0] = dest1
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
498 udest_ptrs
[1] = dest2
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
499 udest_ptrs
[2] = dest3
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
500 udest_ptrs
[3] = dest4
+ (rand() & (PTR_ALIGN_CHK_B
- offset
));
502 memset(dest1
, 0, TEST_LEN
); // zero pad to check write-over
503 memset(dest2
, 0, TEST_LEN
);
504 memset(dest3
, 0, TEST_LEN
);
505 memset(dest4
, 0, TEST_LEN
);
507 for (i
= 0; i
< srcs
; i
++)
508 for (j
= 0; j
< size
; j
++)
509 ubuffs
[i
][j
] = rand();
511 for (i
= 0; i
< srcs
; i
++) {
518 for (i
= 0; i
< srcs
; i
++) {
519 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
520 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * srcs
) + (i
* 32)]);
521 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * srcs
) + (i
* 32)]);
522 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * srcs
) + (i
* 32)]);
525 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[0], ubuffs
, dest_ref1
);
526 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[32 * srcs
], ubuffs
, dest_ref2
);
527 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[64 * srcs
], ubuffs
, dest_ref3
);
528 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[96 * srcs
], ubuffs
, dest_ref4
);
530 FUNCTION_UNDER_TEST(size
, srcs
, g_tbls
, ubuffs
, udest_ptrs
);
532 if (memcmp(dest_ref1
, udest_ptrs
[0], size
)) {
533 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
535 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
536 printf("dprod_base:");
538 printf("dprod_dut:");
539 dump(udest_ptrs
[0], 25);
542 if (memcmp(dest_ref2
, udest_ptrs
[1], size
)) {
543 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
545 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
546 printf("dprod_base:");
548 printf("dprod_dut:");
549 dump(udest_ptrs
[1], 25);
552 if (memcmp(dest_ref3
, udest_ptrs
[2], size
)) {
553 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
555 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
556 printf("dprod_base:");
558 printf("dprod_dut:");
559 dump(udest_ptrs
[2], 25);
562 if (memcmp(dest_ref4
, udest_ptrs
[3], size
)) {
563 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign srcs=%d\n",
565 dump_matrix(ubuffs
, 5, TEST_SOURCES
);
566 printf("dprod_base:");
568 printf("dprod_dut:");
569 dump(udest_ptrs
[3], 25);
572 // Confirm that padding around dests is unchanged
573 memset(dest_ref1
, 0, PTR_ALIGN_CHK_B
); // Make reference zero buff
574 offset
= udest_ptrs
[0] - dest1
;
576 if (memcmp(dest1
, dest_ref1
, offset
)) {
577 printf("Fail rand ualign pad1 start\n");
580 if (memcmp(dest1
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
581 printf("Fail rand ualign pad1 end\n");
582 printf("size=%d offset=%d srcs=%d\n", size
, offset
, srcs
);
586 offset
= udest_ptrs
[1] - dest2
;
587 if (memcmp(dest2
, dest_ref1
, offset
)) {
588 printf("Fail rand ualign pad2 start\n");
591 if (memcmp(dest2
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
592 printf("Fail rand ualign pad2 end\n");
596 offset
= udest_ptrs
[2] - dest3
;
597 if (memcmp(dest3
, dest_ref1
, offset
)) {
598 printf("Fail rand ualign pad3 start\n");
601 if (memcmp(dest3
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
602 printf("Fail rand ualign pad3 end\n");
606 offset
= udest_ptrs
[3] - dest4
;
607 if (memcmp(dest4
, dest_ref1
, offset
)) {
608 printf("Fail rand ualign pad4 start\n");
611 if (memcmp(dest4
+ offset
+ size
, dest_ref1
, PTR_ALIGN_CHK_B
- offset
)) {
612 printf("Fail rand ualign pad4 end\n");
619 // Test all size alignment
620 align
= (LEN_ALIGN_CHK_B
!= 0) ? 1 : 32;
622 for (size
= TEST_LEN
; size
>= TEST_MIN_SIZE
; size
-= align
) {
625 for (i
= 0; i
< srcs
; i
++)
626 for (j
= 0; j
< size
; j
++)
627 buffs
[i
][j
] = rand();
629 for (i
= 0; i
< srcs
; i
++) {
636 for (i
= 0; i
< srcs
; i
++) {
637 gf_vect_mul_init(g1
[i
], &g_tbls
[i
* 32]);
638 gf_vect_mul_init(g2
[i
], &g_tbls
[(32 * srcs
) + (i
* 32)]);
639 gf_vect_mul_init(g3
[i
], &g_tbls
[(64 * srcs
) + (i
* 32)]);
640 gf_vect_mul_init(g4
[i
], &g_tbls
[(96 * srcs
) + (i
* 32)]);
643 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[0], buffs
, dest_ref1
);
644 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[32 * srcs
], buffs
, dest_ref2
);
645 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[64 * srcs
], buffs
, dest_ref3
);
646 gf_vect_dot_prod_base(size
, srcs
, &g_tbls
[96 * srcs
], buffs
, dest_ref4
);
648 FUNCTION_UNDER_TEST(size
, srcs
, g_tbls
, buffs
, dest_ptrs
);
650 if (memcmp(dest_ref1
, dest_ptrs
[0], size
)) {
651 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
653 dump_matrix(buffs
, 5, TEST_SOURCES
);
654 printf("dprod_base:");
656 printf("dprod_dut:");
657 dump(dest_ptrs
[0], 25);
660 if (memcmp(dest_ref2
, dest_ptrs
[1], size
)) {
661 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
663 dump_matrix(buffs
, 5, TEST_SOURCES
);
664 printf("dprod_base:");
666 printf("dprod_dut:");
667 dump(dest_ptrs
[1], 25);
670 if (memcmp(dest_ref3
, dest_ptrs
[2], size
)) {
671 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
673 dump_matrix(buffs
, 5, TEST_SOURCES
);
674 printf("dprod_base:");
676 printf("dprod_dut:");
677 dump(dest_ptrs
[2], 25);
680 if (memcmp(dest_ref4
, dest_ptrs
[3], size
)) {
681 printf("Fail rand " xstr(FUNCTION_UNDER_TEST
) " test ualign len=%d\n",
683 dump_matrix(buffs
, 5, TEST_SOURCES
);
684 printf("dprod_base:");
686 printf("dprod_dut:");
687 dump(dest_ptrs
[3], 25);