Category : Files from Magazines
Archive   : DDJ8609.ZIP
Filename : ELKINS.SEP

These listing are available for downlaoding from co-author Mike
Elkins Fido BBS at (619)722-8724 which operates at 300 and 1200
baud, 8-bits, no partity, 1 stop-bit.

---- LISTING 1 ---------------------------------------------------------------------------

/*
Erathosthenes Sieve Prime Number Program in C
*/
#define TRUE 1
#define FALSE 0
#define SIZE 8190
#define SIZEP1 8191
char flags[SIZEP1];
main()
{
int i, prime, j, count, loops;

loops = 1;
while(loops <= 10) /* Changed to 100 for second benchmark */
{
count = 0;
i = 0;
while(i <= SIZE)
{
flags[i] = TRUE;
i++;
}
i = 0;
while(i <= SIZE)
{
if(flags[i])
{
prime = i + i + 3;
j = i + prime;
while(j <= SIZE)
{
flags[j] = FALSE;
j = j + prime;
}
count++;
}
i++;
}
loops++;
}
printf("%d primes, %d loops\n", count, loops);
return;
}


----- LISTING 2 --------------------------------------------------------------------------
/*
* "DHRYSTONE" Benchmark Program
*
* Compile: cl dry.c (Microsoft 3.0)
* Defines: Defines are provided for old C compiler's
* which don't have enums, and can't assign structures.
* The time(2) function is library dependant; One is
* provided for CI-C86. Your compiler may be different.
* This is not required for Microsoft 3.0 which supports
* all of the standard calls and will compile asis.
*
* MACHINE OPERATING COMPILER DHRYSTONES
* TYPE SYSTEM /SEC
* --------------- ------------ --------------- -----------
* IBM PC PCDOS 3.1 Microsoft C 3.0 333
* IBM PC/AT PCDOS 3.1 Microsoft C 3.0 1041
* $ IBM PC/AT PCDOS 3.0 CI-C86 2.1 684
* $ ATT 3B2/300 UNIX 5.2 cc 806
* $ IBM PC/AT VENIX/86 2.1 cc 1000
* $ Sun2/120 Sun 4.2BSD cc 1219
*
* The entries with $ supplied by Rick Richardson, who origanally converted
* the program from ADA.
* The rest are provided by Mike's "C" Board 619-722-8724 .
**************************************************************************
*
* The following program contains statements of a high-level programming
* language (C) in a distribution considered representative:
*
* assignments 53%
* control statements 32%
* procedure, function calls 15%
*
* 100 statements are dynamically executed. The program is balanced with
* respect to the three aspects:
* - statement type
* - operand type (for simple data types)
* - operand access
* operand global, local, parameter, or constant.
*
* The combination of these three aspects is balanced only approximately.
*
* The program does not compute anything meaningfull, but it is
* syntactically and semantically correct.
*
*/

/* Compiler dependent options */
#undef NOENUM /* Define if compiler has no enum's */
#undef NOSTRUCTASSIGN /* Define if compiler can't assign structures */
#undef NOTIME /* Define if no time() function in library */

#ifdef NOSTRUCTASSIGN
#define structassign(d, s) memcpy(&(d), &(s), sizeof(d))
#else
#define structassign(d, s) d = s
#endif

#ifdef NOENUM
#define Ident1 1
#define Ident2 2
#define Ident3 3
#define Ident4 4
#define Ident5 5
typedef int Enumeration;
#else
typedef enum {Ident1, Ident2, Ident3, Ident4, Ident5} Enumeration;
#endif

typedef int OneToThirty;
typedef int OneToFifty;
typedef char CapitalLetter;
typedef char String30[31];
typedef int Array1Dim[51];
typedef int Array2Dim[51][51];

struct Record
{
struct Record *PtrComp;
Enumeration Discr;
Enumeration EnumComp;
OneToFifty IntComp;
String30 StringComp;
};

typedef struct Record RecordType;
typedef RecordType * RecordPtr;
typedef int boolean;

#define NULL 0
#define TRUE 1
#define FALSE 0

#ifndef REG
#define REG
#endif

extern Enumeration Func1();
extern boolean Func2();

main()
{
Proc0();
}

/*
* Package 1
*/
int IntGlob;
boolean BoolGlob;
char Char1Glob;
char Char2Glob;
Array1Dim Array1Glob;
Array2Dim Array2Glob;
RecordPtr PtrGlob;
RecordPtr PtrGlobNext;

Proc0()
{
OneToFifty IntLoc1;
REG OneToFifty IntLoc2;
OneToFifty IntLoc3;
REG char CharLoc;
REG char CharIndex;
REG Enumeration EnumLoc;
String30 String1Loc;
String30 String2Loc;

#define LOOPS 50000
long time();
long starttime;
long benchtime;
long nulltime;
register unsigned int i;
starttime = time(0);
for (i = 0; i < LOOPS; ++i);
nulltime = time(0) - starttime;

PtrGlobNext = (RecordPtr) malloc(sizeof(RecordType));
PtrGlob = (RecordPtr) malloc(sizeof(RecordType));
PtrGlob->PtrComp = PtrGlobNext;
PtrGlob->Discr = Ident1;
PtrGlob->EnumComp = Ident3;
PtrGlob->IntComp = 40;
strcpy(PtrGlob->StringComp, "DHRYSTONE PROGRAM, SOME STRING");

/*****************
-- Start Timer --
*****************/
starttime = time(0);
for (i = 0; i < LOOPS; ++i)
{

Proc5();
Proc4();
IntLoc1 = 2;
IntLoc2 = 3;
strcpy(String2Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
EnumLoc = Ident2;
BoolGlob = ! Func2(String1Loc, String2Loc);
while (IntLoc1 < IntLoc2)
{
IntLoc3 = 5 * IntLoc1 - IntLoc2;
Proc7(IntLoc1, IntLoc2, &IntLoc3);
++IntLoc1;
}
Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3);
Proc1(PtrGlob);
for (CharIndex = 'A'; CharIndex <= Char2Glob; ++CharIndex)
if (EnumLoc == Func1(CharIndex, 'C'))
Proc6(Ident1, &EnumLoc);
IntLoc3 = IntLoc2 * IntLoc1;
IntLoc2 = IntLoc3 / IntLoc1;
IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1;
Proc2(&IntLoc1);

}

/*****************
-- Stop Timer --
*****************/
benchtime = time(0) - starttime - nulltime;
printf("Dhrystone time for %ld passes = %ld\n", (long) LOOPS, benchtime);
printf("This machine benchmarks at %ld dhrystones/second\n",
((long) LOOPS) / benchtime);

}

Proc1(PtrParIn)
REG RecordPtr PtrParIn;
{
#define NextRecord (*(PtrParIn->PtrComp))

structassign(NextRecord, *PtrGlob);
PtrParIn->IntComp = 5;
NextRecord.IntComp = PtrParIn->IntComp;
NextRecord.PtrComp = PtrParIn->PtrComp;
Proc3(NextRecord.PtrComp);
if (NextRecord.Discr == Ident1)
{
NextRecord.IntComp = 6;
Proc6(PtrParIn->EnumComp, &NextRecord.EnumComp);
NextRecord.PtrComp = PtrGlob->PtrComp;
Proc7(NextRecord.IntComp, 10, &NextRecord.IntComp);
}
else
structassign(*PtrParIn, NextRecord);

#undef NextRecord
}

Proc2(IntParIO)
OneToFifty *IntParIO;
{
REG OneToFifty IntLoc;
REG Enumeration EnumLoc;

IntLoc = *IntParIO + 10;
for(;;)
{
if (Char1Glob == 'A')
{
--IntLoc;
*IntParIO = IntLoc - IntGlob;
EnumLoc = Ident1;
}
if (EnumLoc == Ident1)
break;
}
}

Proc3(PtrParOut)
RecordPtr *PtrParOut;
{
if (PtrGlob != NULL)
*PtrParOut = PtrGlob->PtrComp;
else
IntGlob = 100;
Proc7(10, IntGlob, &PtrGlob->IntComp);
}

Proc4()
{
REG boolean BoolLoc;

BoolLoc = Char1Glob == 'A';
BoolLoc |= BoolGlob;
Char2Glob = 'B';
}

Proc5()
{
Char1Glob = 'A';
BoolGlob = FALSE;
}

extern boolean Func3();

Proc6(EnumParIn, EnumParOut)
REG Enumeration EnumParIn;
REG Enumeration *EnumParOut;
{
*EnumParOut = EnumParIn;
if (! Func3(EnumParIn) )
*EnumParOut = Ident4;
switch (EnumParIn)
{
case Ident1: *EnumParOut = Ident1; break;
case Ident2: if (IntGlob > 100) *EnumParOut = Ident1;
else *EnumParOut = Ident4;
break;
case Ident3: *EnumParOut = Ident2; break;
case Ident4: break;
case Ident5: *EnumParOut = Ident3;
}
}

Proc7(IntParI1, IntParI2, IntParOut)
OneToFifty IntParI1;
OneToFifty IntParI2;
OneToFifty *IntParOut;
{
REG OneToFifty IntLoc;

IntLoc = IntParI1 + 2;
*IntParOut = IntParI2 + IntLoc;
}

Proc8(Array1Par, Array2Par, IntParI1, IntParI2)
Array1Dim Array1Par;
Array2Dim Array2Par;
OneToFifty IntParI1;
OneToFifty IntParI2;
{
REG OneToFifty IntLoc;
REG OneToFifty IntIndex;

IntLoc = IntParI1 + 5;
Array1Par[IntLoc] = IntParI2;
Array1Par[IntLoc+1] = Array1Par[IntLoc];
Array1Par[IntLoc+30] = IntLoc;
for (IntIndex = IntLoc; IntIndex <= (IntLoc+1); ++IntIndex)
Array2Par[IntLoc][IntIndex] = IntLoc;
++Array2Par[IntLoc][IntLoc-1];
Array2Par[IntLoc+20][IntLoc] = Array1Par[IntLoc];
IntGlob = 5;
}

Enumeration Func1(CharPar1, CharPar2)
CapitalLetter CharPar1;
CapitalLetter CharPar2;
{
REG CapitalLetter CharLoc1;
REG CapitalLetter CharLoc2;

CharLoc1 = CharPar1;
CharLoc2 = CharLoc1;
if (CharLoc2 != CharPar2)
return (Ident1);
else
return (Ident2);
}

boolean Func2(StrParI1, StrParI2)
String30 StrParI1;
String30 StrParI2;
{
REG OneToThirty IntLoc;
REG CapitalLetter CharLoc;

IntLoc = 1;
while (IntLoc <= 1)
if (Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) == Ident1)
{
CharLoc = 'A';
++IntLoc;
}
if (CharLoc >= 'W' && CharLoc <= 'Z')
IntLoc = 7;
if (CharLoc == 'X')
return(TRUE);

else
{
if (strcmp(StrParI1, StrParI2) > 0)
{
IntLoc += 7;
return (TRUE);
}
else
return (FALSE);
}
}

boolean Func3(EnumParIn)
REG Enumeration EnumParIn;
{
REG Enumeration EnumLoc;

EnumLoc = EnumParIn;
if (EnumLoc == Ident3) return (TRUE);
return (FALSE);
}

#ifdef NOSTRUCTASSIGN
memcpy(d, s, l)
register char *d;
register char *s;
int l;
{
while (l--) *d++ = *s++;
}
#endif

/*
* Library function for compilers with no time(2) function in the
* library.
*/
#ifdef NOTIME
long time(p)
long *p;
{ /* CI-C86 time function - don't use around midnight */
long t;
struct regval {unsigned int ax,bx,cx,dx,si,di,ds,es; } regs;

regs.ax = 0x2c00;
sysint21(®s, ®s);
t = ((regs.cx>>8)*60L + (regs.cx & 0xff))*60L + (regs.dx>>8);
if (p) *p = t;
return t;
}
#endif