ceph/src/isa-l/erasure_code/gf_6vect_dot_prod_sse_test.c

   1 /**********************************************************************
   2   Copyright(c) 2011-2015 Intel Corporation All rights reserved.
   3
   4   Redistribution and use in source and binary forms, with or without
   5   modification, are permitted provided that the following conditions
   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_6vect_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], 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];
 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[6];
 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         dest6 = buf;
 173
 174         if (posix_memalign(&buf, 64, TEST_LEN)) {
 175                 printf("alloc error: Fail");
 176                 return -1;
 177         }
 178         dest_ref1 = buf;
 179
 180         if (posix_memalign(&buf, 64, TEST_LEN)) {
 181                 printf("alloc error: Fail");
 182                 return -1;
 183         }
 184         dest_ref2 = buf;
 185
 186         if (posix_memalign(&buf, 64, TEST_LEN)) {
 187                 printf("alloc error: Fail");
 188                 return -1;
 189         }
 190         dest_ref3 = buf;
 191
 192         if (posix_memalign(&buf, 64, TEST_LEN)) {
 193                 printf("alloc error: Fail");
 194                 return -1;
 195         }
 196         dest_ref4 = buf;
 197
 198         if (posix_memalign(&buf, 64, TEST_LEN)) {
 199                 printf("alloc error: Fail");
 200                 return -1;
 201         }
 202         dest_ref5 = buf;
 203
 204         if (posix_memalign(&buf, 64, TEST_LEN)) {
 205                 printf("alloc error: Fail");
 206                 return -1;
 207         }
 208         dest_ref6 = buf;
 209
 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;
 216
 217         // Test of all zeros
 218         for (i = 0; i < TEST_SOURCES; i++)
 219                 memset(buffs[i], 0, TEST_LEN);
 220
 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);
 239
 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]);
 247         }
 248
 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,
 251                               dest_ref2);
 252         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES], buffs,
 253                               dest_ref3);
 254         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES], buffs,
 255                               dest_ref4);
 256         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[128 * TEST_SOURCES], buffs,
 257                               dest_ref5);
 258         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[160 * TEST_SOURCES], buffs,
 259                               dest_ref6);
 260
 261         FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
 262
 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:");
 267                 dump(dest_ref1, 25);
 268                 printf("dprod_dut:");
 269                 dump(dest1, 25);
 270                 return -1;
 271         }
 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:");
 276                 dump(dest_ref2, 25);
 277                 printf("dprod_dut:");
 278                 dump(dest2, 25);
 279                 return -1;
 280         }
 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:");
 285                 dump(dest_ref3, 25);
 286                 printf("dprod_dut:");
 287                 dump(dest3, 25);
 288                 return -1;
 289         }
 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:");
 294                 dump(dest_ref4, 25);
 295                 printf("dprod_dut:");
 296                 dump(dest4, 25);
 297                 return -1;
 298         }
 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:");
 303                 dump(dest_ref5, 25);
 304                 printf("dprod_dut:");
 305                 dump(dest5, 25);
 306                 return -1;
 307         }
 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:");
 312                 dump(dest_ref6, 25);
 313                 printf("dprod_dut:");
 314                 dump(dest6, 25);
 315                 return -1;
 316         }
 317         putchar('.');
 318
 319         // Rand data test
 320
 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();
 325
 326                 for (i = 0; i < TEST_SOURCES; i++) {
 327                         g1[i] = rand();
 328                         g2[i] = rand();
 329                         g3[i] = rand();
 330                         g4[i] = rand();
 331                         g5[i] = rand();
 332                         g6[i] = rand();
 333                 }
 334
 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)]);
 342                 }
 343
 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],
 346                                       buffs, dest_ref2);
 347                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES],
 348                                       buffs, dest_ref3);
 349                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES],
 350                                       buffs, dest_ref4);
 351                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[128 * TEST_SOURCES],
 352                                       buffs, dest_ref5);
 353                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[160 * TEST_SOURCES],
 354                                       buffs, dest_ref6);
 355
 356                 FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
 357
 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:");
 362                         dump(dest_ref1, 25);
 363                         printf("dprod_dut:");
 364                         dump(dest1, 25);
 365                         return -1;
 366                 }
 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:");
 371                         dump(dest_ref2, 25);
 372                         printf("dprod_dut:");
 373                         dump(dest2, 25);
 374                         return -1;
 375                 }
 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:");
 380                         dump(dest_ref3, 25);
 381                         printf("dprod_dut:");
 382                         dump(dest3, 25);
 383                         return -1;
 384                 }
 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:");
 389                         dump(dest_ref4, 25);
 390                         printf("dprod_dut:");
 391                         dump(dest4, 25);
 392                         return -1;
 393                 }
 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:");
 398                         dump(dest_ref5, 25);
 399                         printf("dprod_dut:");
 400                         dump(dest5, 25);
 401                         return -1;
 402                 }
 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:");
 407                         dump(dest_ref6, 25);
 408                         printf("dprod_dut:");
 409                         dump(dest6, 25);
 410                         return -1;
 411                 }
 412
 413                 putchar('.');
 414         }
 415
 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();
 422
 423                         for (i = 0; i < srcs; i++) {
 424                                 g1[i] = rand();
 425                                 g2[i] = rand();
 426                                 g3[i] = rand();
 427                                 g4[i] = rand();
 428                                 g5[i] = rand();
 429                                 g6[i] = rand();
 430                         }
 431
 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)]);
 439                         }
 440
 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,
 443                                               dest_ref2);
 444                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[64 * srcs], buffs,
 445                                               dest_ref3);
 446                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[96 * srcs], buffs,
 447                                               dest_ref4);
 448                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[128 * srcs], buffs,
 449                                               dest_ref5);
 450                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[160 * srcs], buffs,
 451                                               dest_ref6);
 452
 453                         FUNCTION_UNDER_TEST(TEST_LEN, srcs, g_tbls, buffs, dest_ptrs);
 454
 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:");
 460                                 dump(dest_ref1, 25);
 461                                 printf("dprod_dut:");
 462                                 dump(dest1, 25);
 463                                 return -1;
 464                         }
 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:");
 470                                 dump(dest_ref2, 25);
 471                                 printf("dprod_dut:");
 472                                 dump(dest2, 25);
 473                                 return -1;
 474                         }
 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:");
 480                                 dump(dest_ref3, 25);
 481                                 printf("dprod_dut:");
 482                                 dump(dest3, 25);
 483                                 return -1;
 484                         }
 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:");
 490                                 dump(dest_ref4, 25);
 491                                 printf("dprod_dut:");
 492                                 dump(dest4, 25);
 493                                 return -1;
 494                         }
 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:");
 500                                 dump(dest_ref5, 25);
 501                                 printf("dprod_dut:");
 502                                 dump(dest5, 25);
 503                                 return -1;
 504                         }
 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:");
 510                                 dump(dest_ref6, 25);
 511                                 printf("dprod_dut:");
 512                                 dump(dest6, 25);
 513                                 return -1;
 514                         }
 515
 516                         putchar('.');
 517                 }
 518         }
 519
 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();
 526
 527                 for (i = 0; i < TEST_SOURCES; i++)      // Line up TEST_SIZE from end
 528                         efence_buffs[i] = buffs[i] + TEST_LEN - size;
 529
 530                 for (i = 0; i < TEST_SOURCES; i++) {
 531                         g1[i] = rand();
 532                         g2[i] = rand();
 533                         g3[i] = rand();
 534                         g4[i] = rand();
 535                         g5[i] = rand();
 536                         g6[i] = rand();
 537                 }
 538
 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)]);
 546                 }
 547
 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);
 559
 560                 FUNCTION_UNDER_TEST(size, TEST_SOURCES, g_tbls, efence_buffs, dest_ptrs);
 561
 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:");
 568                         dump(dest1, align);
 569                         return -1;
 570                 }
 571
 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:");
 578                         dump(dest2, align);
 579                         return -1;
 580                 }
 581
 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:");
 588                         dump(dest3, align);
 589                         return -1;
 590                 }
 591
 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:");
 598                         dump(dest4, align);
 599                         return -1;
 600                 }
 601
 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:");
 608                         dump(dest5, align);
 609                         return -1;
 610                 }
 611
 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:");
 618                         dump(dest6, align);
 619                         return -1;
 620                 }
 621
 622                 putchar('.');
 623         }
 624
 625         // Test rand ptr alignment if available
 626
 627         for (rtest = 0; rtest < RANDOMS; rtest++) {
 628                 size = (TEST_LEN - PTR_ALIGN_CHK_B) & ~(TEST_MIN_SIZE - 1);
 629                 srcs = rand() % TEST_SOURCES;
 630                 if (srcs == 0)
 631                         continue;
 632
 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));
 637
 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));
 644
 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);
 651
 652                 for (i = 0; i < srcs; i++)
 653                         for (j = 0; j < size; j++)
 654                                 ubuffs[i][j] = rand();
 655
 656                 for (i = 0; i < srcs; i++) {
 657                         g1[i] = rand();
 658                         g2[i] = rand();
 659                         g3[i] = rand();
 660                         g4[i] = rand();
 661                         g5[i] = rand();
 662                         g6[i] = rand();
 663                 }
 664
 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)]);
 672                 }
 673
 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);
 680
 681                 FUNCTION_UNDER_TEST(size, srcs, g_tbls, ubuffs, udest_ptrs);
 682
 683                 if (memcmp(dest_ref1, udest_ptrs[0], size)) {
 684                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 685                                srcs);
 686                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 687                         printf("dprod_base:");
 688                         dump(dest_ref1, 25);
 689                         printf("dprod_dut:");
 690                         dump(udest_ptrs[0], 25);
 691                         return -1;
 692                 }
 693                 if (memcmp(dest_ref2, udest_ptrs[1], size)) {
 694                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 695                                srcs);
 696                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 697                         printf("dprod_base:");
 698                         dump(dest_ref2, 25);
 699                         printf("dprod_dut:");
 700                         dump(udest_ptrs[1], 25);
 701                         return -1;
 702                 }
 703                 if (memcmp(dest_ref3, udest_ptrs[2], size)) {
 704                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 705                                srcs);
 706                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 707                         printf("dprod_base:");
 708                         dump(dest_ref3, 25);
 709                         printf("dprod_dut:");
 710                         dump(udest_ptrs[2], 25);
 711                         return -1;
 712                 }
 713                 if (memcmp(dest_ref4, udest_ptrs[3], size)) {
 714                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 715                                srcs);
 716                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 717                         printf("dprod_base:");
 718                         dump(dest_ref4, 25);
 719                         printf("dprod_dut:");
 720                         dump(udest_ptrs[3], 25);
 721                         return -1;
 722                 }
 723                 if (memcmp(dest_ref5, udest_ptrs[4], size)) {
 724                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 725                                srcs);
 726                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 727                         printf("dprod_base:");
 728                         dump(dest_ref5, 25);
 729                         printf("dprod_dut:");
 730                         dump(udest_ptrs[4], 25);
 731                         return -1;
 732                 }
 733                 if (memcmp(dest_ref6, udest_ptrs[5], size)) {
 734                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 735                                srcs);
 736                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 737                         printf("dprod_base:");
 738                         dump(dest_ref6, 25);
 739                         printf("dprod_dut:");
 740                         dump(udest_ptrs[5], 25);
 741                         return -1;
 742                 }
 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;
 746
 747                 if (memcmp(dest1, dest_ref1, offset)) {
 748                         printf("Fail rand ualign pad1 start\n");
 749                         return -1;
 750                 }
 751                 if (memcmp(dest1 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 752                         printf("Fail rand ualign pad1 end\n");
 753                         return -1;
 754                 }
 755
 756                 offset = udest_ptrs[1] - dest2;
 757                 if (memcmp(dest2, dest_ref1, offset)) {
 758                         printf("Fail rand ualign pad2 start\n");
 759                         return -1;
 760                 }
 761                 if (memcmp(dest2 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 762                         printf("Fail rand ualign pad2 end\n");
 763                         return -1;
 764                 }
 765
 766                 offset = udest_ptrs[2] - dest3;
 767                 if (memcmp(dest3, dest_ref1, offset)) {
 768                         printf("Fail rand ualign pad3 start\n");
 769                         return -1;
 770                 }
 771                 if (memcmp(dest3 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 772                         printf("Fail rand ualign pad3 end\n");
 773                         return -1;
 774                 }
 775
 776                 offset = udest_ptrs[3] - dest4;
 777                 if (memcmp(dest4, dest_ref1, offset)) {
 778                         printf("Fail rand ualign pad4 start\n");
 779                         return -1;
 780                 }
 781                 if (memcmp(dest4 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 782                         printf("Fail rand ualign pad4 end\n");
 783                         return -1;
 784                 }
 785
 786                 offset = udest_ptrs[4] - dest5;
 787                 if (memcmp(dest5, dest_ref1, offset)) {
 788                         printf("Fail rand ualign pad5 start\n");
 789                         return -1;
 790                 }
 791                 if (memcmp(dest5 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 792                         printf("Fail rand ualign pad5 end\n");
 793                         return -1;
 794                 }
 795
 796                 offset = udest_ptrs[5] - dest6;
 797                 if (memcmp(dest6, dest_ref1, offset)) {
 798                         printf("Fail rand ualign pad6 start\n");
 799                         return -1;
 800                 }
 801                 if (memcmp(dest6 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 802                         printf("Fail rand ualign pad6 end\n");
 803                         return -1;
 804                 }
 805
 806                 putchar('.');
 807         }
 808
 809         // Test all size alignment
 810         align = (LEN_ALIGN_CHK_B != 0) ? 1 : 16;
 811
 812         for (size = TEST_LEN; size >= TEST_MIN_SIZE; size -= align) {
 813                 srcs = TEST_SOURCES;
 814
 815                 for (i = 0; i < srcs; i++)
 816                         for (j = 0; j < size; j++)
 817                                 buffs[i][j] = rand();
 818
 819                 for (i = 0; i < srcs; i++) {
 820                         g1[i] = rand();
 821                         g2[i] = rand();
 822                         g3[i] = rand();
 823                         g4[i] = rand();
 824                         g5[i] = rand();
 825                         g6[i] = rand();
 826                 }
 827
 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)]);
 835                 }
 836
 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);
 843
 844                 FUNCTION_UNDER_TEST(size, srcs, g_tbls, buffs, dest_ptrs);
 845
 846                 if (memcmp(dest_ref1, dest_ptrs[0], size)) {
 847                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 848                                size);
 849                         dump_matrix(buffs, 5, TEST_SOURCES);
 850                         printf("dprod_base:");
 851                         dump(dest_ref1, 25);
 852                         printf("dprod_dut:");
 853                         dump(dest_ptrs[0], 25);
 854                         return -1;
 855                 }
 856                 if (memcmp(dest_ref2, dest_ptrs[1], size)) {
 857                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 858                                size);
 859                         dump_matrix(buffs, 5, TEST_SOURCES);
 860                         printf("dprod_base:");
 861                         dump(dest_ref2, 25);
 862                         printf("dprod_dut:");
 863                         dump(dest_ptrs[1], 25);
 864                         return -1;
 865                 }
 866                 if (memcmp(dest_ref3, dest_ptrs[2], size)) {
 867                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 868                                size);
 869                         dump_matrix(buffs, 5, TEST_SOURCES);
 870                         printf("dprod_base:");
 871                         dump(dest_ref3, 25);
 872                         printf("dprod_dut:");
 873                         dump(dest_ptrs[2], 25);
 874                         return -1;
 875                 }
 876                 if (memcmp(dest_ref4, dest_ptrs[3], size)) {
 877                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 878                                size);
 879                         dump_matrix(buffs, 5, TEST_SOURCES);
 880                         printf("dprod_base:");
 881                         dump(dest_ref4, 25);
 882                         printf("dprod_dut:");
 883                         dump(dest_ptrs[3], 25);
 884                         return -1;
 885                 }
 886                 if (memcmp(dest_ref5, dest_ptrs[4], size)) {
 887                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 888                                size);
 889                         dump_matrix(buffs, 5, TEST_SOURCES);
 890                         printf("dprod_base:");
 891                         dump(dest_ref5, 25);
 892                         printf("dprod_dut:");
 893                         dump(dest_ptrs[4], 25);
 894                         return -1;
 895                 }
 896                 if (memcmp(dest_ref6, dest_ptrs[5], size)) {
 897                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 898                                size);
 899                         dump_matrix(buffs, 5, TEST_SOURCES);
 900                         printf("dprod_base:");
 901                         dump(dest_ref6, 25);
 902                         printf("dprod_dut:");
 903                         dump(dest_ptrs[5], 25);
 904                         return -1;
 905                 }
 906         }
 907
 908         printf("Pass\n");
 909         return 0;
 910
 911 }