From 1fa9357768c1b4b2301b7341656dbc81e531c9f6 Mon Sep 17 00:00:00 2001
From: Matt Turner <mattst88@gmail.com>
Date: Tue, 11 Nov 2008 22:34:57 +0000
Subject: -- 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
---
 bitfield.c | 335 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 335 insertions(+)
 create mode 100644 bitfield.c

(limited to 'bitfield.c')

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;
+}
-- 
cgit v1.2.3