├── README.md
└── mm.c


/README.md:
--------------------------------------------------------------------------------
1 | # samplematrixcode
2 | Sample matrix multiply code to show affect of blocking and data alignment
3 | The code mm.c accompanies two papers at software.intel.com that discuss memory layout and performance.
4 | A simple matrix multiply is reordered and blocked to show performance improvement
5 | An exercise is included to show the impact on performance when matrices are not aligned on cacheline boundaries.
6 | 


--------------------------------------------------------------------------------
/mm.c:
--------------------------------------------------------------------------------
  1 | // A simple matrix multiply code to show affect of ordering and blocking
  2 | // to compile this use gcc -O2 mm.c -lrt or icc -O2 mm.c -lrt
  3 | 
  4 | #include <stdio.h>
  5 | #include <math.h>
  6 | #include <stdlib.h>
  7 | #include <time.h>
  8 | 
  9 | #define MATSIZE 8000
 10 | #define BLOCKSIZE 8
 11 | 
 12 | void setmat() ;
 13 | void fillmat() ;
 14 | void abasicmm() ;
 15 | void abettermm() ;
 16 | void ablockmm() ;
 17 | void checkmatmult() ;
 18 | 
 19 | int main(int argc, char *argv[])
 20 | {
 21 | 
 22 |    double *a, *b, *c, *aa ;
 23 |    unsigned int n ;
 24 |    unsigned i, j, k, iInner, jInner, kInner, blockSize ;
 25 |    struct timespec ts1, ts2, ts3, ts4, ts5, ts6, ts7 ;
 26 | 
 27 |    printf("hello code beginning\n") ;
 28 |    n = MATSIZE ; // default settings
 29 |    blockSize = BLOCKSIZE ;
 30 |    if (argc != 3)
 31 |    {
 32 |       printf("input matrix size and blocksize\n") ;
 33 |       exit(0);
 34 |    }
 35 |    n = atoi(argv[1]) ;
 36 |    blockSize = atoi(argv[2]) ;
 37 |    printf("matrix size %d blocksize %d\n", n,blockSize) ;
 38 |    if (n%blockSize)
 39 |    {
 40 |       printf("for this simple example matrix size must be a multiple of the block size.\n  Please re-start \n") ;
 41 |       exit(0);
 42 |    }
 43 | // allocate matrices
 44 |    a = (double *)calloc((n+blockSize)*(n+blockSize), sizeof(double)) ;
 45 |    b = (double *)calloc((n+blockSize)*(n+blockSize), sizeof(double)) ;
 46 |    c = (double *)calloc((n+blockSize)*(n+blockSize), sizeof(double)) ;
 47 |    aa = (double *)calloc((n+blockSize)*(n+blockSize), sizeof(double)) ;
 48 |    if (aa == NULL) // cheap check only the last allocation checked.
 49 |    {
 50 |      printf("insufficient memory \n") ;
 51 |      exit(0) ;
 52 |    }
 53 | 
 54 | // fill matrices
 55 | 
 56 |    setmat(n, n, a) ;
 57 |    setmat(n, n, aa) ;
 58 | 
 59 | 
 60 |    srand(4.16) ; // set random seed (change to go off time stamp to make it better
 61 | 
 62 |    fillmat(n,n,b) ;
 63 |    fillmat(n,n,c) ;
 64 | 
 65 |    clock_gettime(CLOCK_REALTIME, &ts1) ;
 66 | // multiply matrices
 67 |    abasicmm (n,n,a,b,c) ;
 68 | 
 69 |    clock_gettime(CLOCK_REALTIME, &ts2) ;
 70 | 
 71 |    setmat(n, n, a) ;
 72 | 
 73 |    clock_gettime(CLOCK_REALTIME, &ts3) ;
 74 | 
 75 |    abettermm (n,n,a,b,c) ;
 76 | 
 77 |    clock_gettime(CLOCK_REALTIME, &ts4) ;
 78 | 
 79 |    ablockmm (n, n, aa, b, c, blockSize) ;
 80 | 
 81 |    clock_gettime(CLOCK_REALTIME, &ts5) ;
 82 | 
 83 |    printf("matrix multplies complete \n") ; fflush(stdout) ;
 84 | 
 85 | /**/
 86 |    checkmatmult(n,n,a,aa) ;
 87 | 
 88 |    {
 89 |       double t1, t2, t3, tmp ;
 90 |       t1 =  ts2.tv_sec-ts1.tv_sec;
 91 |       tmp = ts2.tv_nsec-ts1.tv_nsec;
 92 |       tmp /= 1.0e+09 ;
 93 |       t1 += tmp ;
 94 |       printf("ijk ordering basic time %lf\n",t1) ;
 95 |       t2 =  ts4.tv_sec-ts3.tv_sec;
 96 |       tmp = ts4.tv_nsec-ts3.tv_nsec;
 97 |       tmp /= 1.0e+09 ;
 98 |       t2 += tmp ;
 99 |       printf("ikj ordering bette time %lf\n",t2) ;
100 |       t3 =  ts5.tv_sec-ts4.tv_sec;
101 |       tmp = ts5.tv_nsec-ts4.tv_nsec;
102 |       tmp /= 1.0e+09 ;
103 |       t3 += tmp ;
104 |       printf("ikj blocked time        %lf\n",t3) ;
105 | 
106 |    }
107 | 
108 | }
109 | 
110 | void setmat(int n, int m, double a[n][m])
111 | {
112 |    int i, j ;
113 | 
114 |    for (i=0;i<n; i++)
115 |       for (j = 0 ; j<m; j++)
116 |       {
117 |          a[i][j] = 0.0 ;
118 |       }
119 | }
120 | 
121 | void fillmat(int n, int m, double a[n][m])
122 | {
123 |    int i, j ;
124 | 
125 |    for (i = 0; i<n; i++)
126 |       for (j = 0 ; j < m; j++)
127 |       {
128 |          a[i][j] = (double)rand() / 3.1e09 ;
129 |       }
130 | }
131 | 
132 | void abasicmm(int n, int m, double a[n][m], double b[n][m], double c[n][m])
133 | {
134 |    int i, j, k ;
135 | 
136 |    for (i=0;i<n; i++)
137 |       for (j = 0; j<n; j++)
138 |          for (k=0;k<n; k++)
139 |             a[i][j] += b[i][k]* c[k][j] ;
140 | }
141 | 
142 | void abettermm(int n, int m, double a[n][m], double b[n][m], double c[n][m])
143 | {
144 |    int i, j, k ;
145 | 
146 |    for (i=0;i<n; i++)
147 |       for (k=0;k<n; k++)
148 |          for (j = 0; j<n; j++)
149 |             a[i][j] += b[i][k]* c[k][j] ;
150 | }
151 | void ablockmm(int n,int m,double a[n][m],double b[n][m],double c[n][m], int blockSize)
152 | {
153 |    int i, j, k, iInner, jInner, kInner ;
154 |    for (i = 0; i < n; i+=blockSize)
155 |       for (k = 0 ; k < n; k+=blockSize)
156 |          for (j=0; j<n ; j+= blockSize)
157 |             for (iInner = i; iInner<i+blockSize; iInner++)
158 |                for (kInner = k ; kInner<k+blockSize ; kInner++)
159 |                   for (jInner = j ; jInner<j+blockSize; jInner++)
160 |                         a[iInner][jInner] += b[iInner][kInner] * c[kInner][jInner] ;
161 | }
162 | 
163 | void checkmatmult(int n,int m, double a[n][m], double aa[n][m])
164 | {
165 | // crude check.  Never compare floating point or double with ==.
166 | // most floating point results are too sensitive to order of operations.
167 | // this worked(sizes up to about 4600) it was quick, in general this is not safe
168 |    int i, j ;
169 | for (i=0;i<n;i++)
170 | for (j=0;j<m;j++)
171 |    if (a[i][j]-aa[i][j] != 0.0) printf("diff i %d %d diff %lf\n",i,j,a[i][j]=aa[i][j]) ;
172 | printf("check OK\n") ;
173 | }
174 | 
175 | /**/
176 | // use thsi main instead of the one above to measure impact of unalinged matrix
177 | // this version expects intel compiler
178 | /*
179 | int main(int argc, char *argv[])
180 | {
181 |  
182 |    double *a, *b, *c, *aa ;
183 |    unsigned int n ;
184 |    unsigned i, j, k, iInner, jInner, kInner, blockSize ;
185 |    struct timespec ts1, ts2, ts3, ts4, ts5, ts6, ts7 ;
186 | 
187 |    printf("hello code beginning\n") ;
188 |    n = MATSIZE ; // default settings
189 |    blockSize = BLOCKSIZE ;
190 |    if (argc != 3) {printf("input matrix size and blocksize\n") ; exit(0);}
191 |    n = atoi(argv[1]) ;
192 |    blockSize = atoi(argv[2]) ;
193 |    printf("matrix size %d blocksize %d\n", n,blockSize) ;
194 |    if (n%blockSize) {printf("for this simple example matrix size must be a multiple of the block size.\n  Please re-start \n") ; exit(0); }
195 | // allocate matrices
196 |    a = (double *)_mm_malloc((n+blockSize)*(n+blockSize)* sizeof(double),64) ;
197 |    b = (double *)_mm_malloc((n+blockSize)*(n+blockSize)* sizeof(double),64) ;
198 |    c = (double *)_mm_malloc((n+blockSize)*(n+blockSize)* sizeof(double),64) ;
199 |    aa = (double *)_mm_malloc((n+blockSize)*(n+blockSize)* sizeof(double),64) ;
200 |    if (aa == NULL)
201 |    {
202 |      printf("insufficient memory \n") ;
203 |      exit(0) ;
204 |    }
205 | 
206 | // fill matrices
207 | 
208 |    aa += 3 ; //offset aa.  aa is intentionally allocated larger than required.
209 |    setmat(n, n, a) ;
210 |    setmat(n, n, aa) ;
211 | 
212 | 
213 |    srand(4.16) ; // set random seed (change to go off time stamp to make it better
214 | 
215 |    fillmat(n,n,b) ;
216 |    fillmat(n,n,c) ;
217 | 
218 |    clock_gettime(CLOCK_REALTIME, &ts1) ;
219 | // multiply matrices
220 | 
221 | 
222 |    ablockmm (n, n, a, b, c, blockSize) ;
223 |    clock_gettime(CLOCK_REALTIME, &ts2) ;
224 |    ablockmm (n, n, aa, b, c, blockSize) ;
225 |    clock_gettime(CLOCK_REALTIME, &ts3) ;
226 | 
227 |    printf("matrix multplies complete \n") ; fflush(stdout) ;
228 | 
229 |    checkmatmult(n,n,a,aa) ;
230 | 
231 |    {
232 |       double t1, t2, t3, tmp ;
233 |       t1 =  ts2.tv_sec-ts1.tv_sec;
234 |       tmp = ts2.tv_nsec-ts1.tv_nsec;
235 |       tmp /= 1.0e+09 ;
236 |       t1 += tmp ;
237 |       printf("aligned block time   %lf\n",t1) ;
238 |       t2 =  ts3.tv_sec-ts2.tv_sec;
239 |       tmp = ts3.tv_nsec-ts2.tv_nsec;
240 |       tmp /= 1.0e+09 ;
241 |       t2 += tmp ;
242 |      printf("unaligned block time %lf\n",t2) ;
243 |    }
244 | }
245 | */
246 | 
247 |    
248 | 
249 | 


--------------------------------------------------------------------------------