ceph/src/isa-l/erasure_code/gf_4vect_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_4vect_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 10000
  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 extern void FUNCTION_UNDER_TEST(int len, int vlen, unsigned char *gftbls,
  72                                 unsigned char **src, unsigned char **dest);
  73
  74 void dump(unsigned char *buf, int len)
  75 {
  76         int i;
  77         for (i = 0; i < len;) {
  78                 printf(" %2x", 0xff & buf[i++]);
  79                 if (i % 32 == 0)
  80                         printf("\n");
  81         }
  82         printf("\n");
  83 }
  84
  85 void dump_matrix(unsigned char **s, int k, int m)
  86 {
  87         int i, j;
  88         for (i = 0; i < k; i++) {
  89                 for (j = 0; j < m; j++) {
  90                         printf(" %2x", s[i][j]);
  91                 }
  92                 printf("\n");
  93         }
  94         printf("\n");
  95 }
  96
  97 void dump_u8xu8(unsigned char *s, int k, int m)
  98 {
  99         int i, j;
 100         for (i = 0; i < k; i++) {
 101                 for (j = 0; j < m; j++) {
 102                         printf(" %2x", 0xff & s[j + (i * m)]);
 103                 }
 104                 printf("\n");
 105         }
 106         printf("\n");
 107 }
 108
 109 int main(int argc, char *argv[])
 110 {
 111         int i, j, rtest, srcs;
 112         void *buf;
 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];
 117
 118         int align, size;
 119         unsigned char *efence_buffs[TEST_SOURCES];
 120         unsigned int offset;
 121         u8 *ubuffs[TEST_SOURCES];
 122         u8 *udest_ptrs[4];
 123         printf(xstr(FUNCTION_UNDER_TEST) ": %dx%d ", TEST_SOURCES, TEST_LEN);
 124
 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");
 129                         return -1;
 130                 }
 131                 buffs[i] = buf;
 132         }
 133
 134         if (posix_memalign(&buf, 64, TEST_LEN)) {
 135                 printf("alloc error: Fail");
 136                 return -1;
 137         }
 138         dest1 = buf;
 139
 140         if (posix_memalign(&buf, 64, TEST_LEN)) {
 141                 printf("alloc error: Fail");
 142                 return -1;
 143         }
 144         dest2 = buf;
 145
 146         if (posix_memalign(&buf, 64, TEST_LEN)) {
 147                 printf("alloc error: Fail");
 148                 return -1;
 149         }
 150         dest3 = buf;
 151
 152         if (posix_memalign(&buf, 64, TEST_LEN)) {
 153                 printf("alloc error: Fail");
 154                 return -1;
 155         }
 156         dest4 = buf;
 157
 158         if (posix_memalign(&buf, 64, TEST_LEN)) {
 159                 printf("alloc error: Fail");
 160                 return -1;
 161         }
 162         dest_ref1 = buf;
 163
 164         if (posix_memalign(&buf, 64, TEST_LEN)) {
 165                 printf("alloc error: Fail");
 166                 return -1;
 167         }
 168         dest_ref2 = buf;
 169
 170         if (posix_memalign(&buf, 64, TEST_LEN)) {
 171                 printf("alloc error: Fail");
 172                 return -1;
 173         }
 174         dest_ref3 = buf;
 175
 176         if (posix_memalign(&buf, 64, TEST_LEN)) {
 177                 printf("alloc error: Fail");
 178                 return -1;
 179         }
 180         dest_ref4 = buf;
 181
 182         dest_ptrs[0] = dest1;
 183         dest_ptrs[1] = dest2;
 184         dest_ptrs[2] = dest3;
 185         dest_ptrs[3] = dest4;
 186
 187         // Test of all zeros
 188         for (i = 0; i < TEST_SOURCES; i++)
 189                 memset(buffs[i], 0, TEST_LEN);
 190
 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);
 203
 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]);
 209         }
 210
 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,
 213                               dest_ref2);
 214         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES], buffs,
 215                               dest_ref3);
 216         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES], buffs,
 217                               dest_ref4);
 218
 219         FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
 220
 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:");
 225                 dump(dest_ref1, 25);
 226                 printf("dprod_dut:");
 227                 dump(dest1, 25);
 228                 return -1;
 229         }
 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:");
 234                 dump(dest_ref2, 25);
 235                 printf("dprod_dut:");
 236                 dump(dest2, 25);
 237                 return -1;
 238         }
 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:");
 243                 dump(dest_ref3, 25);
 244                 printf("dprod_dut:");
 245                 dump(dest3, 25);
 246                 return -1;
 247         }
 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:");
 252                 dump(dest_ref4, 25);
 253                 printf("dprod_dut:");
 254                 dump(dest4, 25);
 255                 return -1;
 256         }
 257
 258         putchar('.');
 259
 260         // Rand data test
 261
 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();
 266
 267                 for (i = 0; i < TEST_SOURCES; i++) {
 268                         g1[i] = rand();
 269                         g2[i] = rand();
 270                         g3[i] = rand();
 271                         g4[i] = rand();
 272                 }
 273
 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)]);
 279                 }
 280
 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],
 283                                       buffs, dest_ref2);
 284                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES],
 285                                       buffs, dest_ref3);
 286                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[96 * TEST_SOURCES],
 287                                       buffs, dest_ref4);
 288
 289                 FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
 290
 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:");
 295                         dump(dest_ref1, 25);
 296                         printf("dprod_dut:");
 297                         dump(dest1, 25);
 298                         return -1;
 299                 }
 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:");
 304                         dump(dest_ref2, 25);
 305                         printf("dprod_dut:");
 306                         dump(dest2, 25);
 307                         return -1;
 308                 }
 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:");
 313                         dump(dest_ref3, 25);
 314                         printf("dprod_dut:");
 315                         dump(dest3, 25);
 316                         return -1;
 317                 }
 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:");
 322                         dump(dest_ref4, 25);
 323                         printf("dprod_dut:");
 324                         dump(dest4, 25);
 325                         return -1;
 326                 }
 327
 328                 putchar('.');
 329         }
 330
 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();
 337
 338                         for (i = 0; i < srcs; i++) {
 339                                 g1[i] = rand();
 340                                 g2[i] = rand();
 341                                 g3[i] = rand();
 342                                 g4[i] = rand();
 343                         }
 344
 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)]);
 350                         }
 351
 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,
 354                                               dest_ref2);
 355                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[64 * srcs], buffs,
 356                                               dest_ref3);
 357                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[96 * srcs], buffs,
 358                                               dest_ref4);
 359
 360                         FUNCTION_UNDER_TEST(TEST_LEN, srcs, g_tbls, buffs, dest_ptrs);
 361
 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:");
 367                                 dump(dest_ref1, 25);
 368                                 printf("dprod_dut:");
 369                                 dump(dest1, 25);
 370                                 return -1;
 371                         }
 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:");
 377                                 dump(dest_ref2, 25);
 378                                 printf("dprod_dut:");
 379                                 dump(dest2, 25);
 380                                 return -1;
 381                         }
 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:");
 387                                 dump(dest_ref3, 25);
 388                                 printf("dprod_dut:");
 389                                 dump(dest3, 25);
 390                                 return -1;
 391                         }
 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:");
 397                                 dump(dest_ref4, 25);
 398                                 printf("dprod_dut:");
 399                                 dump(dest4, 25);
 400                                 return -1;
 401                         }
 402
 403                         putchar('.');
 404                 }
 405         }
 406
 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();
 413
 414                 for (i = 0; i < TEST_SOURCES; i++)      // Line up TEST_SIZE from end
 415                         efence_buffs[i] = buffs[i] + TEST_LEN - size;
 416
 417                 for (i = 0; i < TEST_SOURCES; i++) {
 418                         g1[i] = rand();
 419                         g2[i] = rand();
 420                         g3[i] = rand();
 421                         g4[i] = rand();
 422                 }
 423
 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)]);
 429                 }
 430
 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);
 438
 439                 FUNCTION_UNDER_TEST(size, TEST_SOURCES, g_tbls, efence_buffs, dest_ptrs);
 440
 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:");
 447                         dump(dest1, align);
 448                         return -1;
 449                 }
 450
 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:");
 457                         dump(dest2, align);
 458                         return -1;
 459                 }
 460
 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:");
 467                         dump(dest3, align);
 468                         return -1;
 469                 }
 470
 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:");
 477                         dump(dest4, align);
 478                         return -1;
 479                 }
 480
 481                 putchar('.');
 482         }
 483
 484         // Test rand ptr alignment if available
 485
 486         for (rtest = 0; rtest < RANDOMS; rtest++) {
 487                 size = (TEST_LEN - PTR_ALIGN_CHK_B) & ~(TEST_MIN_SIZE - 1);
 488                 srcs = rand() % TEST_SOURCES;
 489                 if (srcs == 0)
 490                         continue;
 491
 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));
 496
 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));
 501
 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);
 506
 507                 for (i = 0; i < srcs; i++)
 508                         for (j = 0; j < size; j++)
 509                                 ubuffs[i][j] = rand();
 510
 511                 for (i = 0; i < srcs; i++) {
 512                         g1[i] = rand();
 513                         g2[i] = rand();
 514                         g3[i] = rand();
 515                         g4[i] = rand();
 516                 }
 517
 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)]);
 523                 }
 524
 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);
 529
 530                 FUNCTION_UNDER_TEST(size, srcs, g_tbls, ubuffs, udest_ptrs);
 531
 532                 if (memcmp(dest_ref1, udest_ptrs[0], size)) {
 533                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 534                                srcs);
 535                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 536                         printf("dprod_base:");
 537                         dump(dest_ref1, 25);
 538                         printf("dprod_dut:");
 539                         dump(udest_ptrs[0], 25);
 540                         return -1;
 541                 }
 542                 if (memcmp(dest_ref2, udest_ptrs[1], size)) {
 543                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 544                                srcs);
 545                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 546                         printf("dprod_base:");
 547                         dump(dest_ref2, 25);
 548                         printf("dprod_dut:");
 549                         dump(udest_ptrs[1], 25);
 550                         return -1;
 551                 }
 552                 if (memcmp(dest_ref3, udest_ptrs[2], size)) {
 553                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 554                                srcs);
 555                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 556                         printf("dprod_base:");
 557                         dump(dest_ref3, 25);
 558                         printf("dprod_dut:");
 559                         dump(udest_ptrs[2], 25);
 560                         return -1;
 561                 }
 562                 if (memcmp(dest_ref4, udest_ptrs[3], size)) {
 563                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 564                                srcs);
 565                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 566                         printf("dprod_base:");
 567                         dump(dest_ref4, 25);
 568                         printf("dprod_dut:");
 569                         dump(udest_ptrs[3], 25);
 570                         return -1;
 571                 }
 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;
 575
 576                 if (memcmp(dest1, dest_ref1, offset)) {
 577                         printf("Fail rand ualign pad1 start\n");
 578                         return -1;
 579                 }
 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);
 583                         return -1;
 584                 }
 585
 586                 offset = udest_ptrs[1] - dest2;
 587                 if (memcmp(dest2, dest_ref1, offset)) {
 588                         printf("Fail rand ualign pad2 start\n");
 589                         return -1;
 590                 }
 591                 if (memcmp(dest2 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 592                         printf("Fail rand ualign pad2 end\n");
 593                         return -1;
 594                 }
 595
 596                 offset = udest_ptrs[2] - dest3;
 597                 if (memcmp(dest3, dest_ref1, offset)) {
 598                         printf("Fail rand ualign pad3 start\n");
 599                         return -1;
 600                 }
 601                 if (memcmp(dest3 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 602                         printf("Fail rand ualign pad3 end\n");
 603                         return -1;
 604                 }
 605
 606                 offset = udest_ptrs[3] - dest4;
 607                 if (memcmp(dest4, dest_ref1, offset)) {
 608                         printf("Fail rand ualign pad4 start\n");
 609                         return -1;
 610                 }
 611                 if (memcmp(dest4 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 612                         printf("Fail rand ualign pad4 end\n");
 613                         return -1;
 614                 }
 615
 616                 putchar('.');
 617         }
 618
 619         // Test all size alignment
 620         align = (LEN_ALIGN_CHK_B != 0) ? 1 : 32;
 621
 622         for (size = TEST_LEN; size >= TEST_MIN_SIZE; size -= align) {
 623                 srcs = TEST_SOURCES;
 624
 625                 for (i = 0; i < srcs; i++)
 626                         for (j = 0; j < size; j++)
 627                                 buffs[i][j] = rand();
 628
 629                 for (i = 0; i < srcs; i++) {
 630                         g1[i] = rand();
 631                         g2[i] = rand();
 632                         g3[i] = rand();
 633                         g4[i] = rand();
 634                 }
 635
 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)]);
 641                 }
 642
 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);
 647
 648                 FUNCTION_UNDER_TEST(size, srcs, g_tbls, buffs, dest_ptrs);
 649
 650                 if (memcmp(dest_ref1, dest_ptrs[0], size)) {
 651                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 652                                size);
 653                         dump_matrix(buffs, 5, TEST_SOURCES);
 654                         printf("dprod_base:");
 655                         dump(dest_ref1, 25);
 656                         printf("dprod_dut:");
 657                         dump(dest_ptrs[0], 25);
 658                         return -1;
 659                 }
 660                 if (memcmp(dest_ref2, dest_ptrs[1], size)) {
 661                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 662                                size);
 663                         dump_matrix(buffs, 5, TEST_SOURCES);
 664                         printf("dprod_base:");
 665                         dump(dest_ref2, 25);
 666                         printf("dprod_dut:");
 667                         dump(dest_ptrs[1], 25);
 668                         return -1;
 669                 }
 670                 if (memcmp(dest_ref3, dest_ptrs[2], size)) {
 671                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 672                                size);
 673                         dump_matrix(buffs, 5, TEST_SOURCES);
 674                         printf("dprod_base:");
 675                         dump(dest_ref3, 25);
 676                         printf("dprod_dut:");
 677                         dump(dest_ptrs[2], 25);
 678                         return -1;
 679                 }
 680                 if (memcmp(dest_ref4, dest_ptrs[3], size)) {
 681                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 682                                size);
 683                         dump_matrix(buffs, 5, TEST_SOURCES);
 684                         printf("dprod_base:");
 685                         dump(dest_ref4, 25);
 686                         printf("dprod_dut:");
 687                         dump(dest_ptrs[3], 25);
 688                         return -1;
 689                 }
 690         }
 691
 692         printf("Pass\n");
 693         return 0;
 694
 695 }