-- Cleanup fpemulation.c

-- Begin cleaning numsort.c


git-svn-id: svn://mattst88.com/svn/cleanbench/trunk@9 0d43b9a7-5ab2-4d7b-af9d-f64450cef757

1 files changed, 99 insertions, 127 deletions

diff --git a/fpemulation.c b/fpemulation.c
index d4332a3..7d631bf 100644
--- a/fpemulation.c
+++ b/fpemulation.c
@@ -1,6 +1,6 @@
 #include <stdio.h>
-/*
 #include <stdlib.h>
+/*
 #include <string.h>
 #include <strings.h>
 #include <math.h>*/
@@ -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;loops<CPUEMFLOATLOOPMAX;loops+=loops)
-	{       tickcount=DoEmFloatIteration(abase,bbase,cbase,
-			locemfloatstruct->arraysize,
-			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)<locemfloatstruct->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;
+        }
 }