stanford.c

mips架构的bootloader,99左右的版本 但源代码现在没人更新了

/*  This is a suite of benchmarks that are relatively short, both in program
    size and execution time.  It requires no input, and prints 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. */

/*  This program requires floating-point, and so it will only run correctly
 *  if the execution environment includes floating-point support in hardware,
 *  or via software emulation.
 */

#ifndef PMCC
#include <sys/types.h>
#include <sys/times.h>
#endif

#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 */

#ifdef PMCC
int Getclock () /* return time in millisecs */
{
return clock()/1000;
}
#else
int Getclock ()
    {

        struct tms tbuf;
        int r;

        times(&tbuf);
        r = tbuf.tms_utime * 100;
        return r/6;
    }
#endif


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",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;
        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);
    }




    /* A compute-bound program from Forest Baskett. */

    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++ )