int dhrystone(
double& Vax_Mips, double& int_loops, double& int_time, double min_cpu_time
){
One_Fifty Int_1_Loc;
REG One_Fifty Int_2_Loc;
One_Fifty Int_3_Loc;
REG char Ch_Index;
Enumeration Enum_Loc;
Str_30 Str_1_Loc;
Str_30 Str_2_Loc;
unsigned long Loops;
DS_DATA dd;
double startclock, endclock;
double benchtime;
double Dhrystones_Per_Second;
register unsigned long Run_Index;
Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
Ptr_Glob->Discr = Ident_1;
Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
Ptr_Glob->variant.var_1.Int_Comp = 40;
strcpy (Ptr_Glob->variant.var_1.Str_Comp,
"DHRYSTONE PROGRAM, SOME STRING");
strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
Arr_2_Glob [8][7] = 10;
Loops = 16000; // determines runtime
// This must be small enough that, on the slowest CPU,
// one loop completes within 10 seconds.
benchmark_wait_to_start(BM_TYPE_INT);
boinc_calling_thread_cpu_time(startclock);
int bigloops = 0;
do
{
for (Run_Index = 0; Run_Index < Loops; ++Run_Index)
{
Proc_5(dd);
Proc_4(dd);
Int_1_Loc = 2;
Int_2_Loc = 3;
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
Enum_Loc = Ident_2;
Bool_Glob = ! Func_2 (dd, Str_1_Loc, Str_2_Loc);
while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
{
Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
Int_1_Loc += 1;
} /* while */
Proc_8 (dd, Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
Proc_1 (dd, Ptr_Glob);
for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
{
if (Enum_Loc == Func_1 (dd, Ch_Index, 'C'))
{
Proc_6 (dd, Ident_1, &Enum_Loc);
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
Int_2_Loc = Run_Index;
Int_Glob = Run_Index;
}
}
Int_2_Loc = Int_2_Loc * Int_1_Loc;
Int_1_Loc = Int_2_Loc / Int_3_Loc;
Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
Proc_2 (dd, &Int_1_Loc);
}
bigloops++;
}
while (!benchmark_time_to_stop(BM_TYPE_INT));
Loops *= bigloops;
boinc_calling_thread_cpu_time(endclock);
benchtime = endclock - startclock;
int_time = benchtime;
if (benchtime < min_cpu_time) return -1;
//printf ("%12.0f runs %6.2f seconds \n",(double) Loops, benchtime);
Dhrystones_Per_Second = (double) Loops / benchtime;
Vax_Mips = Dhrystones_Per_Second / 1757.0;
int_loops = Loops;
#if 0
printf ("Dhrystones per Second: ");
printf ("%10.0lf \n", Dhrystones_Per_Second);
printf ("VAX MIPS rating = ");
printf ("%12.2lf \n",Vax_Mips);
#endif
free(Next_Ptr_Glob);
free(Ptr_Glob);
return 0;
}
// return an error if CPU time is less than min_cpu_time
//
int whetstone(double& flops, double& cpu_time, double min_cpu_time) {
long n1,n2,n3,n4,n5,n6,n7,n8,i,ix,n1mult;
SPDP x,y,z;
long j,k,l, jjj;
SPDP e1[4];
double startsec, finisec;
double KIPS;
int xtra, ii;
int x100 = 1000; // chosen to make each pass take about 0.1 sec
// on my current computer (2.2 GHz celeron)
// This must be small enough that one loop finishes
// in 10 sec on the slowest CPU
extern_array[11] = 1;
benchmark_wait_to_start(BM_TYPE_FP);
boinc_calling_thread_cpu_time(startsec);
SPDP t = 0.49999975;
SPDP t0 = t;
SPDP t1 = 0.50000025;
SPDP t2 = 2.0;
n1 = 12*x100;
n2 = 14*x100;
n3 = 345*x100;
n4 = 210*x100;
n5 = 32*x100;
n6 = 899*x100;
n7 = 616*x100;
n8 = 93*x100;
xtra = 1;
n1mult = 10;
ii = 0;
do {
/* Section 1, Array elements */
e1[0] = 1.0;
e1[1] = -1.0;
e1[2] = -1.0;
e1[3] = -1.0;
{
for (ix=0; ix<xtra; ix++)
{
for(i=0; i<n1*n1mult; i++)
{
e1[0] = (e1[0] + e1[1] + e1[2] - e1[3]) * t;
e1[1] = (e1[0] + e1[1] - e1[2] + e1[3]) * t;
e1[2] = (e1[0] - e1[1] + e1[2] + e1[3]) * t;
e1[3] = (-e1[0] + e1[1] + e1[2] + e1[3]) * t;
}
t = 1.0 - t;
}
t = t0;
}
extern_array[0] = e1[0];
extern_array[1] = e1[1];
extern_array[2] = e1[2];
extern_array[3] = e1[3];
/* Section 2, Array as parameter */
{
for (ix=0; ix<xtra; ix++)
{
for(i=0; i<n2; i++)
{
pa(e1,t,t2);
}
t = 1.0 - t;
}
t = t0;
}
extern_array[4] = e1[0];
/* Section 3, Conditional jumps */
jjj = (long) extern_array[11];
j = k = jjj;
{
for (ix=0; ix<xtra; ix++) {
for(i=0; i<n3; i++) {
if(j==1) l = jjj;
else l = k;
if(k>2) j = jjj;
else j = 1;
if(l<1) k = 1;
else k = jjj;
}
}
}
extern_array[5] = (double)j;
/* Section 4, Integer arithmetic */
j = long(e1[0]);
k = 2;
l = 3;
{
for (ix=0; ix<xtra; ix++)
{
for(i=0; i<n4; i++)
{
j = j *(k-j)*(l-k);
k = l * k - (l-j) * k;
l = (l-k) * (k+j);
e1[l&3] = j + k + l;
e1[k&3] = j * k * l;
}
}
}
extern_array[6] = e1[0];
/* Section 5, Trig functions */
x = 0.5;
y = 0.5;
{
for (ix=0; ix<xtra; ix++)
{
for(i=1; i<n5; i++)
{
x = t*atan(t2*sin(x)*cos(x)/(cos(x+y)+cos(x-y)-1.0));
y = t*atan(t2*sin(y)*cos(y)/(cos(x+y)+cos(x-y)-1.0));
}
t = 1.0 - t;
}
t = t0;
}
extern_array[7] = x;
/* Section 6, Procedure calls */
x = 1.0;
y = 1.0;
z = 1.0;
{
for (ix=0; ix<xtra; ix++)
{
for(i=0; i<n6; i++)
{
p3(&x,&y,&z,t,t1,t2);
}
}
}
extern_array[8] = x;
/* Section 7, Array refrences */
j = 0;
k = 1;
l = 2;
e1[0] = 1.0;
e1[1] = 2.0;
e1[2] = 3.0;
{
for (ix=0; ix<xtra; ix++)
{
for(i=0;i<n7;i++)
{
po(e1,j,k,l);
}
}
}
extern_array[9] = e1[0];
/* Section 8, Standard functions */
x = 0.75;
for (ix=0; ix<xtra; ix++) {
for(i=0; i<n8; i++) {
x = sqrt(exp(log(x)/t1));
}
}
extern_array[10] = x;
ii++;
}
while (!benchmark_time_to_stop(BM_TYPE_FP));
boinc_calling_thread_cpu_time(finisec);
double diff = finisec - startsec;
cpu_time = diff;
if (diff < min_cpu_time) {
return -1;
}
KIPS = (100.0*x100*ii)/diff;
#if 0
if (KIPS >= 1000.0)
printf("C Converted Double Precision Whetstones: %.1f MIPS\n", KIPS/1000.0);
else
printf("C Converted Double Precision Whetstones: %.1f KIPS\n", KIPS);
#endif
// convert from thousands of instructions a second to instructions a second.
flops = KIPS*1000.0;
return 0;
}
