summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--bitfield.c222
-rw-r--r--fpemulation.c29
-rw-r--r--numsort.c57
3 files changed, 148 insertions, 160 deletions
diff --git a/bitfield.c b/bitfield.c
index 7115524..3d56794 100644
--- a/bitfield.c
+++ b/bitfield.c
@@ -1,17 +1,11 @@
-#include <stdint.h>
-/*
#include <stdio.h>
#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#include <math.h>*/
+#include <stdint.h>
+#include <math.h>
+
#include "nmglobal.h"
#include "nbench1.h"
-#ifdef DEBUG
-static int numsort_status=0;
-static int stringsort_status=0;
-#endif
/************************
** BITFIELD OPERATIONS **
@@ -23,118 +17,106 @@ static int stringsort_status=0;
** Perform the bit operations test portion of the CPU
** benchmark. Returns the iterations per second.
*/
-void DoBitops(void)
-{
-BitOpStruct *locbitopstruct; /* Local bitop structure */
-unsigned long *bitarraybase; /* Base of bitmap array */
-unsigned long *bitoparraybase; /* Base of bitmap operations array */
-unsigned long nbitops; /* # of bitfield operations */
-unsigned long accumtime; /* Accumulated time in ticks */
-double iterations; /* # of iterations */
-char *errorcontext; /* Error context string */
-int systemerror; /* For holding error codes */
-int ticks;
-
-/*
-** Link to global structure.
-*/
-locbitopstruct=&global_bitopstruct;
-
-/*
-** Set the error context.
-*/
-errorcontext="CPU:Bitfields";
-
-/*
-** See if we need to run adjustment code.
-*/
-if(locbitopstruct->adjust==0)
-{
- bitarraybase=(unsigned long *)AllocateMemory(locbitopstruct->bitfieldarraysize *
- sizeof(unsigned long),&systemerror);
- if(systemerror)
- { ReportError(errorcontext,systemerror);
- }
-
- /*
- ** Initialize bitfield operations array to [2,30] elements
- */
- locbitopstruct->bitoparraysize=30L;
-
- while(1)
- {
- /*
- ** Allocate space for operations array
- */
- bitoparraybase=(unsigned long *)AllocateMemory(locbitopstruct->bitoparraysize*2L*
- sizeof(unsigned long),
- &systemerror);
- if(systemerror)
- { ReportError(errorcontext,systemerror);
- FreeMemory((void *)bitarraybase,&systemerror);
- }
- /*
- ** Do an iteration of the bitmap test. If the
- ** elapsed time is less than or equal to the permitted
- ** minimum, then de-allocate the array, reallocate a
- ** larger version, and try again.
- */
- ticks=DoBitfieldIteration(bitarraybase,
- bitoparraybase,
- locbitopstruct->bitoparraysize,
- &nbitops);
-
- if (ticks>global_min_ticks) break; /* We're ok...exit */
-
- FreeMemory((void *)bitoparraybase,&systemerror);
- locbitopstruct->bitoparraysize+=100L;
- }
-}
-else
+void
+DoBitops(void)
{
- /*
- ** Don't need to do self adjustment, just allocate
- ** the array space.
- */
- bitarraybase=(unsigned long *)AllocateMemory(locbitopstruct->bitfieldarraysize *
- sizeof(unsigned long),&systemerror);
- if(systemerror)
- { ReportError(errorcontext,systemerror);
- }
- bitoparraybase=(unsigned long *)AllocateMemory(locbitopstruct->bitoparraysize*2L*
- sizeof(unsigned long),
- &systemerror);
- if(systemerror)
- { ReportError(errorcontext,systemerror);
- FreeMemory((void *)bitarraybase,&systemerror);
- }
-}
-
-/*
-** All's well if we get here. Repeatedly perform bitops until the
-** accumulated elapsed time is greater than # of seconds requested.
-*/
-accumtime=0L;
-iterations=(double)0.0;
-do {
- accumtime+=DoBitfieldIteration(bitarraybase,
- bitoparraybase,
- locbitopstruct->bitoparraysize,&nbitops);
- iterations+=(double)nbitops;
-} while(TicksToSecs(accumtime)<locbitopstruct->request_secs);
-
-/*
-** Clean up, calculate results, and go home.
-** Also, set adjustment flag to show that we don't have
-** to do self adjusting in the future.
-*/
-FreeMemory((void *)bitarraybase,&systemerror);
-FreeMemory((void *)bitoparraybase,&systemerror);
-locbitopstruct->bitopspersec=iterations /TicksToFracSecs(accumtime);
-if(locbitopstruct->adjust==0)
- locbitopstruct->adjust=1;
-
-return;
+ /* Error context string */
+ const char *context = "CPU:Bitfields";
+ /* Local bitop structure */
+ BitOpStruct *locbitopstruct = &global_bitopstruct;
+
+ unsigned long *bitarraybase = NULL; /* Base of bitmap array */
+ unsigned long *bitoparraybase = NULL; /* Base of bitmap operations array */
+ unsigned long nbitops; /* # of bitfield operations */
+ unsigned long accumtime; /* Accumulated time in ticks */
+ double iterations; /* # of iterations */
+ int ticks;
+
+ /*
+ ** See if we need to run adjustment code.
+ */
+ if (locbitopstruct->adjust == 0) {
+ bitarraybase = realloc(bitarraybase, locbitopstruct->bitfieldarraysize * sizeof(unsigned long));
+ if (!bitarraybase) {
+ fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
+ exit(1);
+ }
+
+ /*
+ ** Initialize bitfield operations array to [2,30] elements
+ */
+ locbitopstruct->bitoparraysize = 30L;
+
+ while(1) {
+ bitoparraybase = malloc(locbitopstruct->bitoparraysize * 2 * sizeof(unsigned long));
+ if (!bitoparraybase) {
+ fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
+ free(bitarraybase);
+ exit(1);
+ }
+
+ /*
+ ** Do an iteration of the bitmap test. If the
+ ** elapsed time is less than or equal to the permitted
+ ** minimum, then de-allocate the array, reallocate a
+ ** larger version, and try again.
+ */
+ ticks = DoBitfieldIteration(bitarraybase,
+ bitoparraybase,
+ locbitopstruct->bitoparraysize,
+ &nbitops);
+
+ if (ticks > global_min_ticks) {
+ break;
+ }
+
+ locbitopstruct->bitoparraysize += 100L;
+ }
+ } else {
+ /*
+ ** Don't need to do self adjustment, just allocate
+ ** the array space.
+ */
+ bitarraybase = malloc(locbitopstruct->bitfieldarraysize * sizeof(unsigned long));
+ if (!bitarraybase) {
+ fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
+ exit(1);
+ }
+
+ bitoparraybase = malloc(locbitopstruct->bitoparraysize * 2 * sizeof(unsigned long));
+ if (!bitoparraybase) {
+ fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
+ free(bitarraybase);
+ exit(1);
+ }
+ }
+
+ /*
+ ** All's well if we get here. Repeatedly perform bitops until the
+ ** accumulated elapsed time is greater than # of seconds requested.
+ */
+ accumtime = 0L;
+ iterations = 0.0;
+ do {
+ accumtime += DoBitfieldIteration(bitarraybase,
+ bitoparraybase,
+ locbitopstruct->bitoparraysize,&nbitops);
+ iterations += (double)nbitops;
+ } while (TicksToSecs(accumtime) < locbitopstruct->request_secs);
+
+ /*
+ ** Clean up, calculate results, and go home.
+ ** Also, set adjustment flag to show that we don't have
+ ** to do self adjusting in the future.
+ */
+ free(bitarraybase);
+ free(bitoparraybase);
+
+ locbitopstruct->bitopspersec = iterations / TicksToFracSecs(accumtime);
+
+ if (locbitopstruct->adjust == 0) {
+ locbitopstruct->adjust = 1;
+ }
}
/************************
diff --git a/fpemulation.c b/fpemulation.c
index b9b6235..26ce951 100644
--- a/fpemulation.c
+++ b/fpemulation.c
@@ -1,9 +1,8 @@
#include <stdio.h>
#include <stdlib.h>
-/*
-#include <string.h>
-#include <strings.h>
-#include <math.h>*/
+#include <stdint.h>
+#include <math.h>
+
#include "nmglobal.h"
#include "nbench1.h"
@@ -18,7 +17,9 @@
** Perform the floating-point emulation routines portion of the
** CPU benchmark. Returns the operations per second.
*/
-void DoEmFloat(void) {
+void
+DoEmFloat(void)
+{
/* Error context string pointer */
const char *errorcontext = "CPU:Floating Emulation";
/* Local structure */
@@ -56,21 +57,19 @@ void DoEmFloat(void) {
SetupCPUEmFloatArrays(abase, bbase, cbase, locemfloatstruct->arraysize); /* FIXME: ugly */
- /*
- ** See if we need to do self-adjusting code.
- */
- if( locemfloatstruct->adjust == 0 ) {
- locemfloatstruct->loops=0;
+ /* See if we need to do self-adjusting code.*/
+ if (locemfloatstruct->adjust == 0) {
+ locemfloatstruct->loops = 0;
/*
** Do an iteration of the tests. If the elapsed time is
** less than minimum, increase the loop count and try
** again.
*/
- for ( loops = 1; loops < CPUEMFLOATLOOPMAX; loops += loops ) {
+ for (loops = 1; loops < CPUEMFLOATLOOPMAX; loops += loops) {
tickcount = DoEmFloatIteration(abase, bbase, cbase, /* FIXME: ugly */
locemfloatstruct->arraysize, loops);
- if ( tickcount > global_min_ticks ) {
+ if (tickcount > global_min_ticks) {
locemfloatstruct->loops = loops;
break;
}
@@ -80,7 +79,7 @@ void DoEmFloat(void) {
/*
** Verify that selft adjustment code worked.
*/
- if ( locemfloatstruct->loops == 0 ) {
+ if (locemfloatstruct->loops == 0) {
puts("CPU:EMFPU -- CMPUEMFLOATLOOPMAX limit hit");
free(abase);
free(bbase);
@@ -100,7 +99,7 @@ void DoEmFloat(void) {
accumtime += DoEmFloatIteration(abase, bbase, cbase, /* FIXME: ugly */
locemfloatstruct->arraysize, locemfloatstruct->loops);
iterations += 1.0;
- } while ( TicksToSecs(accumtime) < locemfloatstruct->request_secs );
+ } while (TicksToSecs(accumtime) < locemfloatstruct->request_secs);
/*
** Clean up, calculate results, and go home.
@@ -112,7 +111,7 @@ void DoEmFloat(void) {
locemfloatstruct->emflops = (iterations * (double)locemfloatstruct->loops)
/ (double)TicksToFracSecs(accumtime);
- if ( locemfloatstruct->adjust == 0 ) {
+ if (locemfloatstruct->adjust == 0) {
locemfloatstruct->adjust = 1;
}
}
diff --git a/numsort.c b/numsort.c
index 6337037..f0ab459 100644
--- a/numsort.c
+++ b/numsort.c
@@ -1,10 +1,12 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
+#include <math.h>
#include "nmglobal.h"
#include "nbench1.h"
+
/*********************
** NUMERIC HEAPSORT **
**********************
@@ -22,7 +24,9 @@ static inline void NumSift(long *array, unsigned long min, unsigned long max);
** This routine performs the CPU numeric sort test.
*/
-void DoNumSort(void) {
+void
+DoNumSort (void)
+{
/* Error context string pointer */
const char *context = "CPU:Numeric Sort";
/* Local pointer to global struct */
@@ -35,15 +39,15 @@ void DoNumSort(void) {
/*
** See if we need to do self adjustment code.
*/
- if(numsortstruct->adjust==0) {
+ 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) {
+ 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);
@@ -56,12 +60,12 @@ void DoNumSort(void) {
** minimum, then allocate for more arrays and
** try again.
*/
- if ( DoNumSortIteration(arraybase, numsortstruct->arraysize, numsortstruct->numarrays)>global_min_ticks ) {
+ if (DoNumSortIteration(arraybase, numsortstruct->arraysize, numsortstruct->numarrays)>global_min_ticks) {
break;
}
- if(numsortstruct->numarrays > NUMNUMARRAYS) {
- printf("CPU:NSORT -- NUMNUMARRAYS hit.\n");
+ if (numsortstruct->numarrays > NUMNUMARRAYS) {
+ puts("CPU:NSORT -- NUMNUMARRAYS hit.");
}
++numsortstruct->numarrays;
}
@@ -91,9 +95,9 @@ void DoNumSort(void) {
*/
free(arraybase);
- numsortstruct->sortspersec=iterations * (double)numsortstruct->numarrays / TicksToFracSecs(accumtime);
+ numsortstruct->sortspersec = iterations * (double)numsortstruct->numarrays / TicksToFracSecs(accumtime);
- if ( numsortstruct->adjust == 0 ) {
+ if (numsortstruct->adjust == 0) {
numsortstruct->adjust = 1;
}
}
@@ -105,7 +109,9 @@ void DoNumSort(void) {
** sort benchmark. It returns the number of ticks
** elapsed for the iteration.
*/
-static unsigned long DoNumSortIteration(long *arraybase, unsigned long arraysize, unsigned int numarrays) {
+static unsigned long
+DoNumSortIteration(long *arraybase, unsigned long arraysize, unsigned int numarrays)
+{
unsigned long elapsed; /* Elapsed ticks */
unsigned long i;
@@ -122,7 +128,7 @@ static unsigned long DoNumSortIteration(long *arraybase, unsigned long arraysize
/*
** Execute a heap of heapsorts
*/
- for(i = 0; i < numarrays; i++ ) {
+ for (i = 0; i < numarrays; i++) {
NumHeapSort(arraybase + i * arraysize, 0L, arraysize - 1L);
}
@@ -139,21 +145,19 @@ static unsigned long DoNumSortIteration(long *arraybase, unsigned long arraysize
**************************
** 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
- */
+
+ /* Initialize the random number generator */
randnum(13);
- /*
- ** Load up first array with randoms
- */
- for( i = 0; i < arraysize; i++ ) {
+ /* Load up first array with randoms */
+ for (i = 0; i < arraysize; i++) {
array[i] = randnum(0);
}
@@ -162,7 +166,7 @@ static void LoadNumArrayWithRand(long *array, /* Pointer to arrays */
** first into each of the others.
*/
darray = array;
- while ( --numarrays ) {
+ while (--numarrays) {
darray += arraysize;
memcpy(darray, array, arraysize * sizeof(long));
}
@@ -175,14 +179,16 @@ static void LoadNumArrayWithRand(long *array, /* Pointer to arrays */
** integers. Also pass in minimum and maximum offsets.
** This routine performs a heap sort on that array.
*/
-static inline void NumHeapSort(long *array, unsigned long bottom, unsigned long top) {
+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-- ) {
+ for (i = (top / 2L); i > 0; i--) {
NumSift(array, i, top);
}
@@ -191,7 +197,7 @@ static inline void NumHeapSort(long *array, unsigned long bottom, unsigned long
** end of the array. When we get done, we'll have a sorted
** array.
*/
- for ( i = top; i > 0; i-- ) {
+ for (i = top; i > 0; i--) {
NumSift(array, bottom, i);
temp = *array;
@@ -206,7 +212,9 @@ static inline void NumHeapSort(long *array, unsigned long bottom, unsigned long
** Peforms the sift operation on a numeric array,
** constructing a heap in the array.
*/
-static inline void NumSift(long *array, unsigned long min, unsigned long max) {
+static inline void
+NumSift(long *array, unsigned long min, unsigned long max)
+{
unsigned long k;
unsigned long temp; /* Used for exchange */
@@ -228,4 +236,3 @@ static inline void NumSift(long *array, unsigned long min, unsigned long max) {
}
}
}
-