diff options
author | Matt Turner <mattst88@gmail.com> | 2008-11-11 22:34:57 +0000 |
---|---|---|
committer | Matt Turner <mattst88@gmail.com> | 2008-11-11 22:34:57 +0000 |
commit | 1fa9357768c1b4b2301b7341656dbc81e531c9f6 (patch) | |
tree | 09866b6fc5eb52f13a44228fbbd7be543131942f /bitfield.c | |
parent | 9e43555ab77b3a486948f2de4a878cc0d6d0c275 (diff) |
-- Split nbench1.c into component files
-- Combine wordcat.h with huffman routines in huffman.c
-- Readd NNET.DAT (oops)
-- Update Makefile to build component files
git-svn-id: svn://mattst88.com/svn/cleanbench/trunk@3 0d43b9a7-5ab2-4d7b-af9d-f64450cef757
Diffstat (limited to 'bitfield.c')
-rw-r--r-- | bitfield.c | 335 |
1 files changed, 335 insertions, 0 deletions
diff --git a/bitfield.c b/bitfield.c new file mode 100644 index 0000000..78aba9e --- /dev/null +++ b/bitfield.c @@ -0,0 +1,335 @@ +#include <stdint.h> +/* +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <strings.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 ** +*************************/ + +/************* +** DoBitops ** +************** +** 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); +#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 */ + + FreeMemory((void *)bitoparraybase,&systemerror); + locbitopstruct->bitoparraysize+=100L; + } +} +else +{ + /* + ** 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; +} + +/************************ +** DoBitfieldIteration ** +************************* +** Perform a single iteration of the bitfield benchmark. +** Return the # of ticks accumulated by the operation. +*/ +static unsigned long DoBitfieldIteration(unsigned long *bitarraybase, + unsigned long *bitoparraybase, + long bitoparraysize, + unsigned long *nbitops) +{ +long i; /* Index */ +unsigned long bitoffset; /* Offset into bitmap */ +unsigned long elapsed; /* Time to execute */ +/* +** Clear # bitops counter +*/ +*nbitops=0L; + +/* +** Construct a set of bitmap offsets and run lengths. +** The offset can be any random number from 0 to the +** size of the bitmap (in bits). The run length can +** be any random number from 1 to the number of bits +** between the offset and the end of the bitmap. +** Note that the bitmap has 8192 * 32 bits in it. +** (262,144 bits) +*/ +/* +** Reset random number generator so things repeat. +** Also reset the bit array we work on. +** added by Uwe F. Mayer +*/ +randnum((int32_t)13); + +for (i=0;i<global_bitopstruct.bitfieldarraysize;i++) +{ +#ifdef _LP64 + *(bitarraybase+i)=(unsigned long)0x5555555555555555; +#else + *(bitarraybase+i)=(unsigned long)0x55555555; +#endif +} + +randnum((int32_t)13); +/* end of addition of code */ + +for (i=0;i<bitoparraysize;i++) +{ + /* First item is offset */ + /* *(bitoparraybase+i+i)=bitoffset=abs_randwc(262140L); */ + *(bitoparraybase+i+i)=bitoffset=abs_randwc((int32_t)262140); + + /* Next item is run length */ + /* *nbitops+=*(bitoparraybase+i+i+1L)=abs_randwc(262140L-bitoffset);*/ + *nbitops+=*(bitoparraybase+i+i+1L)=abs_randwc((int32_t)262140-bitoffset); +} + +/* +** Array of offset and lengths built...do an iteration of +** the test. +** Start the stopwatch. +*/ +elapsed=StartStopwatch(); + +/* +** Loop through array off offset/run length pairs. +** Execute operation based on modulus of index. +*/ +for(i = 0; i < bitoparraysize; i++) { + int asdf = i % 3; + switch(asdf) { + case 2: /* Complement run of bits */ + FlipBitRun(bitarraybase, + *(bitoparraybase+i+i), + *(bitoparraybase+i+i+1)); + break; + default: + ToggleBitRun(bitarraybase, + *(bitoparraybase+i+i), + *(bitoparraybase+i+i+1), + !i); + break; + } +} + +/* +** Return elapsed time +*/ +return(StopStopwatch(elapsed)); +} + +/*************** +** FlipBitRun ** +**************** +** Complements a run of bits. +*/ +static void FlipBitRun(unsigned long *bitmap, /* Bit map */ + unsigned long bit_addr, /* Bit address */ + unsigned long nbits) /* # of bits to flip */ +{ +unsigned long bindex; /* Index into array */ +unsigned long bitnumb; /* Bit number */ + +while(nbits--) +{ +#ifdef _LP64 + bindex=bit_addr>>6; /* Index is number /64 */ + bitnumb=bit_addr % 64; /* Bit number in longword */ +#else + bindex=bit_addr>>5; /* Index is number /32 */ + bitnumb=bit_addr % 32; /* Bit number in longword */ +#endif + bitmap[bindex]^=(1L<<bitnumb); + bit_addr++; +} + +return; +} + +/***************************** +** ToggleBitRun * +****************************** +** Set or clear a run of nbits starting at +** bit_addr in bitmap. +*/ +void ToggleBitRun(unsigned long *bitmap, /* Bitmap */ + unsigned long bit_addr, /* Address of bits to set */ + unsigned long nbits, /* # of bits to set/clr */ + unsigned int val) /* 1 or 0 */ +{ + unsigned long bindex; /* Index into array */ + unsigned long bitnumb; /* Bit number */ + +#if 0 + while (nbits != 0) { + nbits--; + + bindex = bit_addr >> 6; /* Index is number /64 */ + bitnumb = bit_addr % 64; /* Bit number in word */ + + if (val) { + bitmap[bindex] |= (1L << bitnumb); + } else { + bitmap[bindex] &= ~(1L << bitnumb); + } + bit_addr++; + } +#else + if (val) { + for (; nbits != 0; nbits--) { + bindex = bit_addr >> 6; + bitnumb = bit_addr % 64; + + bitmap[bindex] |= (1L << bitnumb); + + bit_addr++; + } + } else { + for (; nbits != 0; nbits--) { + bindex = bit_addr >> 6; + bitnumb = bit_addr % 64; + + bitmap[bindex] &= ~(1L << bitnumb); + + bit_addr++; + } + } +#endif + return; +} |