ceph/src/isa-l/erasure_code/gf_3vect_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_3vect_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 g_tbls[3 * TEST_SOURCES * 32], *dest_ptrs[3], *buffs[TEST_SOURCES];
 115         u8 *dest1, *dest2, *dest3, *dest_ref1, *dest_ref2, *dest_ref3;
 116
 117         int align, size;
 118         unsigned char *efence_buffs[TEST_SOURCES];
 119         unsigned int offset;
 120         u8 *ubuffs[TEST_SOURCES];
 121         u8 *udest_ptrs[3];
 122         printf(xstr(FUNCTION_UNDER_TEST) "_test: %dx%d ", TEST_SOURCES, TEST_LEN);
 123
 124         // Allocate the arrays
 125         for (i = 0; i < TEST_SOURCES; i++) {
 126                 if (posix_memalign(&buf, 64, TEST_LEN)) {
 127                         printf("alloc error: Fail");
 128                         return -1;
 129                 }
 130                 buffs[i] = buf;
 131         }
 132
 133         if (posix_memalign(&buf, 64, TEST_LEN)) {
 134                 printf("alloc error: Fail");
 135                 return -1;
 136         }
 137         dest1 = buf;
 138
 139         if (posix_memalign(&buf, 64, TEST_LEN)) {
 140                 printf("alloc error: Fail");
 141                 return -1;
 142         }
 143         dest2 = buf;
 144
 145         if (posix_memalign(&buf, 64, TEST_LEN)) {
 146                 printf("alloc error: Fail");
 147                 return -1;
 148         }
 149         dest3 = buf;
 150
 151         if (posix_memalign(&buf, 64, TEST_LEN)) {
 152                 printf("alloc error: Fail");
 153                 return -1;
 154         }
 155         dest_ref1 = buf;
 156
 157         if (posix_memalign(&buf, 64, TEST_LEN)) {
 158                 printf("alloc error: Fail");;
 159                 return -1;
 160         }
 161         dest_ref2 = buf;
 162
 163         if (posix_memalign(&buf, 64, TEST_LEN)) {
 164                 printf("alloc error: Fail");
 165                 return -1;
 166         }
 167         dest_ref3 = buf;
 168
 169         dest_ptrs[0] = dest1;
 170         dest_ptrs[1] = dest2;
 171         dest_ptrs[2] = dest3;
 172
 173         // Test of all zeros
 174         for (i = 0; i < TEST_SOURCES; i++)
 175                 memset(buffs[i], 0, TEST_LEN);
 176
 177         memset(dest1, 0, TEST_LEN);
 178         memset(dest2, 0, TEST_LEN);
 179         memset(dest3, 0, TEST_LEN);
 180         memset(dest_ref1, 0, TEST_LEN);
 181         memset(dest_ref2, 0, TEST_LEN);
 182         memset(dest_ref3, 0, TEST_LEN);
 183         memset(g1, 2, TEST_SOURCES);
 184         memset(g2, 1, TEST_SOURCES);
 185         memset(g3, 7, TEST_SOURCES);
 186
 187         for (i = 0; i < TEST_SOURCES; i++) {
 188                 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
 189                 gf_vect_mul_init(g2[i], &g_tbls[32 * TEST_SOURCES + i * 32]);
 190                 gf_vect_mul_init(g3[i], &g_tbls[64 * TEST_SOURCES + i * 32]);
 191         }
 192
 193         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1);
 194         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES], buffs,
 195                               dest_ref2);
 196         gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES], buffs,
 197                               dest_ref3);
 198
 199         FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
 200
 201         if (0 != memcmp(dest_ref1, dest1, TEST_LEN)) {
 202                 printf("Fail zero" xstr(FUNCTION_UNDER_TEST) " test1\n");
 203                 dump_matrix(buffs, 5, TEST_SOURCES);
 204                 printf("dprod_base:");
 205                 dump(dest_ref1, 25);
 206                 printf("dprod_dut:");
 207                 dump(dest1, 25);
 208                 return -1;
 209         }
 210         if (0 != memcmp(dest_ref2, dest2, TEST_LEN)) {
 211                 printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test2\n");
 212                 dump_matrix(buffs, 5, TEST_SOURCES);
 213                 printf("dprod_base:");
 214                 dump(dest_ref2, 25);
 215                 printf("dprod_dut:");
 216                 dump(dest2, 25);
 217                 return -1;
 218         }
 219         if (0 != memcmp(dest_ref3, dest3, TEST_LEN)) {
 220                 printf("Fail zero " xstr(FUNCTION_UNDER_TEST) " test3\n");
 221                 dump_matrix(buffs, 5, TEST_SOURCES);
 222                 printf("dprod_base:");
 223                 dump(dest_ref3, 25);
 224                 printf("dprod_dut:");
 225                 dump(dest3, 25);
 226                 return -1;
 227         }
 228
 229         putchar('.');
 230
 231         // Rand data test
 232
 233         for (rtest = 0; rtest < RANDOMS; rtest++) {
 234                 for (i = 0; i < TEST_SOURCES; i++)
 235                         for (j = 0; j < TEST_LEN; j++)
 236                                 buffs[i][j] = rand();
 237
 238                 for (i = 0; i < TEST_SOURCES; i++) {
 239                         g1[i] = rand();
 240                         g2[i] = rand();
 241                         g3[i] = rand();
 242                 }
 243
 244                 for (i = 0; i < TEST_SOURCES; i++) {
 245                         gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
 246                         gf_vect_mul_init(g2[i], &g_tbls[(32 * TEST_SOURCES) + (i * 32)]);
 247                         gf_vect_mul_init(g3[i], &g_tbls[(64 * TEST_SOURCES) + (i * 32)]);
 248                 }
 249
 250                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[0], buffs, dest_ref1);
 251                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES],
 252                                       buffs, dest_ref2);
 253                 gf_vect_dot_prod_base(TEST_LEN, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES],
 254                                       buffs, dest_ref3);
 255
 256                 FUNCTION_UNDER_TEST(TEST_LEN, TEST_SOURCES, g_tbls, buffs, dest_ptrs);
 257
 258                 if (0 != memcmp(dest_ref1, dest1, TEST_LEN)) {
 259                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test1 %d\n", rtest);
 260                         dump_matrix(buffs, 5, TEST_SOURCES);
 261                         printf("dprod_base:");
 262                         dump(dest_ref1, 25);
 263                         printf("dprod_dut:");
 264                         dump(dest1, 25);
 265                         return -1;
 266                 }
 267                 if (0 != memcmp(dest_ref2, dest2, TEST_LEN)) {
 268                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test2 %d\n", rtest);
 269                         dump_matrix(buffs, 5, TEST_SOURCES);
 270                         printf("dprod_base:");
 271                         dump(dest_ref2, 25);
 272                         printf("dprod_dut:");
 273                         dump(dest2, 25);
 274                         return -1;
 275                 }
 276                 if (0 != memcmp(dest_ref3, dest3, TEST_LEN)) {
 277                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test3 %d\n", rtest);
 278                         dump_matrix(buffs, 5, TEST_SOURCES);
 279                         printf("dprod_base:");
 280                         dump(dest_ref3, 25);
 281                         printf("dprod_dut:");
 282                         dump(dest3, 25);
 283                         return -1;
 284                 }
 285
 286                 putchar('.');
 287         }
 288
 289         // Rand data test with varied parameters
 290         for (rtest = 0; rtest < RANDOMS; rtest++) {
 291                 for (srcs = TEST_SOURCES; srcs > 0; srcs--) {
 292                         for (i = 0; i < srcs; i++)
 293                                 for (j = 0; j < TEST_LEN; j++)
 294                                         buffs[i][j] = rand();
 295
 296                         for (i = 0; i < srcs; i++) {
 297                                 g1[i] = rand();
 298                                 g2[i] = rand();
 299                                 g3[i] = rand();
 300                         }
 301
 302                         for (i = 0; i < srcs; i++) {
 303                                 gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
 304                                 gf_vect_mul_init(g2[i], &g_tbls[(32 * srcs) + (i * 32)]);
 305                                 gf_vect_mul_init(g3[i], &g_tbls[(64 * srcs) + (i * 32)]);
 306                         }
 307
 308                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[0], buffs, dest_ref1);
 309                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[32 * srcs], buffs,
 310                                               dest_ref2);
 311                         gf_vect_dot_prod_base(TEST_LEN, srcs, &g_tbls[64 * srcs], buffs,
 312                                               dest_ref3);
 313
 314                         FUNCTION_UNDER_TEST(TEST_LEN, srcs, g_tbls, buffs, dest_ptrs);
 315
 316                         if (0 != memcmp(dest_ref1, dest1, TEST_LEN)) {
 317                                 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
 318                                        " test1 srcs=%d\n", srcs);
 319                                 dump_matrix(buffs, 5, TEST_SOURCES);
 320                                 printf("dprod_base:");
 321                                 dump(dest_ref1, 25);
 322                                 printf("dprod_dut:");
 323                                 dump(dest1, 25);
 324                                 return -1;
 325                         }
 326                         if (0 != memcmp(dest_ref2, dest2, TEST_LEN)) {
 327                                 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
 328                                        " test2 srcs=%d\n", srcs);
 329                                 dump_matrix(buffs, 5, TEST_SOURCES);
 330                                 printf("dprod_base:");
 331                                 dump(dest_ref2, 25);
 332                                 printf("dprod_dut:");
 333                                 dump(dest2, 25);
 334                                 return -1;
 335                         }
 336                         if (0 != memcmp(dest_ref3, dest3, TEST_LEN)) {
 337                                 printf("Fail rand " xstr(FUNCTION_UNDER_TEST)
 338                                        " test3 srcs=%d\n", srcs);
 339                                 dump_matrix(buffs, 5, TEST_SOURCES);
 340                                 printf("dprod_base:");
 341                                 dump(dest_ref3, 25);
 342                                 printf("dprod_dut:");
 343                                 dump(dest3, 25);
 344                                 return -1;
 345                         }
 346
 347                         putchar('.');
 348                 }
 349         }
 350
 351         // Run tests at end of buffer for Electric Fence
 352         align = (LEN_ALIGN_CHK_B != 0) ? 1 : 16;
 353         for (size = TEST_MIN_SIZE; size <= TEST_SIZE; size += align) {
 354                 for (i = 0; i < TEST_SOURCES; i++)
 355                         for (j = 0; j < TEST_LEN; j++)
 356                                 buffs[i][j] = rand();
 357
 358                 for (i = 0; i < TEST_SOURCES; i++)      // Line up TEST_SIZE from end
 359                         efence_buffs[i] = buffs[i] + TEST_LEN - size;
 360
 361                 for (i = 0; i < TEST_SOURCES; i++) {
 362                         g1[i] = rand();
 363                         g2[i] = rand();
 364                         g3[i] = rand();
 365                 }
 366
 367                 for (i = 0; i < TEST_SOURCES; i++) {
 368                         gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
 369                         gf_vect_mul_init(g2[i], &g_tbls[(32 * TEST_SOURCES) + (i * 32)]);
 370                         gf_vect_mul_init(g3[i], &g_tbls[(64 * TEST_SOURCES) + (i * 32)]);
 371                 }
 372
 373                 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[0], efence_buffs, dest_ref1);
 374                 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[32 * TEST_SOURCES],
 375                                       efence_buffs, dest_ref2);
 376                 gf_vect_dot_prod_base(size, TEST_SOURCES, &g_tbls[64 * TEST_SOURCES],
 377                                       efence_buffs, dest_ref3);
 378
 379                 FUNCTION_UNDER_TEST(size, TEST_SOURCES, g_tbls, efence_buffs, dest_ptrs);
 380
 381                 if (0 != memcmp(dest_ref1, dest1, size)) {
 382                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test1 %d\n", rtest);
 383                         dump_matrix(efence_buffs, 5, TEST_SOURCES);
 384                         printf("dprod_base:");
 385                         dump(dest_ref1, align);
 386                         printf("dprod_dut:");
 387                         dump(dest1, align);
 388                         return -1;
 389                 }
 390
 391                 if (0 != memcmp(dest_ref2, dest2, size)) {
 392                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test2 %d\n", rtest);
 393                         dump_matrix(efence_buffs, 5, TEST_SOURCES);
 394                         printf("dprod_base:");
 395                         dump(dest_ref2, align);
 396                         printf("dprod_dut:");
 397                         dump(dest2, align);
 398                         return -1;
 399                 }
 400
 401                 if (0 != memcmp(dest_ref3, dest3, size)) {
 402                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test3 %d\n", rtest);
 403                         dump_matrix(efence_buffs, 5, TEST_SOURCES);
 404                         printf("dprod_base:");
 405                         dump(dest_ref3, align);
 406                         printf("dprod_dut:");
 407                         dump(dest3, align);
 408                         return -1;
 409                 }
 410
 411                 putchar('.');
 412         }
 413
 414         // Test rand ptr alignment if available
 415
 416         for (rtest = 0; rtest < RANDOMS; rtest++) {
 417                 size = (TEST_LEN - PTR_ALIGN_CHK_B) & ~(TEST_MIN_SIZE - 1);
 418                 srcs = rand() % TEST_SOURCES;
 419                 if (srcs == 0)
 420                         continue;
 421
 422                 offset = (PTR_ALIGN_CHK_B != 0) ? 1 : PTR_ALIGN_CHK_B;
 423                 // Add random offsets
 424                 for (i = 0; i < srcs; i++)
 425                         ubuffs[i] = buffs[i] + (rand() & (PTR_ALIGN_CHK_B - offset));
 426
 427                 udest_ptrs[0] = dest1 + (rand() & (PTR_ALIGN_CHK_B - offset));
 428                 udest_ptrs[1] = dest2 + (rand() & (PTR_ALIGN_CHK_B - offset));
 429                 udest_ptrs[2] = dest3 + (rand() & (PTR_ALIGN_CHK_B - offset));
 430
 431                 memset(dest1, 0, TEST_LEN);     // zero pad to check write-over
 432                 memset(dest2, 0, TEST_LEN);
 433                 memset(dest3, 0, TEST_LEN);
 434
 435                 for (i = 0; i < srcs; i++)
 436                         for (j = 0; j < size; j++)
 437                                 ubuffs[i][j] = rand();
 438
 439                 for (i = 0; i < srcs; i++) {
 440                         g1[i] = rand();
 441                         g2[i] = rand();
 442                         g3[i] = rand();
 443                 }
 444
 445                 for (i = 0; i < srcs; i++) {
 446                         gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
 447                         gf_vect_mul_init(g2[i], &g_tbls[(32 * srcs) + (i * 32)]);
 448                         gf_vect_mul_init(g3[i], &g_tbls[(64 * srcs) + (i * 32)]);
 449                 }
 450
 451                 gf_vect_dot_prod_base(size, srcs, &g_tbls[0], ubuffs, dest_ref1);
 452                 gf_vect_dot_prod_base(size, srcs, &g_tbls[32 * srcs], ubuffs, dest_ref2);
 453                 gf_vect_dot_prod_base(size, srcs, &g_tbls[64 * srcs], ubuffs, dest_ref3);
 454
 455                 FUNCTION_UNDER_TEST(size, srcs, g_tbls, ubuffs, udest_ptrs);
 456
 457                 if (memcmp(dest_ref1, udest_ptrs[0], size)) {
 458                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 459                                srcs);
 460                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 461                         printf("dprod_base:");
 462                         dump(dest_ref1, 25);
 463                         printf("dprod_dut:");
 464                         dump(udest_ptrs[0], 25);
 465                         return -1;
 466                 }
 467                 if (memcmp(dest_ref2, udest_ptrs[1], size)) {
 468                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 469                                srcs);
 470                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 471                         printf("dprod_base:");
 472                         dump(dest_ref2, 25);
 473                         printf("dprod_dut:");
 474                         dump(udest_ptrs[1], 25);
 475                         return -1;
 476                 }
 477                 if (memcmp(dest_ref3, udest_ptrs[2], size)) {
 478                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign srcs=%d\n",
 479                                srcs);
 480                         dump_matrix(ubuffs, 5, TEST_SOURCES);
 481                         printf("dprod_base:");
 482                         dump(dest_ref3, 25);
 483                         printf("dprod_dut:");
 484                         dump(udest_ptrs[2], 25);
 485                         return -1;
 486                 }
 487                 // Confirm that padding around dests is unchanged
 488                 memset(dest_ref1, 0, PTR_ALIGN_CHK_B);  // Make reference zero buff
 489                 offset = udest_ptrs[0] - dest1;
 490
 491                 if (memcmp(dest1, dest_ref1, offset)) {
 492                         printf("Fail rand ualign pad1 start\n");
 493                         return -1;
 494                 }
 495                 if (memcmp(dest1 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 496                         printf("Fail rand ualign pad1 end\n");
 497                         return -1;
 498                 }
 499
 500                 offset = udest_ptrs[1] - dest2;
 501                 if (memcmp(dest2, dest_ref1, offset)) {
 502                         printf("Fail rand ualign pad2 start\n");
 503                         return -1;
 504                 }
 505                 if (memcmp(dest2 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 506                         printf("Fail rand ualign pad2 end\n");
 507                         return -1;
 508                 }
 509
 510                 offset = udest_ptrs[2] - dest3;
 511                 if (memcmp(dest3, dest_ref1, offset)) {
 512                         printf("Fail rand ualign pad3 start\n");
 513                         return -1;
 514                 }
 515                 if (memcmp(dest3 + offset + size, dest_ref1, PTR_ALIGN_CHK_B - offset)) {
 516                         printf("Fail rand ualign pad3 end\n");;
 517                         return -1;
 518                 }
 519
 520                 putchar('.');
 521         }
 522
 523         // Test all size alignment
 524         align = (LEN_ALIGN_CHK_B != 0) ? 1 : 16;
 525
 526         for (size = TEST_LEN; size >= TEST_MIN_SIZE; size -= align) {
 527                 srcs = TEST_SOURCES;
 528
 529                 for (i = 0; i < srcs; i++)
 530                         for (j = 0; j < size; j++)
 531                                 buffs[i][j] = rand();
 532
 533                 for (i = 0; i < srcs; i++) {
 534                         g1[i] = rand();
 535                         g2[i] = rand();
 536                         g3[i] = rand();
 537                 }
 538
 539                 for (i = 0; i < srcs; i++) {
 540                         gf_vect_mul_init(g1[i], &g_tbls[i * 32]);
 541                         gf_vect_mul_init(g2[i], &g_tbls[(32 * srcs) + (i * 32)]);
 542                         gf_vect_mul_init(g3[i], &g_tbls[(64 * srcs) + (i * 32)]);
 543                 }
 544
 545                 gf_vect_dot_prod_base(size, srcs, &g_tbls[0], buffs, dest_ref1);
 546                 gf_vect_dot_prod_base(size, srcs, &g_tbls[32 * srcs], buffs, dest_ref2);
 547                 gf_vect_dot_prod_base(size, srcs, &g_tbls[64 * srcs], buffs, dest_ref3);
 548
 549                 FUNCTION_UNDER_TEST(size, srcs, g_tbls, buffs, dest_ptrs);
 550
 551                 if (memcmp(dest_ref1, dest_ptrs[0], size)) {
 552                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 553                                size);
 554                         dump_matrix(buffs, 5, TEST_SOURCES);
 555                         printf("dprod_base:");
 556                         dump(dest_ref1, 25);
 557                         printf("dprod_dut:");
 558                         dump(dest_ptrs[0], 25);
 559                         return -1;
 560                 }
 561                 if (memcmp(dest_ref2, dest_ptrs[1], size)) {
 562                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 563                                size);
 564                         dump_matrix(buffs, 5, TEST_SOURCES);
 565                         printf("dprod_base:");
 566                         dump(dest_ref2, 25);
 567                         printf("dprod_dut:");
 568                         dump(dest_ptrs[1], 25);
 569                         return -1;
 570                 }
 571                 if (memcmp(dest_ref3, dest_ptrs[2], size)) {
 572                         printf("Fail rand " xstr(FUNCTION_UNDER_TEST) " test ualign len=%d\n",
 573                                size);
 574                         dump_matrix(buffs, 5, TEST_SOURCES);
 575                         printf("dprod_base:");
 576                         dump(dest_ref3, 25);
 577                         printf("dprod_dut:");
 578                         dump(dest_ptrs[2], 25);
 579                         return -1;
 580                 }
 581         }
 582
 583         printf("Pass\n");
 584         return 0;
 585
 586 }