/*
** nmglobal.h
** Global definitions for native mode benchmarks.
**
** BYTEmark (tm)
** BYTE's Native Mode Benchmarks
** Rick Grehan, BYTE Magazine
**
** Creation:
** Revision: 3/95;10/95
**  10/95 - Added memory array & alignment -- RG
**
** DISCLAIMER
** The source, executable, and documentation files that comprise
** the BYTEmark benchmarks are made available on an "as is" basis.
** This means that we at BYTE Magazine have made every reasonable
** effort to verify that the there are no errors in the source and
** executable code.  We cannot, however, guarantee that the programs
** are error-free.  Consequently, McGraw-HIll and BYTE Magazine make
** no claims in regard to the fitness of the source code, executable
** code, and documentation of the BYTEmark.
**  Furthermore, BYTE Magazine, McGraw-Hill, and all employees
** of McGraw-Hill cannot be held responsible for any damages resulting
** from the use of this code or the results obtained from using
** this code.
*/

/* is this a 64 bit architecture? If so, this will define LONG64 */
/* #include "pointer.h" */

/*
** SYSTEM DEFINES
*/

/* +++ MEMORY +++ */

/*
** You must define ONLY ONE of the following identifiers
** to specify the mechanism for allocating memory:
** MALLOCMEM
** DOS16MEM
** MACMEM
*/

/*
** Define MALLOCMEM to use the standard malloc() call for
** memory.  This is the default for most systems.
*/
#define MALLOCMEM

/*
** Define DOS16MEM if you're running in the old 16-bit segmented
** model.  This enables some fruity memory management routines
** required for that model.  NOT defining this assumes that
** you're running in an environment that allows malloc() to
** get > 64K chunks of memory.
*/
/* #define DOS16MEM */

/* Define MACMEM to use the Mac's GetPtr call to allocate
** memory (instead of malloc()).
*/
/* #define MACMEM */

/* +++ TIMING +++ */
/*
** You must define ONLY ONE of the following identifiers to pick
** the timing routine used.
**  CLOCKWCPS
**  CLOCKWCT
**  MACTIMEMGR
**  WIN31TIMER
*/

/*
** Define CLOCKWCPS if you are using the clock() routine and the
** constant used as the divisor to determine seconds is
** CLOCKS_PER_SEC.  This is the default in most cases.
*/
#define CLOCKWCPS

/*
** Define CLOCKWCT if you are using the clock() routine and the
** constant used as the divisor to determine seconds is CLK_TCK
*/
/* #define CLOCKWCT */

/*
** Define MACTIMEMGR to use the Mac Time manager routines.
** You'll need to be running at least system 6.0.3 or
** better...extended time manager is recommended (system 7 or
** better).
*/
/* #define MACTIMEMGR */

/*
** Define WIN31TIMER to user the timing routines in TOOLHELP.DLL.
** Gets accuracy down to the millisecond.
*/
/* #define WIN31TIMER */

/* +++ MISCELLANEOUS +++ */

/*
** Define DOS16 if you'll be compiling under DOS in 16-bit
** (non DOS-extended) mode.  This will enable proper definitions
** for the far*** typedefs
*/
/* #define DOS16 */

/*
** Define MAC if you're compiling on a Macintosh.  This
** does a number of things:
**  includes unix.h
**  Incorporates code to mimic the command line via either
**      the console library (Symantec/Think) or the SIOUX
**      library (Code Warrior).
*/
/* #define MAC */

/*
** Define LONG64 if your compiler emits 64-bit longs.
** This is typically true of Alpha compilers on Unix
** systems...though, who knows, this may change in the
** future. I MOVED THIS DEFINTION INTO THE FILE pointer.h. DO NOT
** DEFINE IT HERE. IT WILL AUTOMATICALLY BE DEFINED IF NECESSARY.
** Uwe F. Mayer, Dec 15, 1996, Nov 15, 1997
*/
/* #define LONG64 */

/*
** Define MACCWPROF if you are profiling on the Mac using
** Code Warrior.  This enables code that turns off the
** profiler in an evern of an error exit.
*/
/* #define MACCWPROF */

#ifdef MAC
#include <unix.h>
#endif

/*
** ERROR CODES
*/
#define ERROR_MEMORY    1
#define ERROR_MEMARRAY_FULL 2
#define ERROR_MEMARRAY_NFOUND 3
#define ERROR_FILECREATE 10
#define ERROR_FILEREAD 11
#define ERROR_FILEWRITE 12
#define ERROR_FILEOPEN 13
#define ERROR_FILESEEK 14

/*
** MINIMUM_TICKS
**
** This sets the default number of minimum ticks.
** It can, of course, be overridden by the input
** command file.
** This ultimately gets loaded into the variable
** global_min_ticks, which specifies the minimum
** number of ticks that must take place between
** a StartStopwatch() and StopStopwatch() call.
** The idea is to reduce error buildup.
*/
#define MINIMUM_TICKS 60

/*
** MINIMUM_SECONDS
**
** Minimum number of seconds to run each test.
*/
#define MINIMUM_SECONDS 5

/*
** MAXPOSLONG
**
** This is the maximum positive long.
*/
#include <limits.h>
#define MAXPOSLONG LONG_MAX

/*
** OTHER DEFINES
*/
#ifndef MAC
#define TRUE    1
#define FALSE   0
#endif

/*
** Memory array size.  Used in SYSSPEC for keeping track
** of re-aligned memory.
*/
#define MEM_ARRAY_SIZE 20

/*
** TYPEDEFS
*/
#define ulong unsigned long
#define uchar unsigned char
#define uint unsigned int
#define ushort unsigned short
/*
typedef unsigned char uchar;
typedef unsigned int uint;
typedef unsigned short ushort;
typedef unsigned long ulong;
*/
/*
** The 'farxxx' typedefs were added in deference to DOS, which
** requires far pointers to handle some of the bigger
** memory structures.  Other systems will simply
** map 'farxxx' to 'xxx'
*/
#ifdef DOS16
typedef void huge farvoid;
typedef double huge fardouble;
typedef long huge farlong;
typedef unsigned long huge farulong;
typedef char huge farchar;
typedef unsigned char huge faruchar;

#else

typedef void farvoid;
typedef double fardouble;
typedef long farlong;
typedef unsigned long farulong;
typedef char farchar;
typedef unsigned char faruchar;

#endif

/*
** The following typedefs are used when element size
** is critical.  You'll have to alter these for
** your specifical platform/compiler.
*/
typedef unsigned char u8;       /* Unsigned 8-bits */
typedef unsigned short u16;     /* Unsigned 16 bits */
typedef unsigned int u32;       /* Unsigned 32 bits */
typedef int int32;              /* Signed 32 bit integer */

/*****************
** NUMERIC SORT **
*****************/
/*
** DEFINES
*/

/*
** The following constant, NUMNUMARRAYS (no, it is not a
** Peter Sellers joke) is the maximum number of arrays
** that can be built by the numeric sorting benchmark
** before it gives up.  This maximum is dependent on the
** amount of memory in the system.
*/
/*#define NUMNUMARRAYS    1000*/
#define NUMNUMARRAYS    10000

/*
** The following constant NUMARRAYSIZE determines the
** default # of elements in each numeric array.  Ordinarily
** this is something you shouldn't fool with, though as
** with most of the constants here, it is adjustable.
*/
#define NUMARRAYSIZE    8111L


/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* # of seconds requested */
        double sortspersec;     /* # of sort iterations per sec */
        ushort numarrays;       /* # of arrays */
        ulong arraysize;        /* # of elements in array */
} SortStruct;

/****************
** STRING SORT **
*****************
** Note: The string sort benchmark uses the same structure to
** communicate parameters as does the numeric sort benchmark.
** (i.e., SortStruct...see above.
*/

/*
** DEFINES
*/
/*
** The following constant STRINGARRAYSIZE determines
** the default # of bytes allocated to each string array.
** Though the actual size can be pre-set from the command
** file, this constant should be left unchanged.
*/
#define STRINGARRAYSIZE 8111L

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

/*
** DEFINES
*/

/*
** Following field sets the size of the bitfield array (in longs).
*/
#define BITFARRAYSIZE (4096L * sizeof(long))

/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* # of seconds requested */
        double bitopspersec;    /* # of bitfield ops per sec */
        ulong bitoparraysize;           /* Total # of bitfield ops */
        ulong bitfieldarraysize;        /* Bit field array size */
} BitOpStruct;

/****************************
** EMULATED FLOATING POINT **
****************************/
/*
** DEFINES
*/
#define INTERNAL_FPF_PRECISION 4

/*
** The following constant is the maximum number of loops
** of the emulated floating point test that the system
** will allow before flagging an error.  This is not a
** critical constant, and can be altered if your system is
** a real barn-burner.
*/
/*#define CPUEMFLOATLOOPMAX 50000L*/
#define CPUEMFLOATLOOPMAX 500000L

/*
** Set size of array
*/
#define EMFARRAYSIZE 3000L

/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* # of seconds requested */
        ulong arraysize;        /* Size of array */
        ulong loops;            /* Loops per iterations */
        double emflops;         /* Results */
} EmFloatStruct;

/*************************
** FOURIER COEFFICIENTS **
*************************/

/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* # of requested seconds */
        ulong arraysize;        /* Size of coeff. arrays */
        double fflops;          /* Results */
} FourierStruct;

/*************************
** ASSIGNMENT ALGORITHM **
*************************/

/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* Requested # of seconds */
        ulong numarrays;        /* # of arrays */
        double iterspersec;     /* Results */
} AssignStruct;

/********************
** IDEA ENCRYPTION **
********************/

/*
** DEFINES
*/
/* Following constant defines the max number of loops the
** system will attempt. Keeps things from going off into the
** weeds. */
/*#define MAXIDEALOOPS 50000L*/
#define MAXIDEALOOPS 500000L

/*
** Following constant sets the size of the arrays.
** NOTE: For the IDEA algorithm to work properly, this
**  number MUST be some multiple of 8.
*/
#define IDEAARRAYSIZE 4000L

/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* Requested # of seconds */
        ulong arraysize;        /* Size of array */
        ulong loops;            /* # of times to convert */
        double iterspersec;     /* Results */
} IDEAStruct;


/************************
** HUFFMAN COMPRESSION **
************************/

/*
** DEFINES
*/
/*
** MAXHUFFLOOPS
**
** This constant specifies the maximum number of Huffman
** compression loops the system will try for.  This keeps
** the test from going off into the weeds.  This is not
** a critical constant, and can be increased if your
** system is a real barn-burner.
*/
/*#define MAXHUFFLOOPS 50000L*/
#define MAXHUFFLOOPS 500000L

/*
** Following constant sets the size of the arrays to
** be compressed/uncompressed.
*/
#define HUFFARRAYSIZE 5000L

/*
** TYPEDEFS
*/

typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* Requested # of seconds */
        ulong arraysize;        /* Size of array */
        ulong loops;            /* # of times to compress/decompress */
        double iterspersec;     /* Results */
} HuffStruct;

/********************************
** BACK PROPAGATION NEURAL NET **
********************************/

/*
**  MAXNNETLOOPS
**
** This constant sets the max number of loops through the neural
** net that the system will attempt before giving up.  This
** is not a critical constant.  You can alter it if your system
** has sufficient horsepower.
*/
/*#define MAXNNETLOOPS  50000L*/
#define MAXNNETLOOPS  500000L

/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* Requested # of seconds */
        ulong loops;            /* # of times to learn */
        double iterspersec;     /* Results */
} NNetStruct;

/***********************
**  LU DECOMPOSITION  **
** (Linear Equations) **
***********************/

/*
** MAXLUARRAYS
**
** This sets the upper limit on the number of arrays
** that the benchmark will attempt to build before
** flagging an error.  It is not a critical constant, and
** may be increased if your system has the horsepower.
*/
/*#define MAXLUARRAYS 1000*/
#define MAXLUARRAYS 10000

/*
** TYPEDEFS
*/
typedef struct {
        int adjust;             /* Set adjust code */
        ulong request_secs;     /* Requested # of seconds */
        ulong numarrays;        /* # of arrays */
        double iterspersec;     /* Results */
} LUStruct;