scripts/probe_perf/bench.c - systemtap
Global variables defined
Data types defined
Functions defined
Macros defined
Source code
# include <sys/types.h>
# include <sys/time.h>
# include <sys/times.h>
# include <memory.h>
# include <stdio.h>
# include <stdlib.h>
# include "bench_.h"
#define nil 0
#define false 0
#define true 1
#define bubblebase 1.61
#define dnfbase 3.5
#define permbase 1.75
#define queensbase 1.83
#define towersbase 2.39
#define quickbase 1.92
#define intmmbase 1.46
#define treebase 2.5
#define mmbase 0.0
#define fpmmbase 2.92
#define puzzlebase 0.5
#define fftbase 0.0
#define fpfftbase 4.44
#define maxcells 18
#define rowsize 40
#define SIZE 511
#define classmax 3
#define typemax 12
#define d 8
#define sortelements 5000
#define srtelements 500
#define fftsize 256
#define fftsize2 129
#define permrange 10
struct node
{
struct node *left, *right;
int val;
};
#define stackrange 3
struct element
{
int discsize;
int next;
};
struct complex
{
float rp, ip;
};
float value;
float fixed, floated;
int seed;
#define CYCLES_HBOUND 1000
long cycles_start;
long permute_cycles_idx;
long permute_cycles_avg;
long (*permute_cycles) [CYCLES_HBOUND];
long tower_cycles_idx;
long tower_cycles_avg;
long (*tower_cycles) [CYCLES_HBOUND];
long try_cycles_idx;
long try_cycles_avg;
long (*try_cycles) [CYCLES_HBOUND];
long innerproduct_cycles_idx;
long innerproduct_cycles_avg;
long (*innerproduct_cycles) [CYCLES_HBOUND];
long trial_cycles_idx;
long trial_cycles_avg;
long (*trial_cycles) [CYCLES_HBOUND];
long quicksort_cycles_idx;
long quicksort_cycles_avg;
long (*quicksort_cycles) [CYCLES_HBOUND];
long insert_cycles_idx;
long insert_cycles_avg;
long (*insert_cycles) [CYCLES_HBOUND];
long bubble_cycles_idx;
long bubble_cycles_avg;
long (*bubble_cycles) [CYCLES_HBOUND];
long fft_cycles_idx;
long fft_cycles_avg;
long (*fft_cycles) [CYCLES_HBOUND];
int permarray[permrange + 1];
int pctr;
struct node *tree;
int stack[stackrange + 1];
struct element cellspace[maxcells + 1];
int freelist, movesdone;
int ima[rowsize + 1][rowsize + 1], imb[rowsize + 1][rowsize + 1],
imr[rowsize + 1][rowsize + 1];
float rma[rowsize + 1][rowsize + 1], rmb[rowsize + 1][rowsize + 1],
rmr[rowsize + 1][rowsize + 1];
int piececount[classmax + 1],
class[typemax + 1],
piecemax[typemax + 1], puzzl[SIZE + 1], p[typemax + 1][SIZE + 1], n, kount;
int sortlist[sortelements + 1], biggest, littlest, top;
struct complex z[fftsize + 1], w[fftsize + 1], e[fftsize2 + 1];
float zr, zi;
long rdtsc(void) __attribute__ ((__noinline__));
long rdtsc(void)
{
XXX #if defined __x86_64__
int res[2];
__asm__ __volatile__ ("xorl %%eax,%%eax \n push %%rbx \n cpuid \n"
::: "%rax", "%rcx", "%rdx");
__asm__ __volatile__ ("rdtsc\n"
: "=a" (res[0]), "=d" (res[1]) );
__asm__ __volatile__ ("xorl %%eax,%%eax \n cpuid \n pop %%rbx \n"
::: "%rax", "%rcx", "%rdx");
return *(long*)res;
#else
return 0;
#endif
}
Initrand ()
{
seed = 74755;
}
int
Rand ()
{
seed = (seed * 1309 + 13849) & 65535;
return (seed);
}
Swap (a, b)
int *a, *b;
{
int t;
t = *a;
*a = *b;
*b = t;
}
Initialize ()
{
int i;
for (i = 1; i <= 7; i++)
{
permarray[i] = i - 1;
};
}
Permute (n)
int n;
{
int k;
pctr = pctr + 1;
if (n != 1)
{
Permute (n - 1);
for (k = n - 1; k >= 1; k--)
{
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_PERMUTE (cycles_start,k);
#else
BENCH_PERMUTE:
#endif
if (__builtin_expect(permute_cycles_idx != CYCLES_HBOUND,0))
{
permute_cycles_idx++;
(*permute_cycles)[permute_cycles_idx] = rdtsc() - cycles_start;
}
Swap (&permarray[n], &permarray[k]);
Permute (n - 1);
Swap (&permarray[n], &permarray[k]);
};
};
}
Perm ()
{
int i;
pctr = 0;
for (i = 1; i <= 5; i++)
{
Initialize ();
Permute (7);
};
if (pctr != 43300)
printf (" Error in Perm.\n");
}
Error (emsg)
char *emsg;
{
printf (" Error in Towers: %s\n", emsg);
}
Makenull (s)
{
stack[s] = 0;
}
int
Getelement ()
{
int temp;
if (freelist > 0)
{
temp = freelist;
freelist = cellspace[freelist].next;
}
else
Error ("out of space ");
return (temp);
}
Push (i, s)
int i, s;
{
int errorfound, localel;
errorfound = false;
if (stack[s] > 0)
if (cellspace[stack[s]].discsize <= i)
{
errorfound = true;
Error ("disc size error");
};
if (!errorfound)
{
localel = Getelement ();
cellspace[localel].next = stack[s];
stack[s] = localel;
cellspace[localel].discsize = i;
}
}
Init (s, n)
int s, n;
{
int discctr;
Makenull (s);
for (discctr = n; discctr >= 1; discctr--)
Push (discctr, s);
}
int
Pop (s)
int s;
{
int temp, temp1;
if (stack[s] > 0)
{
temp1 = cellspace[stack[s]].discsize;
temp = cellspace[stack[s]].next;
cellspace[stack[s]].next = freelist;
freelist = stack[s];
stack[s] = temp;
return (temp1);
}
else
Error ("nothing to pop ");
}
Move (s1, s2)
int s1, s2;
{
Push (Pop (s1), s2);
movesdone = movesdone + 1;
}
tower (i, j, k)
int i, j, k;
{
int other;
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_TOWER (cycles_start,i, j, k);
#else
BENCH_TOWER:
#endif
if (__builtin_expect(tower_cycles_idx != CYCLES_HBOUND,0))
{
tower_cycles_idx++;
(*tower_cycles)[tower_cycles_idx] = rdtsc() - cycles_start;
}
if (k == 1)
Move (i, j);
else
{
other = 6 - i - j;
tower (i, other, k - 1);
Move (i, j);
tower (other, j, k - 1);
}
}
Towers ()
{
int i;
for (i = 1; i <= maxcells; i++)
cellspace[i].next = i - 1;
freelist = maxcells;
Init (1, 14);
Makenull (2);
Makenull (3);
movesdone = 0;
tower (1, 2, 14);
if (movesdone != 16383)
printf (" Error in Towers.\n");
}
Try (i, q, a, b, c, x)
int i, *q, a[], b[], c[], x[];
{
int j;
j = 0;
*q = false;
while ((!*q) && (j != 8))
{
j = j + 1;
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_TRY (cycles_start,i, q, a, b, c, x);
#else
BENCH_TRY:
#endif
if (__builtin_expect(try_cycles_idx != CYCLES_HBOUND,0))
{
try_cycles_idx++;
(*try_cycles)[try_cycles_idx] = rdtsc() - cycles_start;
}
*q = false;
if (b[j] && a[i + j] && c[i - j + 7])
{
x[i] = j;
b[j] = false;
a[i + j] = false;
c[i - j + 7] = false;
if (i < 8)
{
Try (i + 1, q, a, b, c, x);
if (!*q)
{
b[j] = true;
a[i + j] = true;
c[i - j + 7] = true;
}
}
else
*q = true;
}
}
}
Doit ()
{
int i, q;
int a[9], b[17], c[15], x[9];
i = 0 - 7;
while (i <= 16)
{
if ((i >= 1) && (i <= 8))
a[i] = true;
if (i >= 2)
b[i] = true;
if (i <= 7)
c[i + 7] = true;
i = i + 1;
}
Try (1, &q, b, a, c, x);
if (!q)
printf (" Error in Queens.\n");
}
Queens ()
{
int i;
for (i = 1; i <= 50; i++)
Doit ();
}
Initmatrix (m)
int m[rowsize + 1][rowsize + 1];
{
int temp, i, j;
for (i = 1; i <= rowsize; i++)
for (j = 1; j <= rowsize; j++)
temp = Rand ();
m[i][j] = temp - (temp / 120) * 120 - 60;
}
Innerproduct (result, a, b, row, column)
int *result, a[rowsize + 1][rowsize + 1], b[rowsize + 1][rowsize + 1],
row, column;
{
int i;
*result = 0;
for (i = 1; i <= rowsize; i++)
{
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_INNERPRODUCT (cycles_start,a, b, row, column);
#else
BENCH_INNERPRODUCT:
#endif
if (__builtin_expect(innerproduct_cycles_idx != CYCLES_HBOUND,0))
{
innerproduct_cycles_idx++;
(*innerproduct_cycles)[innerproduct_cycles_idx] = rdtsc() - cycles_start;
}
*result = *result + a[row][i] * b[i][column];
}
}
Intmm ()
{
int i, j;
Initrand ();
Initmatrix (ima);
Initmatrix (imb);
for (i = 1; i <= rowsize; i++)
for (j = 1; j <= rowsize; j++)
Innerproduct (&imr[i][j], ima, imb, i, j);
}
rInitmatrix (m)
float m[rowsize + 1][rowsize + 1];
{
int temp, i, j;
for (i = 1; i <= rowsize; i++)
for (j = 1; j <= rowsize; j++)
temp = Rand ();
m[i][j] = (temp - (temp / 120) * 120 - 60) / 3;
}
rInnerproduct (result, a, b, row, column)
float *result, a[rowsize + 1][rowsize + 1], b[rowsize + 1][rowsize + 1];
int row, column;
{
int i;
*result = 0.0;
for (i = 1; i <= rowsize; i++)
*result = *result + a[row][i] * b[i][column];
}
Mm ()
{
int i, j;
Initrand ();
rInitmatrix (rma);
rInitmatrix (rmb);
for (i = 1; i <= rowsize; i++)
for (j = 1; j <= rowsize; j++)
rInnerproduct (&rmr[i][j], rma, rmb, i, j);
}
int
Fit (i, j)
int i, j;
{
int k;
for (k = 0; k <= piecemax[i]; k++)
if (p[i][k])
if (puzzl[j + k])
return (false);
return (true);
}
int
Place (i, j)
int i, j;
{
int k;
for (k = 0; k <= piecemax[i]; k++)
if (p[i][k])
puzzl[j + k] = true;
piececount[class[i]] = piececount[class[i]] - 1;
for (k = j; k <= SIZE; k++)
if (!puzzl[k])
{
return (k);
}
return (0);
}
Remove (i, j)
int i, j;
{
int k;
for (k = 0; k <= piecemax[i]; k++)
if (p[i][k])
puzzl[j + k] = false;
piececount[class[i]] = piececount[class[i]] + 1;
}
int
Trial (j)
int j;
{
int i, k;
kount = kount + 1;
for (i = 0; i <= typemax; i++)
{
if (piececount[class[i]] != 0)
if (Fit (i, j))
{
k = Place (i, j);
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_TRIAL (cycles_start,i, j, k);
#else
BENCH_TRIAL:
#endif
if (__builtin_expect(trial_cycles_idx != CYCLES_HBOUND,0))
{
trial_cycles_idx++;
(*trial_cycles)[trial_cycles_idx] = rdtsc() - cycles_start;
}
if (Trial (k) || (k == 0))
{
return (true);
}
else
Remove (i, j);
}
}
return (false);
}
Puzzle ()
{
int i, j, k, m;
for (m = 0; m <= SIZE; m++)
puzzl[m] = true;
for (i = 1; i <= 5; i++)
for (j = 1; j <= 5; j++)
for (k = 1; k <= 5; k++)
puzzl[i + d * (j + d * k)] = false;
for (i = 0; i <= typemax; i++)
for (m = 0; m <= SIZE; m++)
p[i][m] = false;
for (i = 0; i <= 3; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 0; k++)
p[0][i + d * (j + d * k)] = true;
class[0] = 0;
piecemax[0] = 3 + d * 1 + d * d * 0;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 0; j++)
for (k = 0; k <= 3; k++)
p[1][i + d * (j + d * k)] = true;
class[1] = 0;
piecemax[1] = 1 + d * 0 + d * d * 3;
for (i = 0; i <= 0; i++)
for (j = 0; j <= 3; j++)
for (k = 0; k <= 1; k++)
p[2][i + d * (j + d * k)] = true;
class[2] = 0;
piecemax[2] = 0 + d * 3 + d * d * 1;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 3; j++)
for (k = 0; k <= 0; k++)
p[3][i + d * (j + d * k)] = true;
class[3] = 0;
piecemax[3] = 1 + d * 3 + d * d * 0;
for (i = 0; i <= 3; i++)
for (j = 0; j <= 0; j++)
for (k = 0; k <= 1; k++)
p[4][i + d * (j + d * k)] = true;
class[4] = 0;
piecemax[4] = 3 + d * 0 + d * d * 1;
for (i = 0; i <= 0; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 3; k++)
p[5][i + d * (j + d * k)] = true;
class[5] = 0;
piecemax[5] = 0 + d * 1 + d * d * 3;
for (i = 0; i <= 2; i++)
for (j = 0; j <= 0; j++)
for (k = 0; k <= 0; k++)
p[6][i + d * (j + d * k)] = true;
class[6] = 1;
piecemax[6] = 2 + d * 0 + d * d * 0;
for (i = 0; i <= 0; i++)
for (j = 0; j <= 2; j++)
for (k = 0; k <= 0; k++)
p[7][i + d * (j + d * k)] = true;
class[7] = 1;
piecemax[7] = 0 + d * 2 + d * d * 0;
for (i = 0; i <= 0; i++)
for (j = 0; j <= 0; j++)
for (k = 0; k <= 2; k++)
p[8][i + d * (j + d * k)] = true;
class[8] = 1;
piecemax[8] = 0 + d * 0 + d * d * 2;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 0; k++)
p[9][i + d * (j + d * k)] = true;
class[9] = 2;
piecemax[9] = 1 + d * 1 + d * d * 0;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 0; j++)
for (k = 0; k <= 1; k++)
p[10][i + d * (j + d * k)] = true;
class[10] = 2;
piecemax[10] = 1 + d * 0 + d * d * 1;
for (i = 0; i <= 0; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 1; k++)
p[11][i + d * (j + d * k)] = true;
class[11] = 2;
piecemax[11] = 0 + d * 1 + d * d * 1;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 1; k++)
p[12][i + d * (j + d * k)] = true;
class[12] = 3;
piecemax[12] = 1 + d * 1 + d * d * 1;
piececount[0] = 13;
piececount[1] = 3;
piececount[2] = 1;
piececount[3] = 1;
m = 1 + d * (1 + d * 1);
kount = 0;
if (Fit (0, m))
n = Place (0, m);
else
printf ("Error1 in Puzzle\n");
if (!Trial (n))
printf ("Error2 in Puzzle.\n");
else if (kount != 2005)
printf ("Error3 in Puzzle.\n");
}
Initarr ()
{
int i, temp;
Initrand ();
biggest = 0;
littlest = 0;
for (i = 1; i <= sortelements; i++)
{
temp = Rand ();
sortlist[i] = temp - (temp / 100000) * 100000 - 50000;
if (sortlist[i] > biggest)
biggest = sortlist[i];
else if (sortlist[i] < littlest)
littlest = sortlist[i];
}
}
Quicksort (a, l, r)
int a[], l, r;
{
int i, j, x, w;
i = l;
j = r;
x = a[(l + r) / 2];
do
{
while (a[i] < x)
i = i + 1;
while (x < a[j])
j = j - 1;
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_QUICKSORT (cycles_start,i, j, x);
#else
BENCH_QUICKSORT:
#endif
if (__builtin_expect(quicksort_cycles_idx != CYCLES_HBOUND,0))
{
quicksort_cycles_idx++;
(*quicksort_cycles)[quicksort_cycles_idx] = rdtsc() - cycles_start;
}
if (i <= j)
{
w = a[i];
a[i] = a[j];
a[j] = w;
i = i + 1;
j = j - 1;
}
}
while (i <= j);
if (l < j)
Quicksort (a, l, j);
if (i < r)
Quicksort (a, i, r);
}
Quick ()
{
Initarr ();
Quicksort (sortlist, 1, sortelements);
if ((sortlist[1] != littlest) || (sortlist[sortelements] != biggest))
printf (" Error in Quick.\n");
}
tInitarr ()
{
int i, temp;
Initrand ();
biggest = 0;
littlest = 0;
for (i = 1; i <= sortelements; i++)
{
temp = Rand ();
sortlist[i] = temp - (temp / 100000) * 100000 - 50000;
if (sortlist[i] > biggest)
biggest = sortlist[i];
else if (sortlist[i] < littlest)
littlest = sortlist[i];
}
}
CreateNode (t, n)
struct node **t;
int n;
{
*t = (struct node *) malloc (sizeof (struct node));
(*t)->left = nil;
(*t)->right = nil;
(*t)->val = n;
}
Insert (n, t)
int n;
struct node *t;
{
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_INSERT (cycles_start,n, t);
#else
BENCH_INSERT:
#endif
if (__builtin_expect(insert_cycles_idx != CYCLES_HBOUND,0))
{
insert_cycles_idx++;
(*insert_cycles)[insert_cycles_idx] = rdtsc() - cycles_start;
}
if (n > t->val)
if (t->left == nil)
CreateNode (&t->left, n);
else
Insert (n, t->left);
else if (n < t->val)
if (t->right == nil)
CreateNode (&t->right, n);
else
Insert (n, t->right);
}
int
Checktree (p)
struct node *p;
{
int result;
result = true;
if (p->left != nil)
if (p->left->val <= p->val)
result = false;
else
result = Checktree (p->left) && result;
if (p->right != nil)
if (p->right->val >= p->val)
result = false;
else
result = Checktree (p->right) && result;
return (result);
}
Trees ()
{
int i;
tInitarr ();
tree = (struct node *) malloc (sizeof (struct node));
tree->left = nil;
tree->right = nil;
tree->val = sortlist[1];
for (i = 2; i <= sortelements; i++)
Insert (sortlist[i], tree);
if (!Checktree (tree))
printf (" Error in Tree.\n");
}
bInitarr ()
{
int i, temp;
Initrand ();
biggest = 0;
littlest = 0;
for (i = 1; i <= srtelements; i++)
{
temp = Rand ();
sortlist[i] = temp - (temp / 100000) * 100000 - 50000;
if (sortlist[i] > biggest)
biggest = sortlist[i];
else if (sortlist[i] < littlest)
littlest = sortlist[i];
}
}
Bubble ()
{
int i, j;
bInitarr ();
top = srtelements;
while (top > 1)
{
i = 1;
while (i < top)
{
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_BUBBLE (cycles_start,i, top);
#else
BENCH_BUBBLE:
#endif
if (__builtin_expect(bubble_cycles_idx != CYCLES_HBOUND,0))
{
bubble_cycles_idx++;
(*bubble_cycles)[bubble_cycles_idx] = rdtsc() - cycles_start;
}
if (sortlist[i] > sortlist[i + 1])
{
j = sortlist[i];
sortlist[i] = sortlist[i + 1];
sortlist[i + 1] = j;
}
i = i + 1;
}
top = top - 1;
}
if ((sortlist[1] != littlest) || (sortlist[srtelements] != biggest))
printf ("Error3 in Bubble.\n");
}
float
Cos (x)
float x;
{
int i, factor;
float result, power;
result = 1.0;
factor = 1;
power = x;
for (i = 2; i <= 10; i++)
{
factor = factor * i;
power = power * x;
if ((i & 1) == 0)
{
if ((i & 3) == 0)
result = result + power / factor;
else
result = result - power / factor;
}
}
return (result);
}
int
Min0 (arg1, arg2)
int arg1, arg2;
{
if (arg1 < arg2)
return (arg1);
else
return (arg2);
}
Printcomplex (arg1, arg2, zarray, start, finish, increment)
int arg1, arg2, start, finish, increment;
struct complex zarray[];
{
int i;
printf ("\n");
i = start;
do
{
printf (" %15.3e%15.3e", zarray[i].rp, zarray[i].ip);
i = i + increment;
printf (" %15.3e%15.3e", zarray[i].rp, zarray[i].ip);
printf ("\n");
i = i + increment;
}
while (i <= finish);
}
Uniform11 (iy, yfl)
int iy;
float yfl;
{
iy = (4855 * iy + 1731) & 8191;
yfl = iy / 8192.0;
}
Exptab (n, e)
int n;
struct complex e[];
{
float theta, divisor, h[26];
int i, j, k, l, m;
theta = 3.1415926536;
divisor = 4.0;
for (i = 1; i <= 25; i++)
{
h[i] = 1 / (2 * Cos (theta / divisor));
divisor = divisor + divisor;
}
m = n / 2;
l = m / 2;
j = 1;
e[1].rp = 1.0;
e[1].ip = 0.0;
e[l + 1].rp = 0.0;
e[l + 1].ip = 1.0;
e[m + 1].rp = -1.0;
e[m + 1].ip = 0.0;
do
{
i = l / 2;
k = i;
do
{
e[k + 1].rp = h[j] * (e[k + i + 1].rp + e[k - i + 1].rp);
e[k + 1].ip = h[j] * (e[k + i + 1].ip + e[k - i + 1].ip);
k = k + l;
}
while (k <= m);
j = Min0 (j + 1, 25);
l = i;
}
while (l > 1);
}
Fft (n, z, w, e, sqrinv)
int n;
struct complex z[], w[];
struct complex e[];
float sqrinv;
{
int i, j, k, l, m, index;
m = n / 2;
l = 1;
do
{
k = 0;
j = l;
i = 1;
do
{
do
{
cycles_start = rdtsc();
#ifndef NO_STAP_SDT
BENCH_FFT (cycles_start,n, z, w, e);
#else
BENCH_FFT:
#endif
if (__builtin_expect(fft_cycles_idx != CYCLES_HBOUND,0))
{
fft_cycles_idx++;
(*fft_cycles)[fft_cycles_idx] = rdtsc() - cycles_start;
}
w[i + k].rp = z[i].rp + z[m + i].rp;
w[i + k].ip = z[i].ip + z[m + i].ip;
w[i + j].rp = e[k + 1].rp * (z[i].rp - z[i + m].rp)
- e[k + 1].ip * (z[i].ip - z[i + m].ip);
w[i + j].ip = e[k + 1].rp * (z[i].ip - z[i + m].ip)
+ e[k + 1].ip * (z[i].rp - z[i + m].rp);
i = i + 1;
}
while (i <= j);
k = j;
j = k + l;
}
while (j <= m);
index = 1;
do
{
z[index] = w[index];
index = index + 1;
}
while (index <= n);
l = l + l;
}
while (l <= m);
for (i = 1; i <= n; i++)
{
z[i].rp = sqrinv * z[i].rp;
z[i].ip = -sqrinv * z[i].ip;
};
}
Oscar ()
{
int i;
Exptab (fftsize, e);
seed = 5767;
for (i = 1; i <= fftsize; i++)
{
Uniform11 (seed, zr);
Uniform11 (seed, zi);
z[i].rp = 20.0 * zr - 10.0;
z[i].ip = 20.0 * zi - 10.0;
};
for (i = 1; i <= 20; i++)
{
Fft (fftsize, z, w, e, 0.0625);
}
}
#define Start()
#define Stop(a,b)
#ifndef LOOP
#define LOOP 500
#endif
int
main ()
{
int i,j;
permute_cycles = calloc(CYCLES_HBOUND,sizeof(long));
tower_cycles = calloc(CYCLES_HBOUND,sizeof(long));
try_cycles = calloc(CYCLES_HBOUND,sizeof(long));
innerproduct_cycles = calloc(CYCLES_HBOUND,sizeof(long));
trial_cycles = calloc(CYCLES_HBOUND,sizeof(long));
quicksort_cycles = calloc(CYCLES_HBOUND,sizeof(long));
insert_cycles = calloc(CYCLES_HBOUND,sizeof(long));
bubble_cycles = calloc(CYCLES_HBOUND,sizeof(long));
fft_cycles = calloc(CYCLES_HBOUND,sizeof(long));
Start ();
for (i = 0; i < LOOP; i++)
Perm ();
Stop ("Perm", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Towers ();
Stop ("Towers", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Queens ();
Stop ("Queens", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Intmm ();
Stop ("Intmm", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Mm ();
Stop ("Mm", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Puzzle ();
Stop ("Puzzle", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Quick ();
Stop ("Quick", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Bubble ();
Stop ("Bubble", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Trees ();
Stop ("Trees", LOOP);
Start ();
for (i = 0; i < LOOP; i++)
Oscar ();
Stop ("Oscar", LOOP);
for (j = 1; j <= permute_cycles_idx; j++)
permute_cycles_avg += (*permute_cycles)[j];
printf ("permute_cycles %#lx\n", permute_cycles_avg / permute_cycles_idx);
for (j = 1; j <= tower_cycles_idx; j++)
tower_cycles_avg += (*tower_cycles)[j];
printf ("tower_cycles %#lx\n", tower_cycles_avg / tower_cycles_idx);
for (j = 1; j <= try_cycles_idx; j++)
try_cycles_avg += (*try_cycles)[j];
printf ("try_cycles %#lx\n", try_cycles_avg / try_cycles_idx);
for (j = 1; j <= innerproduct_cycles_idx; j++)
innerproduct_cycles_avg += (*innerproduct_cycles)[j];
printf ("innerproduct_cycles %#lx\n", innerproduct_cycles_avg / innerproduct_cycles_idx);
for (j = 1; j <= trial_cycles_idx; j++)
trial_cycles_avg += (*trial_cycles)[j];
printf ("trial_cycles %#lx\n", trial_cycles_avg / trial_cycles_idx);
for (j = 1; j <= quicksort_cycles_idx; j++)
quicksort_cycles_avg += (*quicksort_cycles)[j];
printf ("quicksort_cycles %#lx\n", quicksort_cycles_avg / quicksort_cycles_idx);
for (j = 1; j <= insert_cycles_idx; j++)
insert_cycles_avg += (*insert_cycles)[j];
printf ("insert_cycles %#lx\n", insert_cycles_avg / insert_cycles_idx);
for (j = 1; j <= bubble_cycles_idx; j++)
bubble_cycles_avg += (*bubble_cycles)[j];
printf ("bubble_cycles %#lx\n", bubble_cycles_avg / bubble_cycles_idx);
for (j = 1; j <= fft_cycles_idx; j++)
fft_cycles_avg += (*fft_cycles)[j];
printf ("fft_cycles %#lx\n", fft_cycles_avg / fft_cycles_idx);
return 0;
}