#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);

		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;
}