/* ** nbench1.h ** Header for nbench1.c ** BYTEmark (tm) ** BYTE's Native Mode Benchmarks ** Rick Grehan, BYTE Magazine ** ** Creation: ** Revision: 3/95;10/95 ** ** 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. */ /* ** DEFINES */ /* #define DEBUG */ /* ** EXTERNALS */ extern ulong global_min_ticks; extern SortStruct global_numsortstruct; extern SortStruct global_strsortstruct; extern BitOpStruct global_bitopstruct; extern EmFloatStruct global_emfloatstruct; extern FourierStruct global_fourierstruct; extern AssignStruct global_assignstruct; extern IDEAStruct global_ideastruct; extern HuffStruct global_huffstruct; extern NNetStruct global_nnetstruct; extern LUStruct global_lustruct; /* External PROTOTYPES */ /*extern unsigned long abs_randwc(unsigned long num);*/ /* From MISC */ /*extern long randnum(long lngval);*/ extern int32 randwc(int32 num); extern u32 abs_randwc(u32 num); extern int32 randnum(int32 lngval); extern farvoid *AllocateMemory(unsigned long nbytes, /* From SYSSPEC */ int *errorcode); extern void FreeMemory(farvoid *mempointer, int *errorcode); extern void MoveMemory(farvoid *destination, farvoid *source, unsigned long nbytes); extern void ReportError(char *context, int errorcode); extern void ErrorExit(); extern unsigned long StartStopwatch(); extern unsigned long StopStopwatch(unsigned long startticks); extern unsigned long TicksToSecs(unsigned long tickamount); extern double TicksToFracSecs(unsigned long tickamount); /***************** ** NUMERIC SORT ** *****************/ /* ** PROTOTYPES */ void DoNumSort(void); static ulong DoNumSortIteration(farlong *arraybase, ulong arraysize, uint numarrays); static void LoadNumArrayWithRand(farlong *array, ulong arraysize, uint numarrays); static void NumHeapSort(farlong *array, ulong bottom, ulong top); static void NumSift(farlong *array, ulong i, ulong j); /**************** ** STRING SORT ** ***************** */ /* ** PROTOTYPES */ void DoStringSort(void); static ulong DoStringSortIteration(faruchar *arraybase, uint numarrays, ulong arraysize); static farulong *LoadStringArray(faruchar *strarray, uint numarrays, ulong *strings, ulong arraysize); static void stradjust(farulong *optrarray, faruchar *strarray, ulong nstrings, ulong i, uchar l); static void StrHeapSort(farulong *optrarray, faruchar *strarray, ulong numstrings, ulong bottom, ulong top); static int str_is_less(farulong *optrarray, faruchar *strarray, ulong numstrings, ulong a, ulong b); static void strsift(farulong *optrarray, faruchar *strarray, ulong numstrings, ulong i, ulong j); /************************ ** BITFIELD OPERATIONS ** ************************* */ /* ** PROTOTYPES */ void DoBitops(void); static ulong DoBitfieldIteration(farulong *bitarraybase, farulong *bitoparraybase, long bitoparraysize, ulong *nbitops); static void ToggleBitRun(farulong *bitmap, ulong bit_addr, ulong nbits, uint val); static void FlipBitRun(farulong *bitmap, ulong bit_addr, ulong nbits); /**************************** ** EMULATED FLOATING POINT ** ****************************/ typedef struct { u8 type; /* Indicates, NORMAL, SUBNORMAL, etc. */ u8 sign; /* Mantissa sign */ short exp; /* Signed exponent...no bias */ u16 mantissa[INTERNAL_FPF_PRECISION]; } InternalFPF; /* ** PROTOTYPES */ void DoEmFloat(void); /* ** EXTERNALS */ extern void SetupCPUEmFloatArrays(InternalFPF *abase, InternalFPF *bbase, InternalFPF *cbase, ulong arraysize); extern ulong DoEmFloatIteration(InternalFPF *abase, InternalFPF *bbase, InternalFPF *cbase, ulong arraysize, ulong loops); /************************* ** FOURIER COEFFICIENTS ** *************************/ /* ** PROTOTYPES */ void DoFourier(void); static ulong DoFPUTransIteration(fardouble *abase, fardouble *bbase, ulong arraysize); static double TrapezoidIntegrate(double x0, double x1, int nsteps, double omegan, int select); static double thefunction(double x, double omegan, int select); /************************* ** ASSIGNMENT ALGORITHM ** *************************/ /* ** DEFINES */ #define ASSIGNROWS 101L #define ASSIGNCOLS 101L /* ** TYPEDEFS */ typedef struct { union { long *p; long (*ap)[ASSIGNROWS][ASSIGNCOLS]; } ptrs; } longptr; /* ** PROTOTYPES */ void DoAssign(void); static ulong DoAssignIteration(farlong *arraybase, ulong numarrays); static void LoadAssignArrayWithRand(farlong *arraybase, ulong numarrays); static void LoadAssign(farlong arraybase[][ASSIGNCOLS]); static void CopyToAssign(farlong arrayfrom[][ASSIGNCOLS], long arrayto[][ASSIGNCOLS]); static void Assignment(farlong arraybase[][ASSIGNCOLS]); static void calc_minimum_costs(long tableau[][ASSIGNCOLS]); static int first_assignments(long tableau[][ASSIGNCOLS], short assignedtableau[][ASSIGNCOLS]); static void second_assignments(long tableau[][ASSIGNCOLS], short assignedtableau[][ASSIGNCOLS]); /******************** ** IDEA ENCRYPTION ** ********************/ /* ** DEFINES */ #define IDEAKEYSIZE 16 #define IDEABLOCKSIZE 8 #define ROUNDS 8 #define KEYLEN (6*ROUNDS+4) /* ** MACROS */ #define low16(x) ((x) & 0x0FFFF) #define MUL(x,y) (x=mul(low16(x),y)) typedef u16 IDEAkey[KEYLEN]; /* ** PROTOTYPES */ void DoIDEA(void); static ulong DoIDEAIteration(faruchar *plain1, faruchar *crypt1, faruchar *plain2, ulong arraysize, ulong nloops, IDEAkey Z, IDEAkey DK); static u16 mul(register u16 a, register u16 b); static u16 inv(u16 x); static void en_key_idea(u16 userkey[8], IDEAkey Z); static void de_key_idea(IDEAkey Z, IDEAkey DK); static void cipher_idea(u16 in[4], u16 out[4], IDEAkey Z); /************************ ** HUFFMAN COMPRESSION ** ************************/ /* ** DEFINES */ #define EXCLUDED 32000L /* Big positive value */ /* ** TYPEDEFS */ typedef struct { uchar c; /* Byte value */ float freq; /* Frequency */ int parent; /* Parent node */ int left; /* Left pointer = 0 */ int right; /* Right pointer = 1 */ } huff_node; /* ** GLOBALS */ static huff_node *hufftree; /* The huffman tree */ static long plaintextlen; /* Length of plaintext */ /* ** PROTOTYPES */ void DoHuffman(); static void create_text_line(farchar *dt,long nchars); static void create_text_block(farchar *tb, ulong tblen, ushort maxlinlen); static ulong DoHuffIteration(farchar *plaintext, farchar *comparray, farchar *decomparray, ulong arraysize, ulong nloops, huff_node *hufftree); static void SetCompBit(u8 *comparray, u32 bitoffset, char bitchar); static int GetCompBit(u8 *comparray, u32 bitoffset); /******************************** ** BACK PROPAGATION NEURAL NET ** ********************************/ /* ** DEFINES */ #define T 1 /* TRUE */ #define F 0 /* FALSE */ #define ERR -1 #define MAXPATS 10 /* max number of patterns in data file */ #define IN_X_SIZE 5 /* number of neurodes/row of input layer */ #define IN_Y_SIZE 7 /* number of neurodes/col of input layer */ #define IN_SIZE 35 /* equals IN_X_SIZE*IN_Y_SIZE */ #define MID_SIZE 8 /* number of neurodes in middle layer */ #define OUT_SIZE 8 /* number of neurodes in output layer */ #define MARGIN 0.1 /* how near to 1,0 do we have to come to stop? */ #define BETA 0.09 /* beta learning constant */ #define ALPHA 0.09 /* momentum term constant */ #define STOP 0.1 /* when worst_error less than STOP, training is done */ /* ** GLOBALS */ double mid_wts[MID_SIZE][IN_SIZE]; /* middle layer weights */ double out_wts[OUT_SIZE][MID_SIZE]; /* output layer weights */ double mid_out[MID_SIZE]; /* middle layer output */ double out_out[OUT_SIZE]; /* output layer output */ double mid_error[MID_SIZE]; /* middle layer errors */ double out_error[OUT_SIZE]; /* output layer errors */ double mid_wt_change[MID_SIZE][IN_SIZE]; /* storage for last wt change */ double out_wt_change[OUT_SIZE][MID_SIZE]; /* storage for last wt change */ double in_pats[MAXPATS][IN_SIZE]; /* input patterns */ double out_pats[MAXPATS][OUT_SIZE]; /* desired output patterns */ double tot_out_error[MAXPATS]; /* measure of whether net is done */ double out_wt_cum_change[OUT_SIZE][MID_SIZE]; /* accumulated wt changes */ double mid_wt_cum_change[MID_SIZE][IN_SIZE]; /* accumulated wt changes */ double worst_error; /* worst error each pass through the data */ double average_error; /* average error each pass through the data */ double avg_out_error[MAXPATS]; /* average error each pattern */ int iteration_count; /* number of passes thru network so far */ int numpats; /* number of patterns in data file */ int numpasses; /* number of training passes through data file */ int learned; /* flag--if TRUE, network has learned all patterns */ /* ** The Neural Net test requires an input data file. ** The name is specified here. */ char *inpath="NNET.DAT"; /* ** PROTOTYPES */ void DoNNET(void); static ulong DoNNetIteration(ulong nloops); static void do_mid_forward(int patt); static void do_out_forward(); void display_output(int patt); static void do_forward_pass(int patt); static void do_out_error(int patt); static void worst_pass_error(); static void do_mid_error(); static void adjust_out_wts(); static void adjust_mid_wts(); static void do_back_pass(int patt); static void move_wt_changes(); static int check_out_error(); static void zero_changes(); static void randomize_wts(); static int read_data_file(); /* static int initialize_net(); */ /*********************** ** LU DECOMPOSITION ** ** (Linear Equations) ** ***********************/ /* ** DEFINES */ #define LUARRAYROWS 101L #define LUARRAYCOLS 101L /* ** TYPEDEFS */ typedef struct { union { fardouble *p; fardouble (*ap)[][LUARRAYCOLS]; } ptrs; } LUdblptr; /* ** GLOBALS */ fardouble *LUtempvv; /* ** PROTOTYPES */ void DoLU(void); static void LUFreeMem(fardouble *a, fardouble *b, fardouble *abase, fardouble *bbase); static ulong DoLUIteration(fardouble *a, fardouble *b, fardouble *abase, fardouble *bbase, ulong numarrays); static void build_problem( double a[][LUARRAYCOLS], int n, double b[LUARRAYROWS]); static int ludcmp(double a[][LUARRAYCOLS], int n, int indx[], int *d); static void lubksb(double a[][LUARRAYCOLS], int n, int indx[LUARRAYROWS], double b[LUARRAYROWS]); static int lusolve(double a[][LUARRAYCOLS], int n, double b[LUARRAYROWS]);