stanford.c

来自「基于4个mips核的noc设计」· C语言 代码 · 共 864 行 · 第 1/2 页

#include <math.h>



#define PI              3.14
#define TWOPI           6.2831853071795865
#define HALFPI          1.5707963267948966
#define FOURTHPI        7.8539816339744831e-1
#define SIXTHPI         5.2359877559829887e-1


/*  This is a suite of benchmarks that are relatively short, both in program
    size and execution time.  It requires no input, and printfs the execution
    time for each program, using the system- dependent routine Getclock,
    below, to find out the current CPU time.  It does a rudimentary check to
    make sure each program gets the right output.  These programs were
    gathered by John Hennessy and modified by Peter Nye. */

#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 /* 0.73 */
#define  fpmmbase 	 2.92
#define  puzzlebase 	 0.5
#define  fftbase 	 0.0 /* 1.11 */
#define  fpfftbase 	 4.44
/* Towers */
#define maxcells 	 18

/* Intmm, Mm */
#define rowsize 	 40

/* Puzzle */
#define size	 	 511
#define classmax 	 3
#define typemax 	 12
#define d 		 8

/* Bubble, Quick */
#define sortelements 	 5000
#define srtelements 	 500

/* fft */
#define fftsize 	 256 
#define fftsize2 	 129  
/*
  type */
/* Perm */
#define    permrange 10

/* tree */
struct node {
  struct node *left,*right;
  int val;
};

/* Towers */ /*
   discsizrange = 1..maxcells; */
#define    stackrange	3
/*    cellcursor = 0..maxcells; */
struct    element {
  int discsize;
  int next;
};
/*    emsgtype = packed array[1..15] of char;
 */
/* Intmm, Mm */ /*
   index = 1 .. rowsize;
   intmatrix = array [index,index] of integer;
   realmatrix = array [index,index] of real;
   */
/* Puzzle */ /*
   piececlass = 0..classmax;
   piecetype = 0..typemax;
   position = 0..size;
   */
/* Bubble, Quick */ /*
   listsize = 0..sortelements;
   sortarray = array [listsize] of integer;
   */
/* FFT */
struct    complex { float rp, ip; } ;
/*
  carray = array [1..fftsize] of complex ;
  c2array = array [1..fftsize2] of complex ;
  */

float value;
float    fixed,floated;

/* global */
int    timer;
int    xtimes[11];
int    seed;

/* Perm */
int    permarray[permrange+1];
int    pctr;

/* tree */
struct node *tree;

/* Towers */
int    stack[stackrange+1];
struct element    cellspace[maxcells+1];
int    freelist,
  movesdone;

/* Intmm, Mm */
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];

/* Puzzle */
int	piececount[classmax+1],
  class[typemax+1],
  piecemax[typemax+1],
  puzzl[size+1],
  p[typemax+1][size+1],
  n,
  kount;

/* Bubble, Quick */
int    sortlist[sortelements+1],
  biggest, littlest,
  top;

/* FFT */
struct complex    z[fftsize+1], w[fftsize+1],
  e[fftsize2+1];
float    zr, zi;

/* global procedures */

int Getclock ()
{
	return 0;
};

Initrand ()
{
  seed = 74755;
};

int Rand ()
{
  seed = (seed * 1309 + 13849) & 65535;
  return( seed );
};



/* Permutation program, heavily recursive, written by Denny Brown. */

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;
{   /* permute */
  int k;
  pctr = pctr + 1;
  if ( n!=1 )  {
    Permute(n-1);
    for ( k = n-1; k >= 1; k-- ) {
      Swap(&permarray[n],&permarray[k]);
      Permute(n-1);
      Swap(&permarray[n],&permarray[k]);
    };
  };
}     /* permute */;

Perm ()    {   /* Perm */
  int i;
  pctr = 0;
  for ( i = 1; i <= 5; i++ ) {
    Initialize();
    Permute(7);
  };
  if ( pctr != 43300 )
    printf(" Error in Perm.\n");
}     /* Perm */;



/*  Program to Solve the Towers of Hanoi */

Error (emsg) char *emsg;
{
  printf(" Error in Towers: %s\n");
};

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;
  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 ()    { /* 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");
}; /* Towers */


/* The eight queens problem, solved 50 times. */
/*
  type    
  doubleboard =   2..16;
  doublenorm  =   -7..7;
  boardrange  =   1..8;
  aarray      =   array [boardrange] of boolean;
  barray      =   array [doubleboard] of boolean;
  carray      =   array [doublenorm] of boolean;
  xarray      =   array [boardrange] of boardrange;
  */

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;
      *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();
};

/* Multiplies two integer matrices. */

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;
     /* computes the inner product of A[row,*] and B[*,column] */
{
  int i;
  *result = 0;
  for(i = 1; i <= rowsize; i++ )*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);
};


/* Multiplies two real matrices. */

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;
     /* computes the inner product of A[row,*] and B[*,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);
};