]>
Commit | Line | Data |
---|---|---|
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 | ||
69 | typedef unsigned char u8; | |
70 | ||
71 | void 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 | ||
82 | void 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 | ||
94 | void 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 | ||
106 | int 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 | } |