← Back to branch summary

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

« back to all changes in this revision

Viewing changes to interfaces/blas/F77/testing/settst.c

  • Committer: Bazaar Package Importer
  • Author(s): Sylvestre Ledru
  • Date: 2009-09-17 23:31:54 UTC
  • mto: (2.2.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20090917233154-9esw88ub02twbuab
Tags: upstream-3.8.3
Import upstream version 3.8.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
interfaces/blas/F77/testing/settst.c
1
1
#include "atlas_misc.h"
2
2
#include <assert.h>
3
3
 
 
4
int FAx=0, MAx=0, FAy=0, MAy=0;
 
5
#include <stdio.h>
 
6
#include <stdlib.h>
 
7
#include <assert.h>
 
8
 
 
9
struct FA_allocs
 
10
{
 
11
   void *mem, *memA;
 
12
   struct FA_allocs *next;
 
13
} *allocQ=NULL;
 
14
 
 
15
struct FA_allocs *NewAlloc(size_t size, struct FA_allocs *next,
 
16
                           int align, int misalign)
 
17
/*
 
18
 * Allocates size allocation that is aligned to [align], but not aligned
 
19
 * to [misalign].  Therefore, misalign > align.  Align must minimally be sizeof
 
20
 * while misalign may be 0 if we don't need to avoid a particular alignment.
 
21
 */
 
22
{
 
23
   void *vp;
 
24
   char *cp;
 
25
   struct FA_allocs *ap;
 
26
   int n, i;
 
27
   const int malign = align >= misalign ? align : misalign;
 
28
 
 
29
   n = size + align + malign;
 
30
   i = (n >> 3)<<3;
 
31
   if (n != i)
 
32
      n += n - i;
 
33
   cp = malloc(n + sizeof(struct FA_allocs));
 
34
   assert(cp);
 
35
   ap = (struct FA_allocs *) (cp + n);
 
36
   ap->mem = cp;
 
37
/*
 
38
 * Align to min alignment
 
39
 */
 
40
   ap->memA = align ? (void*) ((((size_t) cp)/align)*align + align) : cp;
 
41
/*
 
42
 * Misalign to misalign
 
43
 */
 
44
   if (misalign)
 
45
   {
 
46
      if (((size_t)ap->memA)%misalign == 0)
 
47
         ap->memA = ((char*)ap->memA) + align;
 
48
   }
 
49
   ap->next = next;
 
50
   return(ap);
 
51
}
 
52
 
 
53
/*
 
54
 * no-align malloc free retaining system default behavior
 
55
 */
 
56
void *NA_malloc(size_t size)
 
57
{
 
58
   return(malloc(size));
 
59
}
 
60
void *NA_calloc(size_t n, size_t size)
 
61
{
 
62
   return(calloc(n, size));
 
63
}
 
64
void NA_free(void *ptr)
 
65
{
 
66
   free(ptr);
 
67
}
 
68
 
 
69
 
 
70
/*
 
71
 * malloc/free pair that aligns data to align, but not to misalign
 
72
 */
 
73
void *FA_malloc(size_t size, int align, int misalign)
 
74
{
 
75
   if ((!misalign && align <= 8) || !size)
 
76
      return(malloc(size));
 
77
   else
 
78
   {
 
79
      allocQ = NewAlloc(size, allocQ, align, misalign);
 
80
      return(allocQ->memA);
 
81
   }
 
82
}
 
83
void *FA_calloc(size_t n, size_t size, int align, int misalign)
 
84
{
 
85
   char *cp;
 
86
   int *ip;
 
87
   double *dp;
 
88
   size_t i;
 
89
   size_t tsize;
 
90
   tsize = n * size;
 
91
   cp = FA_malloc(tsize, align, misalign);
 
92
   if (size == sizeof(int))
 
93
      for (ip=(int*)cp,i=0; i < n; i++)
 
94
        ip[i] = 0;
 
95
   else if (size == sizeof(double))
 
96
      for (dp=(double*)cp,i=0; i < n; i++)
 
97
        dp[i] = 0.0;
 
98
   else
 
99
      for (i=0; i < tsize; i++)
 
100
        cp[i] = 0;
 
101
   return(cp);
 
102
}
 
103
 
 
104
void FA_free(void *ptr, int align, int misalign)
 
105
/*
 
106
 * Part of malloc/free pair that aligns data to FALIGN
 
107
 */
 
108
{
 
109
   struct FA_allocs *ap, *prev;
 
110
   if (ptr)
 
111
   {
 
112
      if ((!misalign && align <= 8))
 
113
         free(ptr);
 
114
      else
 
115
      {
 
116
         for (ap=allocQ; ap && ap->memA != ptr; ap = ap->next) prev = ap;
 
117
         if (!ap)
 
118
         {
 
119
            fprintf(stderr, "Couldn't find mem=%ld\nmemQ=\n", ptr);
 
120
            for (ap=allocQ; ap; ap = ap->next)
 
121
               fprintf(stderr, "   %ld, %ld\n", ap->memA, ap->mem);
 
122
         }
 
123
         assert(ap);
 
124
         if (ap == allocQ)
 
125
            allocQ = allocQ->next;
 
126
         else
 
127
            prev->next = ap->next;
 
128
         free(ap->mem);
 
129
      }
 
130
   }
 
131
}
 
132
 
4
133
#define dumb_seed(iseed_) srand(iseed_)
5
134
#ifndef RAND_MAX  /* rather dangerous non-ansi workaround */
6
135
   #define RAND_MAX ((unsigned long)(1<<30))
194
323
   for (i=0; i < N; i++) X[i] = alpha;
195
324
}
196
325
 
197
 
static TYPE *getvec(int npad, TYPE padval, int N, int incX)
 
326
static TYPE *getvec(int npad, TYPE padval, int N, int incX, int FA, int MA)
198
327
{
199
328
   TYPE *X, *x;
200
329
   int i, n;
202
331
   if (N <= 0) return(NULL);
203
332
   incX = Mabs(incX);
204
333
   n = 2*npad + 1+(N-1)*incX;
205
 
   X = malloc( ATL_sizeof*n );
 
334
   X = FA_malloc(ATL_sizeof*n, FA, MA);
206
335
   assert(X);
207
336
   vecset(n, padval, X);
208
337
   #ifdef TCPLX
233
362
   #endif
234
363
}
235
364
 
236
 
static TYPE *dupvec(int npad, int N, TYPE *X, int incX)
 
365
static TYPE *dupvec(int npad, int N, TYPE *X, int incX, int FA, int MA)
237
366
{
238
367
   int i, n;
239
368
   TYPE *y;
240
369
 
241
370
   incX = Mabs(incX);
242
371
   n = 1+(N-1)*incX + 2*npad;
243
 
   y = malloc(ATL_sizeof*n);
 
372
   y = FA_malloc(ATL_sizeof*n, FA, MA);
244
373
   assert(y);
245
374
   #ifdef TCPLX
246
375
      n *= 2;
250
379
}
251
380
 
252
381
static TYPE *gen_dupvec(int N, TYPE padval, int npadX, TYPE *X, int incX,
253
 
                        int npadY, int incY)
 
382
                        int npadY, int incY, int FA, int MA)
254
383
{
255
384
   int i, n;
256
385
   TYPE *y, *yy, *xx=X+(npadX SHIFT);
257
386
 
258
 
   y = getvec(npadY, padval, N, incY);
 
387
   y = getvec(npadY, padval, N, incY, FA, MA);
259
388
   yy = y + (npadY SHIFT);
260
389
   if (incY < 1) yy -= ((N-1)SHIFT) * incY;
261
390
   if (incX < 1) xx -= ((N-1)SHIFT) * incX;
275
404
      TYPE *alpha = alpha0;
276
405
   #endif
277
406
 
278
 
   Yg = getvec(npad, padval, N, incY);
279
 
   Yt = dupvec(npad, N, Yg, incY);
 
407
   Yg = getvec(npad, padval, N, incY, FAy, MAy);
 
408
   Yt = dupvec(npad, N, Yg, incY, FAy, MAy);
280
409
 
281
410
   y = Yg + (npad SHIFT);
282
411
   if (incY < 1) y -= ((N-1)SHIFT) * incY;
285
414
   if (incY < 1) y -= ((N-1)SHIFT) * incY;
286
415
   TEST_SET(N, alpha, Yt+(npad SHIFT), incY);
287
416
   iret = CheckY(npad, padval, N, Yg, incY, Yt, incY);
288
 
   free(Yg);
289
 
   free(Yt);
 
417
   FA_free(Yg, FAx, MAx);
 
418
   FA_free(Yt, FAy, MAy);
290
419
   return(iret);
291
420
}
292
421
int DoAllTests(int nN, int *Ns, int nX, int *Xs, int nY, int *Ys,
341
470
void GetFlags(int nargs, char **args, int *nN, int **Ns, int *nX, int **incXs,
342
471
              int *nY, int **incYs, int *nal, TYPE **alphas)
343
472
{
344
 
   int i, j;
 
473
   int i, j, k, ig;
345
474
 
346
475
   *nal = -1;
347
476
   *nY = *nX = *nN = -1;
352
481
      if (i == nargs-1) PrintUsage(args[0]);
353
482
      switch(args[i][1])
354
483
      {
 
484
      case 'F':
 
485
         j = args[i][2] != 'y';
 
486
         k = atoi(args[++i]);
 
487
         if (j)
 
488
         {
 
489
            if (k < 0)
 
490
               MAx = -k;
 
491
            else
 
492
               FAx = k;
 
493
         }
 
494
         else
 
495
         {
 
496
            if (k < 0)
 
497
               MAy = -k;
 
498
            else
 
499
               FAy = k;
 
500
         }
 
501
         break;
355
502
      case 'a':
356
503
         *nal = atoi(args[++i]);
357
504
         if (*nal > nargs-i) PrintUsage(args[0]);
359
506
         assert(*alphas);
360
507
         for (j=0; j < *nal SHIFT; j++) (*alphas)[j] = atof(args[++i]);
361
508
         break;
 
509
      case 'b':
 
510
         ig = atoi(args[++i]);
 
511
         if (ig > nargs-i) PrintUsage(args[0]);
 
512
         i += ig SHIFT;
 
513
         break;
362
514
      case 'Y':
363
515
         *nY = atoi(args[++i]);
364
516
         if (*nY > nargs-i) PrintUsage(args[0]);
452
604
         (*alphas)[7] = 1.1;
453
605
      #endif
454
606
   }
 
607
   if (FAx < sizeof(TYPE))
 
608
      FAx = sizeof(TYPE);
 
609
   if (FAy < sizeof(TYPE))
 
610
      FAy = sizeof(TYPE);
 
611
   FAy = FAx;
 
612
   MAy = MAx;
455
613
}
456
614
 
457
615
main(int nargs, char **args)