mt/bn_matmul/matmul_mi.c

   1 //**************************************************************************
   2 // Multi-threaded Matrix Multiply benchmark
   3 //--------------------------------------------------------------------------
   4 // TA     : Christopher Celio
   5 // Student:
   6 //
   7 //
   8 // This benchmark multiplies two 2-D arrays together and writes the results to
   9 // a third vector. The input data (and reference data) should be generated
  10 // using the matmul_gendata.pl perl script and dumped to a file named
  11 // dataset.h.
  12
  13
  14 // print out arrays, etc.
  15 //#define DEBUG
  16
  17 //--------------------------------------------------------------------------
  18 // Includes
  19
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23
  24
  25 //--------------------------------------------------------------------------
  26 // Input/Reference Data
  27
  28 typedef float data_t;
  29 #include "dataset.h"
  30
  31
  32 //--------------------------------------------------------------------------
  33 // Basic Utilities and Multi-thread Support
  34
  35 __thread unsigned long coreid;
  36 unsigned long ncores;
  37
  38 #include "util.h"
  39
  40 #define stringify_1(s) #s
  41 #define stringify(s) stringify_1(s)
  42 #define stats(code) do { \
  43     unsigned long _c = -rdcycle(), _i = -rdinstret(); \
  44     code; \
  45     _c += rdcycle(), _i += rdinstret(); \
  46     if (coreid == 0) \
  47       printf("%s: %ld cycles, %ld.%ld cycles/iter, %ld.%ld CPI\n", \
  48              stringify(code), _c, _c/DIM_SIZE/DIM_SIZE/DIM_SIZE, 10*_c/DIM_SIZE/DIM_SIZE/DIM_SIZE%10, _c/_i, 10*_c/_i%10); \
  49   } while(0)
  50
  51
  52 //--------------------------------------------------------------------------
  53 // Helper functions
  54
  55 void printArrayMT( char name[], int n, data_t arr[] )
  56 {
  57    int i;
  58    if (coreid != 0)
  59       return;
  60
  61    printf( " %10s :", name );
  62    for ( i = 0; i < n; i++ )
  63       printf( " %3ld ", (long) arr[i] );
  64    printf( "\n" );
  65 }
  66
  67 void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
  68 {
  69    if (coreid != 0)
  70       return;
  71
  72    size_t i;
  73    for (i = 0; i < n; i++)
  74    {
  75       if (test[i] != correct[i])
  76       {
  77          printf("FAILED test[%d]= %3ld, correct[%d]= %3ld\n",
  78             i, (long)test[i], i, (long)correct[i]);
  79          exit(-1);
  80       }
  81    }
  82
  83    return;
  84 }
  85
  86 //--------------------------------------------------------------------------
  87 // matmul function
  88
  89 // single-thread, naive version
  90 void __attribute__((noinline)) matmul_naive(const int lda,  const data_t A[], const data_t B[], data_t C[] )
  91 {
  92 ///*
  93    int i, j, k;
  94
  95    if (coreid > 0)
  96       return;
  97
  98    for ( i = 0; i < lda; i++ )
  99       for ( j = 0; j < lda; j++ )
 100       {
 101          for ( k = 0; k < lda; k++ )
 102          {
 103             C[i + j*lda] += A[j*lda + k] * B[k*lda + i];
 104          }
 105       }
 106 //*/
 107   /*
 108    int i, j, k, kk;
 109   if (coreid) {
 110    for ( i = 0; i < 16; i+=8 )
 111    {
 112       for ( j = 0; j < 32; j++ )
 113       {
 114          data_t temp0 = 0;
 115          data_t temp1 = 0;
 116          data_t temp2 = 0;
 117          data_t temp3 = 0;
 118          data_t temp4 = 0;
 119          data_t temp5 = 0;
 120          data_t temp6 = 0;
 121          data_t temp7 = 0;
 122          for ( kk = 0; kk < 32; kk+=8 )
 123          for ( k = kk; k < kk+8; k++ )
 124 //       for ( k = 0; k < 32; k++ )
 125          {
 126             data_t tempA = A[j*32+k];
 127             temp0 += tempA * B[k*32 + i];
 128             temp1 += tempA * B[k*32 + i+1];
 129             temp2 += tempA * B[k*32 + i+2];
 130             temp3 += tempA * B[k*32 + i+3];
 131             temp4 += tempA * B[k*32 + i+4];
 132             temp5 += tempA * B[k*32 + i+5];
 133             temp6 += tempA * B[k*32 + i+6];
 134             temp7 += tempA * B[k*32 + i+7];
 135          }
 136          C[i+j*32] = temp0;
 137          C[i+j*32+1] = temp1;
 138          C[i+j*32+2] = temp2;
 139          C[i+j*32+3] = temp3;
 140          C[i+j*32+4] = temp4;
 141          C[i+j*32+5] = temp5;
 142          C[i+j*32+6] = temp6;
 143          C[i+j*32+7] = temp7;
 144       }
 145    }
 146   } else {
 147    for ( i =  16; i < 32; i+=8 )
 148    {
 149       for ( j = 0; j < 32; j++ )
 150       {
 151          data_t temp0 = 0;
 152          data_t temp1 = 0;
 153          data_t temp2 = 0;
 154          data_t temp3 = 0;
 155          data_t temp4 = 0;
 156          data_t temp5 = 0;
 157          data_t temp6 = 0;
 158          data_t temp7 = 0;
 159          for ( kk = 0; kk < 32; kk+=8 )
 160          for ( k = kk; k < kk+8; k++ )
 161          {
 162             data_t tempA = A[j*32+k];
 163             temp0 += tempA * B[k*32 + i];
 164             temp1 += tempA * B[k*32 + i+1];
 165             temp2 += tempA * B[k*32 + i+2];
 166             temp3 += tempA * B[k*32 + i+3];
 167             temp4 += tempA * B[k*32 + i+4];
 168             temp5 += tempA * B[k*32 + i+5];
 169             temp6 += tempA * B[k*32 + i+6];
 170             temp7 += tempA * B[k*32 + i+7];
 171          }
 172          C[i+j*32] = temp0;
 173          C[i+j*32+1] = temp1;
 174          C[i+j*32+2] = temp2;
 175          C[i+j*32+3] = temp3;
 176          C[i+j*32+4] = temp4;
 177          C[i+j*32+5] = temp5;
 178          C[i+j*32+6] = temp6;
 179          C[i+j*32+7] = temp7;
 180       }
 181
 182    }
 183   }
 184   */
 185 }
 186
 187
 188 #define KC 16
 189 #define IC 16
 190 #define JC 16
 191 void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const data_t B[], data_t C[] )
 192 {
 193
 194    // ***************************** //
 195    // **** ADD YOUR CODE HERE ***** //
 196    // ***************************** //
 197    //
 198    // feel free to make a separate function for MI and MSI versions.
 199    int i, j, k, ii, jj, kk;
 200   if (coreid) {
 201 // for ( ii = 0; ii < 32; ii+=IC )
 202       for ( jj = 0; jj < 16; jj+=16 )
 203          for ( kk = 0; kk < 32; kk+=16 )
 204    for ( j = jj; j < jj+16 && j < 16; j++ )
 205 // for ( j = 0; j < 16; j++ )
 206    {
 207       for ( i =  0; i < 32; i+=8 )
 208 //    for ( i = ii; i < ii + IC && i < 32; i+=8 )
 209       {
 210          data_t temp0 = C[i+j*32];
 211          data_t temp1 = C[i+j*32+1];
 212          data_t temp2 = C[i+j*32+2];
 213          data_t temp3 = C[i+j*32+3];
 214          data_t temp4 = C[i+j*32+4];
 215          data_t temp5 = C[i+j*32+5];
 216          data_t temp6 = C[i+j*32+6];
 217          data_t temp7 = C[i+j*32+7];
 218          for ( k = kk; k < kk+16 && k < 32; k++ )
 219 //       for ( k = 0; k < 32; k++ )
 220          {
 221             data_t tempA = A[j*32+k];
 222             temp0 += tempA * B[k*32 + i];
 223             temp1 += tempA * B[k*32 + i+1];
 224             temp2 += tempA * B[k*32 + i+2];
 225             temp3 += tempA * B[k*32 + i+3];
 226             temp4 += tempA * B[k*32 + i+4];
 227             temp5 += tempA * B[k*32 + i+5];
 228             temp6 += tempA * B[k*32 + i+6];
 229             temp7 += tempA * B[k*32 + i+7];
 230          }
 231          C[i+j*32] = temp0;
 232          C[i+j*32+1] = temp1;
 233          C[i+j*32+2] = temp2;
 234          C[i+j*32+3] = temp3;
 235          C[i+j*32+4] = temp4;
 236          C[i+j*32+5] = temp5;
 237          C[i+j*32+6] = temp6;
 238          C[i+j*32+7] = temp7;
 239       }
 240    }
 241   } else {
 242 // for ( ii = 0; ii < 32; ii+=IC )
 243       for ( jj = 16; jj < 32; jj+= 16 ) {
 244          for ( kk = 16; kk < 32; kk+=16 )
 245    for ( j = jj; j < jj+16 && j < 32; j++ )
 246 // for ( j = 16; j < 32; j++ )
 247    {
 248       for ( i =   0; i < 32; i+=8 )
 249 //    for ( i = ii; i < ii + IC && i < 32; i+=8 )
 250       {
 251          data_t temp0 = C[i+j*32];
 252          data_t temp1 = C[i+j*32+1];
 253          data_t temp2 = C[i+j*32+2];
 254          data_t temp3 = C[i+j*32+3];
 255          data_t temp4 = C[i+j*32+4];
 256          data_t temp5 = C[i+j*32+5];
 257          data_t temp6 = C[i+j*32+6];
 258          data_t temp7 = C[i+j*32+7];
 259          for ( k = kk; k < kk+16 && k < 32; k++ )
 260          {
 261             data_t tempA = A[j*32+k];
 262             temp0 += tempA * B[k*32 + i];
 263             temp1 += tempA * B[k*32 + i+1];
 264             temp2 += tempA * B[k*32 + i+2];
 265             temp3 += tempA * B[k*32 + i+3];
 266             temp4 += tempA * B[k*32 + i+4];
 267             temp5 += tempA * B[k*32 + i+5];
 268             temp6 += tempA * B[k*32 + i+6];
 269             temp7 += tempA * B[k*32 + i+7];
 270          }
 271          C[i+j*32] = temp0;
 272          C[i+j*32+1] = temp1;
 273          C[i+j*32+2] = temp2;
 274          C[i+j*32+3] = temp3;
 275          C[i+j*32+4] = temp4;
 276          C[i+j*32+5] = temp5;
 277          C[i+j*32+6] = temp6;
 278          C[i+j*32+7] = temp7;
 279       }
 280
 281    }
 282          for ( kk = 0; kk < 16; kk+=16 )
 283    for ( j = jj; j < jj+16 && j < 32; j++ )
 284 // for ( j = 16; j < 32; j++ )
 285    {
 286       for ( i =   0; i < 32; i+=8 )
 287 //    for ( i = ii; i < ii + IC && i < 32; i+=8 )
 288       {
 289          data_t temp0 = C[i+j*32];
 290          data_t temp1 = C[i+j*32+1];
 291          data_t temp2 = C[i+j*32+2];
 292          data_t temp3 = C[i+j*32+3];
 293          data_t temp4 = C[i+j*32+4];
 294          data_t temp5 = C[i+j*32+5];
 295          data_t temp6 = C[i+j*32+6];
 296          data_t temp7 = C[i+j*32+7];
 297          for ( k = kk; k < kk+16 && k < 32; k++ )
 298          {
 299             data_t tempA = A[j*32+k];
 300             temp0 += tempA * B[k*32 + i];
 301             temp1 += tempA * B[k*32 + i+1];
 302             temp2 += tempA * B[k*32 + i+2];
 303             temp3 += tempA * B[k*32 + i+3];
 304             temp4 += tempA * B[k*32 + i+4];
 305             temp5 += tempA * B[k*32 + i+5];
 306             temp6 += tempA * B[k*32 + i+6];
 307             temp7 += tempA * B[k*32 + i+7];
 308          }
 309          C[i+j*32] = temp0;
 310          C[i+j*32+1] = temp1;
 311          C[i+j*32+2] = temp2;
 312          C[i+j*32+3] = temp3;
 313          C[i+j*32+4] = temp4;
 314          C[i+j*32+5] = temp5;
 315          C[i+j*32+6] = temp6;
 316          C[i+j*32+7] = temp7;
 317       }
 318
 319    }
 320       }
 321   }
 322 }
 323
 324 //--------------------------------------------------------------------------
 325 // Main
 326 //
 327 // all threads start executing thread_entry(). Use their "coreid" to
 328 // differentiate between threads (each thread is running on a separate core).
 329
 330 void thread_entry(int cid, int nc)
 331 {
 332    coreid = cid;
 333    ncores = nc;
 334
 335    // static allocates data in the binary, which is visible to both threads
 336    static data_t results_data[ARRAY_SIZE];
 337
 338
 339 //   // Execute the provided, naive matmul
 340 //   barrier(nc);
 341 //   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 342 //
 343 //
 344 //   // verify
 345 //   verifyMT(ARRAY_SIZE, results_data, verify_data);
 346 //
 347 //   // clear results from the first trial
 348 //   size_t i;
 349 //   if (coreid == 0)
 350 //      for (i=0; i < ARRAY_SIZE; i++)
 351 //         results_data[i] = 0;
 352 //   barrier(nc);
 353
 354
 355    // Execute your faster matmul
 356    barrier(nc);
 357    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 358
 359 #ifdef DEBUG
 360    printArrayMT("results:", ARRAY_SIZE, results_data);
 361    printArrayMT("verify :", ARRAY_SIZE, verify_data);
 362 #endif
 363
 364    // verify
 365    verifyMT(ARRAY_SIZE, results_data, verify_data);
 366    barrier(nc);
 367
 368    exit(0);
 369 }
 370