From e618b16d4cc89e46ec4bac40af34a93790a17f8e Mon Sep 17 00:00:00 2001 From: Matt Turner Date: Wed, 12 Nov 2008 03:18:32 +0000 Subject: -- Cleanup fpemulation.c -- Begin cleaning numsort.c git-svn-id: svn://mattst88.com/svn/cleanbench/trunk@9 0d43b9a7-5ab2-4d7b-af9d-f64450cef757 --- bitfield.c | 25 ------- fpemulation.c | 226 +++++++++++++++++++++++++--------------------------------- numsort.c | 94 +++++++++--------------- sysspec.c | 2 +- sysspec.h | 2 +- 5 files changed, 134 insertions(+), 215 deletions(-) diff --git a/bitfield.c b/bitfield.c index 78aba9e..7115524 100644 --- a/bitfield.c +++ b/bitfield.c @@ -83,31 +83,6 @@ if(locbitopstruct->adjust==0) bitoparraybase, locbitopstruct->bitoparraysize, &nbitops); -#ifdef DEBUG -#ifdef LINUX - if (locbitopstruct->bitoparraysize==30L){ - /* this is the first loop, write a debug file */ - FILE *file; - unsigned long *running_base; /* same as unsigned long */ - long counter; - file=fopen("debugbit.dat","w"); - running_base=bitarraybase; - for (counter=0;counter<(long)(locbitopstruct->bitfieldarraysize);counter++){ -#ifdef _LP64 - fprintf(file,"%08X",(unsigned int)(*running_base&0xFFFFFFFFL)); - fprintf(file,"%08X",(unsigned int)((*running_base>>32)&0xFFFFFFFFL)); - if ((counter+1)%4==0) fprintf(file,"\n"); -#else - fprintf(file,"%08lX",*running_base); - if ((counter+1)%8==0) fprintf(file,"\n"); -#endif - running_base=running_base+1; - } - fclose(file); - printf("\nWrote the file debugbit.dat, you may want to compare it to debugbit.good\n"); - } -#endif -#endif if (ticks>global_min_ticks) break; /* We're ok...exit */ diff --git a/fpemulation.c b/fpemulation.c index d4332a3..7d631bf 100644 --- a/fpemulation.c +++ b/fpemulation.c @@ -1,6 +1,6 @@ #include -/* #include +/* #include #include #include */ @@ -18,130 +18,102 @@ ** Perform the floating-point emulation routines portion of the ** CPU benchmark. Returns the operations per second. */ -void DoEmFloat(void) -{ -EmFloatStruct *locemfloatstruct; /* Local structure */ -InternalFPF *abase; /* Base of A array */ -InternalFPF *bbase; /* Base of B array */ -InternalFPF *cbase; /* Base of C array */ -unsigned long accumtime; /* Accumulated time in ticks */ -double iterations; /* # of iterations */ -unsigned long tickcount; /* # of ticks */ -char *errorcontext; /* Error context string pointer */ -int systemerror; /* For holding error code */ -unsigned long loops; /* # of loops */ - -/* -** Link to global structure -*/ -locemfloatstruct=&global_emfloatstruct; - -/* -** Set the error context -*/ -errorcontext="CPU:Floating Emulation"; - - -/* -** Test the emulation routines. -*/ -#ifdef DEBUG -#endif - -abase=(InternalFPF *)AllocateMemory(locemfloatstruct->arraysize*sizeof(InternalFPF), - &systemerror); -if(systemerror) -{ ReportError(errorcontext,systemerror); - ErrorExit(); -} - -bbase=(InternalFPF *)AllocateMemory(locemfloatstruct->arraysize*sizeof(InternalFPF), - &systemerror); -if(systemerror) -{ ReportError(errorcontext,systemerror); - FreeMemory((void *)abase,&systemerror); - ErrorExit(); -} - -cbase=(InternalFPF *)AllocateMemory(locemfloatstruct->arraysize*sizeof(InternalFPF), - &systemerror); -if(systemerror) -{ ReportError(errorcontext,systemerror); - FreeMemory((void *)abase,&systemerror); - FreeMemory((void *)bbase,&systemerror); - ErrorExit(); -} - -/* -** Set up the arrays -*/ -SetupCPUEmFloatArrays(abase,bbase,cbase,locemfloatstruct->arraysize); - -/* -** 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;loopsarraysize, - loops); - if(tickcount>global_min_ticks) - { locemfloatstruct->loops=loops; - break; - } - } -} - -/* -** Verify that selft adjustment code worked. -*/ -if(locemfloatstruct->loops==0) -{ printf("CPU:EMFPU -- CMPUEMFLOATLOOPMAX limit hit\n"); - FreeMemory((void *)abase,&systemerror); - FreeMemory((void *)bbase,&systemerror); - FreeMemory((void *)cbase,&systemerror); - ErrorExit(); -} - -/* -** All's well if we get here. Repeatedly perform floating -** tests until the accumulated time is greater than the -** # of seconds requested. -** Each iteration performs arraysize * 3 operations. -*/ -accumtime=0L; -iterations=(double)0.0; -do { - accumtime+=DoEmFloatIteration(abase,bbase,cbase, - locemfloatstruct->arraysize, - locemfloatstruct->loops); - iterations+=(double)1.0; -} while(TicksToSecs(accumtime)request_secs); - - -/* -** Clean up, calculate results, and go home. -** Also, indicate that adjustment is done. -*/ -FreeMemory((void *)abase,&systemerror); -FreeMemory((void *)bbase,&systemerror); -FreeMemory((void *)cbase,&systemerror); - -locemfloatstruct->emflops=(iterations*(double)locemfloatstruct->loops)/ - (double)TicksToFracSecs(accumtime); -if(locemfloatstruct->adjust==0) - locemfloatstruct->adjust=1; - -#ifdef DEBUG -printf("----------------------------------------------------------------------------\n"); -#endif -return; +void DoEmFloat(void) { + /* Error context string pointer */ + const char *errorcontext = "CPU:Floating Emulation"; + /* Local structure */ + EmFloatStruct *locemfloatstruct = &global_emfloatstruct; + + InternalFPF *abase = NULL; /* Base of A array */ + InternalFPF *bbase = NULL; /* Base of B array */ + InternalFPF *cbase = NULL; /* Base of C array */ + unsigned long accumtime; /* Accumulated time in ticks */ + double iterations; /* # of iterations */ + unsigned long tickcount; /* # of ticks */ + int systemerror; /* For holding error code */ + unsigned long loops; /* # of loops */ + + abase = malloc(locemfloatstruct->arraysize * sizeof(InternalFPF)); + if (!abase) { + printf("ERROR CONDITION\nContext: %s\n", errorcontext); + exit(1); + } + + + bbase = malloc(locemfloatstruct->arraysize * sizeof(InternalFPF)); + if (!bbase) { + printf("ERROR CONDITION\nContext: %s\n", errorcontext); + free(abase); + exit(1); + } + + cbase = malloc(locemfloatstruct->arraysize * sizeof(InternalFPF)); + if (!cbase) { + printf("ERROR CONDITION\nContext: %s\n", errorcontext); + free(abase); + free(bbase); + exit(1); + } + + SetupCPUEmFloatArrays(abase, bbase, cbase, locemfloatstruct->arraysize); /* FIXME: ugly */ + + /* + ** 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 ) { + tickcount = DoEmFloatIteration(abase, bbase, cbase, /* FIXME: ugly */ + locemfloatstruct->arraysize, loops); + if ( tickcount > global_min_ticks ) { + locemfloatstruct->loops = loops; + break; + } + } + } + + /* + ** Verify that selft adjustment code worked. + */ + if ( locemfloatstruct->loops == 0 ) { + puts("CPU:EMFPU -- CMPUEMFLOATLOOPMAX limit hit"); + free(abase); + free(bbase); + free(cbase); + exit(1); + } + + /* + ** All's well if we get here. Repeatedly perform floating + ** tests until the accumulated time is greater than the + ** # of seconds requested. + ** Each iteration performs arraysize * 3 operations. + */ + accumtime = 0L; + iterations = 0.0; + do { + accumtime += DoEmFloatIteration(abase, bbase, cbase, /* FIXME: ugly */ + locemfloatstruct->arraysize, locemfloatstruct->loops); + iterations += 1.0; + } while ( TicksToSecs(accumtime) < locemfloatstruct->request_secs ); + + /* + ** Clean up, calculate results, and go home. + ** Also, indicate that adjustment is done. + */ + free(abase); + free(bbase); + free(cbase); + + locemfloatstruct->emflops = (iterations * (double)locemfloatstruct->loops) + / (double)TicksToFracSecs(accumtime); + if ( locemfloatstruct->adjust == 0 ) { + locemfloatstruct->adjust = 1; + } } diff --git a/numsort.c b/numsort.c index 936b390..5756a31 100644 --- a/numsort.c +++ b/numsort.c @@ -25,24 +25,16 @@ ** Not so; the routine returns # of iterations per sec. */ -void DoNumSort(void) -{ -SortStruct *numsortstruct; /* Local pointer to global struct */ -long *arraybase; /* Base pointers of array */ -long accumtime; /* Accumulated time */ -double iterations; /* Iteration counter */ -char *errorcontext; /* Error context string pointer */ -int systemerror; /* For holding error codes */ +void DoNumSort(void) { + /* Error context string pointer */ + const char *errorcontext = "CPU:Numeric Sort"; + /* Local pointer to global struct */ + SortStruct * numsortstruct = &global_numsortstruct; -/* -** Link to global structure -*/ -numsortstruct=&global_numsortstruct; - -/* -** Set the error context string. -*/ -errorcontext="CPU:Numeric Sort"; + 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. @@ -105,8 +97,8 @@ else ** All's well if we get here. Repeatedly perform sorts until the ** accumulated elapsed time is greater than # of seconds requested. */ -accumtime=0L; -iterations=(double)0.0; +accumtime = 0L; +iterations = 0.0; do { accumtime+=DoNumSortIteration(arraybase, @@ -127,11 +119,6 @@ numsortstruct->sortspersec=iterations * if(numsortstruct->adjust==0) numsortstruct->adjust=1; -#ifdef DEBUG -if (numsort_status==0) printf("Numeric sort: OK\n"); -numsort_status=0; -#endif -return; } /*********************** @@ -167,21 +154,6 @@ for(i=0;i