mt/bk_matmul/matmul_msi.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 void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const data_t B[], data_t C[] )
 189 {
 190
 191    // ***************************** //
 192    // **** ADD YOUR CODE HERE ***** //
 193    // ***************************** //
 194    //
 195    // feel free to make a separate function for MI and MSI versions.
 196    int i, j, k, ii, jj, kk;
 197   if (coreid) {
 198 // for ( ii = 0; ii < 32; ii+=IC )
 199          for ( kk = 0; kk < 32; kk+=16 )
 200    for ( j = 0; j < 16; j++ )
 201 // for ( j = 0; j < 16; j++ )
 202    {
 203       for ( i =  0; i < 32; i+=8 )
 204 //    for ( i = ii; i < ii + IC && i < 32; i+=8 )
 205       {
 206          data_t temp0 = C[i+j*32];
 207          data_t temp1 = C[i+j*32+1];
 208          data_t temp2 = C[i+j*32+2];
 209          data_t temp3 = C[i+j*32+3];
 210          data_t temp4 = C[i+j*32+4];
 211          data_t temp5 = C[i+j*32+5];
 212          data_t temp6 = C[i+j*32+6];
 213          data_t temp7 = C[i+j*32+7];
 214          for ( k = kk; k < kk+16 && k < 32; k++ )
 215 //       for ( k = 0; k < 32; k++ )
 216          {
 217             data_t tempA = A[j*32+k];
 218             temp0 += tempA * B[k*32 + i];
 219             temp1 += tempA * B[k*32 + i+1];
 220             temp2 += tempA * B[k*32 + i+2];
 221             temp3 += tempA * B[k*32 + i+3];
 222             temp4 += tempA * B[k*32 + i+4];
 223             temp5 += tempA * B[k*32 + i+5];
 224             temp6 += tempA * B[k*32 + i+6];
 225             temp7 += tempA * B[k*32 + i+7];
 226          }
 227          C[i+j*32] = temp0;
 228          C[i+j*32+1] = temp1;
 229          C[i+j*32+2] = temp2;
 230          C[i+j*32+3] = temp3;
 231          C[i+j*32+4] = temp4;
 232          C[i+j*32+5] = temp5;
 233          C[i+j*32+6] = temp6;
 234          C[i+j*32+7] = temp7;
 235       }
 236    }
 237   } else {
 238 // for ( ii = 0; ii < 32; ii+=IC )
 239          for ( kk = 0; kk < 32; kk+=16 )
 240    for ( j = 16; j < 32; j++ )
 241 // for ( j = 16; j < 32; j++ )
 242    {
 243       for ( i =   0; i < 32; i+=8 )
 244 //    for ( i = ii; i < ii + IC && i < 32; i+=8 )
 245       {
 246          data_t temp0 = C[i+j*32];
 247          data_t temp1 = C[i+j*32+1];
 248          data_t temp2 = C[i+j*32+2];
 249          data_t temp3 = C[i+j*32+3];
 250          data_t temp4 = C[i+j*32+4];
 251          data_t temp5 = C[i+j*32+5];
 252          data_t temp6 = C[i+j*32+6];
 253          data_t temp7 = C[i+j*32+7];
 254          for ( k = kk; k < kk+16 && k < 32; k++ )
 255          {
 256             data_t tempA = A[j*32+k];
 257             temp0 += tempA * B[k*32 + i];
 258             temp1 += tempA * B[k*32 + i+1];
 259             temp2 += tempA * B[k*32 + i+2];
 260             temp3 += tempA * B[k*32 + i+3];
 261             temp4 += tempA * B[k*32 + i+4];
 262             temp5 += tempA * B[k*32 + i+5];
 263             temp6 += tempA * B[k*32 + i+6];
 264             temp7 += tempA * B[k*32 + i+7];
 265          }
 266          C[i+j*32] = temp0;
 267          C[i+j*32+1] = temp1;
 268          C[i+j*32+2] = temp2;
 269          C[i+j*32+3] = temp3;
 270          C[i+j*32+4] = temp4;
 271          C[i+j*32+5] = temp5;
 272          C[i+j*32+6] = temp6;
 273          C[i+j*32+7] = temp7;
 274       }
 275
 276    }
 277   }
 278 }
 279
 280 //--------------------------------------------------------------------------
 281 // Main
 282 //
 283 // all threads start executing thread_entry(). Use their "coreid" to
 284 // differentiate between threads (each thread is running on a separate core).
 285
 286 void thread_entry(int cid, int nc)
 287 {
 288    coreid = cid;
 289    ncores = nc;
 290
 291    // static allocates data in the binary, which is visible to both threads
 292    static data_t results_data[ARRAY_SIZE];
 293
 294
 295    // Execute the provided, naive matmul
 296    barrier(nc);
 297    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 298
 299
 300    // verify
 301    verifyMT(ARRAY_SIZE, results_data, verify_data);
 302
 303    // clear results from the first trial
 304    size_t i;
 305    if (coreid == 0)
 306       for (i=0; i < ARRAY_SIZE; i++)
 307          results_data[i] = 0;
 308    barrier(nc);
 309
 310
 311    // Execute your faster matmul
 312    barrier(nc);
 313    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 314
 315 #ifdef DEBUG
 316    printArrayMT("results:", ARRAY_SIZE, results_data);
 317    printArrayMT("verify :", ARRAY_SIZE, verify_data);
 318 #endif
 319
 320    // verify
 321    verifyMT(ARRAY_SIZE, results_data, verify_data);
 322    barrier(nc);
 323
 324    exit(0);
 325 }
 326