← Back to branch summary

~ubuntu-branches/ubuntu/vivid/atlas/vivid

« back to all changes in this revision

Viewing changes to tune/blas/level1/dottime.c

  • Committer: Package Import Robot
  • Author(s): Sébastien Villemot
  • Date: 2013-06-11 15:58:16 UTC
  • mfrom: (1.1.3 upstream)
  • mto: (2.2.21 experimental)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: package-import@ubuntu.com-20130611155816-b72z8f621tuhbzn0
Tags: upstream-3.10.1
Import upstream version 3.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
tune/blas/level1/dottime.c
1
1
#include <stdio.h>
2
2
#include <stdlib.h>
3
3
#include <assert.h>
 
4
double ATL_flushcache(long long size);
 
5
 
4
6
 
5
7
int FAx=0, MAx=0, FAy=0, MAy=0;
6
8
#include <stdio.h>
27
29
   int n, i;
28
30
   const int malign = align >= misalign ? align : misalign;
29
31
 
30
 
   n = size + align + malign;
 
32
   n = size + align + align + malign;
31
33
   i = (n >> 3)<<3;
32
34
   if (n != i)
33
35
      n += n - i;
41
43
   ap->memA = align ? (void*) ((((size_t) cp)/align)*align + align) : cp;
42
44
/*
43
45
 * Misalign to misalign
 
46
 * We often need to make sure to unaligned addresses share the same modulo
 
47
 * so that they have the *same* degree of misalignment (so that their alignment
 
48
 * can be fixed by simple peeling), and so in this case force the address
 
49
 * modulo the misalign to be the exact align value.
44
50
 */
45
51
   if (misalign)
46
 
   {
47
 
      if (((size_t)ap->memA)%misalign == 0)
48
 
         ap->memA = ((char*)ap->memA) + align;
49
 
   }
 
52
      ap->memA = (void*)((((size_t)ap->memA)/malign)*malign + malign + align);
50
53
   ap->next = next;
51
54
   return(ap);
52
55
}
117
120
         for (ap=allocQ; ap && ap->memA != ptr; ap = ap->next) prev = ap;
118
121
         if (!ap)
119
122
         {
120
 
            fprintf(stderr, "Couldn't find mem=%ld\nmemQ=\n", ptr);
 
123
            fprintf(stderr, "Couldn't find mem=%ld\nmemQ=\n", (size_t)ptr);
121
124
            for (ap=allocQ; ap; ap = ap->next)
122
 
               fprintf(stderr, "   %ld, %ld\n", ap->memA, ap->mem);
 
125
               fprintf(stderr, "   %ld, %ld\n", (size_t)ap->memA,
 
126
                       (size_t)ap->mem);
123
127
         }
124
128
         assert(ap);
125
129
         if (ap == allocQ)
198
202
   #define TEST_DOT ATL_DOT
199
203
#endif
200
204
 
 
205
double DoOneTiming(int N, int nkflop, int cachesize, int incX, int incY)
 
206
/*
 
207
 * This method of timing can be used when we have a cycle-accurate timer
 
208
 * available so we don't need to call routine multiple times to get above
 
209
 * clock resolution.
 
210
 */
 
211
{
 
212
   #ifdef TREAL
 
213
      TYPE TEST_DOT(const int N, const TYPE *X, const int incX,
 
214
                    TYPE *Y, const int incY);
 
215
      TYPE dot=0.0;
 
216
   #else
 
217
      void TEST_DOT(const int N, const TYPE *X, const int incX,
 
218
                    TYPE *Y, const int incY, TYPE *dotc);
 
219
      TYPE dot[2];
 
220
   #endif
 
221
   TYPE *X, *Y;
 
222
   double *W, dtmp, t0, t1;
 
223
   int Ny, Nx, i, n;
 
224
   const int FLBYADDR = (nkflop < 0);
 
225
 
 
226
 
 
227
   Nx = (incX >= 0) ? incX : -incX;
 
228
   Nx = 1 + (N-1)*Nx;
 
229
   X = FA_malloc(ATL_sizeof*Nx, FAx, MAx);
 
230
   assert(X);
 
231
   Ny = (incY >= 0) ? incY : -incY;
 
232
   Ny = 1 + (N-1)*Ny;
 
233
   Y = FA_malloc(ATL_sizeof*Ny, FAy, MAy);
 
234
   assert(Y);
 
235
   dumb_seed(i<<2);
 
236
   for (i=0; i < N; i++)
 
237
   {
 
238
      X[i*incX] = dumb_rand();
 
239
      Y[i*incY] = dumb_rand();
 
240
   }
 
241
 
 
242
   if (FLBYADDR)
 
243
   {
 
244
      #if ATL_LINEFLUSH
 
245
         ATL_flushCacheByAddr(Nx*ATL_sizeof, X);
 
246
         ATL_flushCacheByAddr(Ny*ATL_sizeof, Y);
 
247
      #else
 
248
         fprintf(stderr, "No flush by address!!\n");
 
249
         exit(-1);
 
250
      #endif
 
251
   }
 
252
   else if (cachesize)
 
253
   {
 
254
      dtmp = ATL_flushcache(cachesize);
 
255
      dtmp += ATL_flushcache(-1);
 
256
   }
 
257
   t0 = time00();
 
258
   #ifdef TREAL
 
259
      dot = TEST_DOT(N, X, incX, Y, incY);
 
260
   #else
 
261
      TEST_DOT(N, X, incX, Y, incY, dot);
 
262
   #endif
 
263
   t1 = time00();
 
264
 
 
265
   FA_free(X, FAx, MAx);
 
266
   FA_free(Y, FAy, MAy);
 
267
   return(t1-t0);
 
268
}
201
269
double DoTiming(int N, int nkflop, int cachesize, int incX, int incY)
202
270
{
203
271
   #ifdef TREAL
267
335
   int i;
268
336
   for (i=0; i < nrep; i++)
269
337
   {
 
338
      if (nkflop <= 0)
 
339
         tims[i] = DoOneTiming(N, nkflop, cachesize, incX, incY);
 
340
      else
270
341
      tims[i] = DoTiming(N, nkflop, cachesize, incX, incY);
271
342
      fprintf(stdout, "      N=%d, tim=%e\n", N, tims[i]);
272
343
   }
528
599
      FAy = sizeof(TYPE);
529
600
}
530
601
 
531
 
main(int nargs, char **args)
 
602
int main(int nargs, char **args)
532
603
{
533
604
   char *fout;
534
605
   int nN, nkflops, cachesize, incX, incY;
536
607
   GetFlags(nargs, args, &nN, &Ns, &nkflops, &cachesize, &fout, &incX, &incY);
537
608
   DoTimings(nN, Ns, nkflops, cachesize, fout, incX, incY);
538
609
   free(Ns);
539
 
   exit(0);
 
610
   return(0);
540
611
}