diff options
| -rw-r--r-- | Makefile | 32 | ||||
| -rw-r--r-- | nbench1.h | 13 | ||||
| -rw-r--r-- | numsort.c | 321 |
3 files changed, 160 insertions, 206 deletions
@@ -19,15 +19,15 @@ default: nbench # You should leave -static in the CFLAGS so that your sysinfo can be # compiled into the executable. -CCC=gcc +ICC=icc GCC=gcc # generic options for gcc #CFLAGS=-O3 -mcpu=ev67 -mieee -funroll-loops -ftree-vectorize -fprefetch-loop-arrays -pipe -static -msmall-data -msmall-text #CFLAGS=-O3 -mcpu=ev67 -mieee -pipe -msmall-data -msmall-text -funroll-loops -ftree-vectorize -static -GCCFLAGS=-O3 -march=k8 -msse3 -ftree-vectorize -funroll-loops -pipe -#CCCFLAGS=-fast -unroll 0 -inline speed -CCCFLAGS=${GCCFLAGS} +GCCFLAGS=-O3 -march=k8 -msse3 -ftree-vectorize -funroll-loops -pipe -static +#GCCFLAGS=-fast -unroll 0 -inline speed +ICCFLAGS=-O2 -ip -xP -gcc -static LINKFLAGS= # if your gcc lets you do it, then try this one @@ -120,33 +120,33 @@ nbench0.o: nbench0.h nbench0.c nmglobal.h hardware.h Makefile sysinfo.c sysinfoc # Segfault before first test emfloat.o: emfloat.h emfloat.c nmglobal.h Makefile - $(CCC) $(DEFINES) $(CCCFLAGS) -c emfloat.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c emfloat.c randnum.o: randnum.c Makefile - $(CCC) $(DEFINES) $(CCCFLAGS) -c randnum.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c randnum.c numsort.o: numsort.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c numsort.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c numsort.c # gcc - 2.95 # ccc - 5.08 stringsort.o: stringsort.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c stringsort.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c stringsort.c # gcc - 6.77 # ccc - 7.24 bitfield.o: bitfield.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c bitfield.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c bitfield.c # gcc - 4.93, 4.90, 4.93, 4.93 # ccc - 4.79, 4.85, 4.81, fpemulation.o: fpemulation.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c fpemulation.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c fpemulation.c # gcc - 13.90 # ccc - 13.90 fourier.o: fourier.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c fourier.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c fourier.c # gcc - 15.96 # ccc - 19.30 @@ -156,14 +156,14 @@ assignment.o: assignment.c # ccc - 7.98 idea.o: idea.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c idea.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c idea.c # gcc - 8.79 # ccc - 9.10 huffman.o: huffman.c $(GCC) $(DEFINES) $(GCCFLAGS) -c huffman.c -# $(CCC) $(DEFINES) -O1 -host -unroll 0 -inline speed -c huffman.c -g3 -# $(CCC) $(DEFINES) $(CCCFLAGS) -c huffman.c -g3 +# $(GCC) $(DEFINES) -O1 -host -unroll 0 -inline speed -c huffman.c -g3 +# $(GCC) $(DEFINES) $(GCCFLAGS) -c huffman.c -g3 # gcc - 6.94 # ccc - segfault # ccc -O1 -host - 5.14 @@ -171,12 +171,12 @@ huffman.o: huffman.c # ccc -O1 -host -unroll 0 -inline speed - 5.95 neural.o: neural.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c neural.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c neural.c # gcc - 12.00 # ccc - 14.20 linear.o: linear.c - $(CCC) $(DEFINES) $(CCCFLAGS) -c linear.c + $(GCC) $(DEFINES) $(GCCFLAGS) -c linear.c # gcc - 16.38 # ccc - 23.29 @@ -72,19 +72,6 @@ extern double TicksToFracSecs(unsigned long tickamount); ** PROTOTYPES */ void DoNumSort(void); -static unsigned long DoNumSortIteration(long *arraybase, - unsigned long arraysize, - unsigned int numarrays); -static void LoadNumArrayWithRand(long *array, - unsigned long arraysize, - unsigned int numarrays); -static void NumHeapSort(long *array, - unsigned long bottom, - unsigned long top); -static void NumSift(long *array, - unsigned long i, - unsigned long j); - /**************** ** STRING SORT ** @@ -1,11 +1,7 @@ #include <stdio.h> -#include <stdint.h> -/* #include <stdlib.h> -#include <string.h> -#include <strings.h> -#include <math.h> -*/ +#include <stdint.h> + #include "nmglobal.h" #include "nbench1.h" @@ -15,110 +11,91 @@ ** This test implements a heapsort algorithm, performed on an ** array of longs. */ +static unsigned long DoNumSortIteration(long *arraybase, unsigned long arraysize, unsigned int numarrays); +static void LoadNumArrayWithRand(long *array, unsigned long arraysize, unsigned int numarrays); +static inline void NumHeapSort(long *array, unsigned long bottom, unsigned long top); +static inline void NumSift(long *array, unsigned long min, unsigned long max); /************** ** DoNumSort ** *************** ** This routine performs the CPU numeric sort test. -** NOTE: Last version incorrectly stated that the routine -** returned result in # of longword sorted per second. -** Not so; the routine returns # of iterations per sec. */ void DoNumSort(void) { /* Error context string pointer */ - const char *errorcontext = "CPU:Numeric Sort"; + const char *context = "CPU:Numeric Sort"; /* Local pointer to global struct */ SortStruct * numsortstruct = &global_numsortstruct; long accumtime; /* Accumulated time */ double iterations; /* Iteration counter */ - long *arraybase; /* Base pointers of array */ - int systemerror; /* For holding error codes */ - -/* -** See if we need to do self adjustment code. -*/ -if(numsortstruct->adjust==0) -{ - /* - ** Self-adjustment code. The system begins by sorting 1 - ** array. If it does that in no time, then two arrays - ** are built and sorted. This process continues until - ** enough arrays are built to handle the tolerance. - */ - numsortstruct->numarrays=1; - while(1) - { - /* - ** Allocate space for arrays - */ - arraybase=(long *)AllocateMemory(sizeof(long) * - numsortstruct->numarrays * numsortstruct->arraysize, - &systemerror); - if(systemerror) - { ReportError(errorcontext,systemerror); - FreeMemory((void *)arraybase, - &systemerror); - } - - /* - ** Do an iteration of the numeric sort. If the - ** elapsed time is less than or equal to the permitted - ** minimum, then allocate for more arrays and - ** try again. - */ - if(DoNumSortIteration(arraybase, - numsortstruct->arraysize, - numsortstruct->numarrays)>global_min_ticks) - break; /* We're ok...exit */ + long *arraybase = NULL; /* Base pointers of array */ + + /* + ** See if we need to do self adjustment code. + */ + if(numsortstruct->adjust==0) { + /* + ** Self-adjustment code. The system begins by sorting 1 + ** array. If it does that in no time, then two arrays + ** are built and sorted. This process continues until + ** enough arrays are built to handle the tolerance. + */ + numsortstruct->numarrays=1; + while(1) { + arraybase = realloc(arraybase, numsortstruct->numarrays * numsortstruct->arraysize * sizeof(long)); + if (!arraybase) { + fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context); + exit(1); + } - FreeMemory((void *)arraybase,&systemerror); - if(numsortstruct->numarrays++>NUMNUMARRAYS) - { printf("CPU:NSORT -- NUMNUMARRAYS hit.\n"); - } - } -} -else -{ /* - ** Allocate space for arrays - */ - arraybase=(long *)AllocateMemory(sizeof(long) * - numsortstruct->numarrays * numsortstruct->arraysize, - &systemerror); - if(systemerror) - { ReportError(errorcontext,systemerror); - FreeMemory((void *)arraybase, - &systemerror); - } + /* + ** Do an iteration of the numeric sort. If the + ** elapsed time is less than or equal to the permitted + ** minimum, then allocate for more arrays and + ** try again. + */ + if ( DoNumSortIteration(arraybase, numsortstruct->arraysize, numsortstruct->numarrays)>global_min_ticks ) { + break; + } -} -/* -** All's well if we get here. Repeatedly perform sorts until the -** accumulated elapsed time is greater than # of seconds requested. -*/ -accumtime = 0L; -iterations = 0.0; + if(numsortstruct->numarrays > NUMNUMARRAYS) { + printf("CPU:NSORT -- NUMNUMARRAYS hit.\n"); + } + ++numsortstruct->numarrays; + } + } else { + arraybase = malloc(numsortstruct->numarrays * numsortstruct->arraysize * sizeof(long)); + if (!arraybase) { + fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context); + exit(1); + } + } -do { - accumtime+=DoNumSortIteration(arraybase, - numsortstruct->arraysize, - numsortstruct->numarrays); - iterations+=(double)1.0; -} while(TicksToSecs(accumtime)<numsortstruct->request_secs); + /* + ** All's well if we get here. Repeatedly perform sorts until the + ** accumulated elapsed time is greater than # of seconds requested. + */ + accumtime = 0L; + iterations = 0.0; -/* -** Clean up, calculate results, and go home. Be sure to -** show that we don't have to rerun adjustment code. -*/ -FreeMemory((void *)arraybase,&systemerror); + do { + accumtime += DoNumSortIteration(arraybase, numsortstruct->arraysize, numsortstruct->numarrays); + iterations += 1.0; + } while ( TicksToSecs(accumtime) < numsortstruct->request_secs ); -numsortstruct->sortspersec=iterations * - (double)numsortstruct->numarrays / TicksToFracSecs(accumtime); + /* + ** Clean up, calculate results, and go home. Be sure to + ** show that we don't have to rerun adjustment code. + */ + free(arraybase); -if(numsortstruct->adjust==0) - numsortstruct->adjust=1; + numsortstruct->sortspersec=iterations * (double)numsortstruct->numarrays / TicksToFracSecs(accumtime); + if ( numsortstruct->adjust == 0 ) { + numsortstruct->adjust = 1; + } } /*********************** @@ -128,34 +105,33 @@ if(numsortstruct->adjust==0) ** sort benchmark. It returns the number of ticks ** elapsed for the iteration. */ -static unsigned long DoNumSortIteration(long *arraybase, - unsigned long arraysize, - unsigned int numarrays) -{ -unsigned long elapsed; /* Elapsed ticks */ -unsigned long i; -/* -** Load up the array with random numbers -*/ -LoadNumArrayWithRand(arraybase,arraysize,numarrays); - -/* -** Start the stopwatch -*/ -elapsed=StartStopwatch(); - -/* -** Execute a heap of heapsorts -*/ -for(i=0;i<numarrays;i++) - NumHeapSort(arraybase+i*arraysize,0L,arraysize-1L); +static unsigned long DoNumSortIteration(long *arraybase, unsigned long arraysize, unsigned int numarrays) { + unsigned long elapsed; /* Elapsed ticks */ + unsigned long i; + + /* + ** Load up the array with random numbers + */ + LoadNumArrayWithRand(arraybase, arraysize, numarrays); + + /* + ** Start the stopwatch + */ + elapsed = StartStopwatch(); + + /* + ** Execute a heap of heapsorts + */ + for(i = 0; i < numarrays; i++ ) { + NumHeapSort(arraybase + i * arraysize, 0L, arraysize - 1L); + } -/* -** Get elapsed time -*/ -elapsed=StopStopwatch(elapsed); + /* + ** Get elapsed time + */ + elapsed = StopStopwatch(elapsed); -return(elapsed); + return(elapsed); } /************************* @@ -163,37 +139,33 @@ return(elapsed); ************************** ** Load up an array with random longs. */ -static void LoadNumArrayWithRand(long *array, /* Pointer to arrays */ +static void LoadNumArrayWithRand(long *array, /* Pointer to arrays */ unsigned long arraysize, unsigned int numarrays) /* # of elements in array */ { -long i; /* Used for index */ -long *darray; /* Destination array pointer */ -/* -** Initialize the random number generator -*/ -/* randnum(13L); */ -randnum(13); - -/* -** Load up first array with randoms -*/ -for(i=0L;i<arraysize;i++) - /* array[i]=randnum(0L); */ - array[i]=randnum((int32_t)0); - -/* -** Now, if there's more than one array to load, copy the -** first into each of the others. -*/ -darray=array; -while(--numarrays) -{ darray+=arraysize; - for(i=0L;i<arraysize;i++) - darray[i]=array[i]; -} + long i; /* Used for index */ + long *darray; /* Destination array pointer */ + /* + ** Initialize the random number generator + */ + randnum(13); + + /* + ** Load up first array with randoms + */ + for( i = 0; i < arraysize; i++ ) { + array[i] = randnum(0); + } -return; + /* + ** Now, if there's more than one array to load, copy the + ** first into each of the others. + */ + darray = array; + while ( --numarrays ) { + darray += arraysize; + memcpy(darray, array, arraysize * sizeof(long)); + } } /**************** @@ -203,31 +175,29 @@ return; ** integers. Also pass in minimum and maximum offsets. ** This routine performs a heap sort on that array. */ -static void NumHeapSort(long *array, - unsigned long bottom, /* Lower bound */ - unsigned long top) /* Upper bound */ -{ -unsigned long temp; /* Used to exchange elements */ -unsigned long i; /* Loop index */ +static inline void NumHeapSort(long *array, unsigned long bottom, unsigned long top) { + unsigned long temp; /* Used to exchange elements */ + unsigned long i; /* Loop index */ -/* -** First, build a heap in the array -*/ -for(i=(top/2L); i>0; --i) - NumSift(array,i,top); + /* + ** First, build a heap in the array + */ + for (i = (top / 2L); i > 0; i-- ) { + NumSift(array, i, top); + } -/* -** Repeatedly extract maximum from heap and place it at the -** end of the array. When we get done, we'll have a sorted -** array. -*/ -for(i=top; i>0; --i) -{ NumSift(array,bottom,i); - temp=*array; /* Perform exchange */ - *array=*(array+i); - *(array+i)=temp; -} -return; + /* + ** Repeatedly extract maximum from heap and place it at the + ** end of the array. When we get done, we'll have a sorted + ** array. + */ + for ( i = top; i > 0; i-- ) { + NumSift(array, bottom, i); + + temp = *array; + *array = *(array + i); + *(array + i) = temp; + } } /************ @@ -236,28 +206,25 @@ return; ** Peforms the sift operation on a numeric array, ** constructing a heap in the array. */ -static void NumSift(long *array,/* Array of numbers */ - unsigned long i, /* Minimum of array */ - unsigned long j) /* Maximum of array */ -{ +static inline void NumSift(long *array, unsigned long min, unsigned long max) { unsigned long k; unsigned long temp; /* Used for exchange */ - while ( ( i + i ) <= j ) { - k = i + i; - if ( k < j ) { + while ( ( min * 2 ) <= max ) { + k = min * 2; + if ( k < max ) { if ( array[k] < array[k+1L] ) { ++k; } } - if ( array[i] < array[k] ) { + if ( array[min] < array[k] ) { temp = array[k]; - array[k] = array[i]; - array[i] = temp; - i = k; + array[k] = array[min]; + array[min] = temp; + min = k; } else { - i = j + 1; + min = max + 1; } } } |