#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <limits.h>

#include "nmglobal.h"
#include "nbench1.h"


/************************
** BITFIELD OPERATIONS **
*************************/

/*************
** DoBitops **
**************
** Perform the bit operations test portion of the CPU
** benchmark.  Returns the iterations per second.
*/
void
DoBitops(void)
{
        /* Error context string */
        const char *context = "CPU:Bitfields";
        /* Local bitop structure */
        BitOpStruct *locbitopstruct = &global_bitopstruct;

        unsigned long *bitarraybase = NULL;     /* Base of bitmap array */
        unsigned long *bitoparraybase = NULL;   /* Base of bitmap operations array */
        unsigned long nbitops;                  /* # of bitfield operations */
        unsigned long accumtime;                /* Accumulated time in ticks */
        double iterations;                      /* # of iterations */
        int ticks;

        /*
        ** See if we need to run adjustment code.
        */
        if (locbitopstruct->adjust == 0) {
                bitarraybase = realloc(bitarraybase, locbitopstruct->bitfieldarraysize * sizeof(unsigned long));
                if (!bitarraybase) {
                      fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
                      exit(1);
                }

	        /*
        	** Initialize bitfield operations array to [2,30] elements
                */
                locbitopstruct->bitoparraysize = 30L;

                while(1) {
                        bitoparraybase = malloc(locbitopstruct->bitoparraysize * 2 * sizeof(unsigned long));
                        if (!bitoparraybase) {
                                fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
                                free(bitarraybase);
                                exit(1);
                        }

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

                        locbitopstruct->bitoparraysize += 100L;
                }
        } else {
                /*
                ** Don't need to do self adjustment, just allocate
                ** the array space.
                */
                bitarraybase = malloc(locbitopstruct->bitfieldarraysize * sizeof(unsigned long));
                if (!bitarraybase) {
                        fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
                        exit(1);
                }

                bitoparraybase = malloc(locbitopstruct->bitoparraysize * 2 * sizeof(unsigned long));
                if (!bitoparraybase) {
                        fprintf(stderr, "Error in %s, could not allocate memory. Exitting...\n", context);
                        free(bitarraybase);
                        exit(1);
                }
        }

        /*
        ** All's well if we get here.  Repeatedly perform bitops until the
        ** accumulated elapsed time is greater than # of seconds requested.
        */
        accumtime = 0L;
        iterations = 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.
        */
        free(bitarraybase);
        free(bitoparraybase);

        locbitopstruct->bitopspersec = iterations / TicksToFracSecs(accumtime);

        if (locbitopstruct->adjust == 0) {
                locbitopstruct->adjust = 1;
        }
}

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