public void runBenchMark()
{
BMArgs.Banner(BMName, CLASS, serial, num_threads);
Console.WriteLine(" Size = " + nx + " X " + ny + " X " + nz
+ " niter = " + niter_default);
setTimers();
timer.resetAllTimers();
if (serial)
{
appft_serial();
}
if (timeron)
{
timer.start(14);
}
int verified = verify(4, nx, ny, nz, niter_default, checksum);
if (timeron)
{
timer.stop(14);
}
timer.stop(1);
double time = timer.readTimer(1);
results = new BMResults(BMName,
CLASS,
nx,
ny,
nz,
niter_default,
time,
getMFLOPS(time, nx, ny, nz),
"floating point",
verified,
serial,
num_threads,
bid);
results.print();
if (timeron)
{
printTimers();
}
done = true;
}
private void runBenchmark()
{
setup_mpi();
if (!active)
{
Console.WriteLine("not active !");
System.Environment.Exit(0);
}
//int niter = -1;
if (node == root)
{
BMArgs.Banner(BMName, problem_class.ToString()[0], false, total_nodes);
}
// Process.make_set();
for (int c = 0; c < ncells; c++)
{
if ((cell_size[c, 0] > Problem.IMAX) ||
(cell_size[c, 1] > Problem.JMAX) ||
(cell_size[c, 2] > Problem.KMAX))
{
Console.WriteLine("Problem size too big for compiled array sizes");
System.Environment.Exit(0);
}
}
//Problem.initialize_problem_data();
//Problem.set_constants(0);
Initialize.go();
Lhsinit.go();
Exact_rhs.go();
//compute_buffer_size(5);
//---------------------------------------------------------------------
// do one time step to touch all code, and reinitialize
//---------------------------------------------------------------------
Adi.go();
Initialize.go();
//---------------------------------------------------------------------
// Synchronize before placing time stamp
//---------------------------------------------------------------------
comm_setup.Barrier();
Timer.resetAllTimers();
Timer.start(t_total);
Console.WriteLine("STARTING"); Console.Out.Flush();
for (int step = 1; step <= niter; step++)
{
if (node == 0 && (step % 20 == 0 || step == 1 || step == niter))
{
Console.WriteLine("Time step " + step);
}
Adi.go();
}
Timer.stop(1);
Verify.go();
int verified = Verify.Verified;
double tmax = Timer.readTimerGlobal(t_total);
if (node == root)
{
double time = Timer.readTimer(t_total);
results = new BMResults(BMName,
problem_class.ToString()[0],
grid_points[0],
grid_points[1],
grid_points[2],
niter,
time,
getMFLOPS(time, niter),
"floating point",
verified,
true,
total_nodes,
bid);
results.print();
}
worldcomm.Barrier();
}
public int verify(int ires, int n1, int n2, int n3, int nt, double[,] cksum)
{
int verified = -1;
bool[] temp = new bool[niter_default];
double[,] cexpd = new double[21, 2];
if ((n1 == 64) && (n2 == 64) && (n3 == 64) && (nt == 6))
{
//
// Class S reference values.
//
cexpd[0, REAL] = 554.6087004964;
cexpd[1, REAL] = 554.6385409189;
cexpd[2, REAL] = 554.6148406171;
cexpd[3, REAL] = 554.5423607415;
cexpd[4, REAL] = 554.4255039624;
cexpd[5, REAL] = 554.2683411902;
cexpd[0, IMAG] = 484.5363331978;
cexpd[1, IMAG] = 486.5304269511;
cexpd[2, IMAG] = 488.3910722336;
cexpd[3, IMAG] = 490.1273169046;
cexpd[4, IMAG] = 491.7475857993;
cexpd[5, IMAG] = 493.2597244941;
}
else if ((n1 == 128) && (n2 == 128) && (n3 == 32) && (nt == 6))
{
//
// Class W reference values.
//
cexpd[0, REAL] = 567.3612178944;
cexpd[1, REAL] = 563.1436885271;
cexpd[2, REAL] = 559.4024089970;
cexpd[3, REAL] = 556.0698047020;
cexpd[4, REAL] = 553.0898991250;
cexpd[5, REAL] = 550.4159734538;
cexpd[0, IMAG] = 529.3246849175;
cexpd[1, IMAG] = 528.2149986629;
cexpd[2, IMAG] = 527.0996558037;
cexpd[3, IMAG] = 526.0027904925;
cexpd[4, IMAG] = 524.9400845633;
cexpd[5, IMAG] = 523.9212247086;
//
}
else if ((n1 == 256) && (n2 == 256) && (n3 == 128) && (nt == 6))
{
//
// Class A reference values.
//
cexpd[0, REAL] = 504.6735008193;
cexpd[1, REAL] = 505.9412319734;
cexpd[2, REAL] = 506.9376896287;
cexpd[3, REAL] = 507.7892868474;
cexpd[4, REAL] = 508.5233095391;
cexpd[5, REAL] = 509.1487099959;
cexpd[0, IMAG] = 511.4047905510;
cexpd[1, IMAG] = 509.8809666433;
cexpd[2, IMAG] = 509.8144042213;
cexpd[3, IMAG] = 510.1336130759;
cexpd[4, IMAG] = 510.4914655194;
cexpd[5, IMAG] = 510.7917842803;
//
}
else if ((n1 == 512) && (n2 == 256) && (n3 == 256) && (nt == 20))
{
//
// Class B reference values.
//
cexpd[0, REAL] = 517.7643571579;
cexpd[1, REAL] = 515.4521291263;
cexpd[2, REAL] = 514.6409228649;
cexpd[3, REAL] = 514.2378756213;
cexpd[4, REAL] = 513.9626667737;
cexpd[5, REAL] = 513.7423460082;
cexpd[6, REAL] = 513.5547056878;
cexpd[7, REAL] = 513.3910925466;
cexpd[8, REAL] = 513.2470705390;
cexpd[9, REAL] = 513.1197729984;
cexpd[10, REAL] = 513.0070319283;
cexpd[11, REAL] = 512.9070537032;
cexpd[12, REAL] = 512.8182883502;
cexpd[13, REAL] = 512.7393733383;
cexpd[14, REAL] = 512.6691062020;
cexpd[15, REAL] = 512.6064276004;
cexpd[16, REAL] = 512.5504076570;
cexpd[17, REAL] = 512.5002331720;
cexpd[18, REAL] = 512.4551951846;
cexpd[19, REAL] = 512.4146770029;
cexpd[0, IMAG] = 507.7803458597;
cexpd[1, IMAG] = 508.8249431599;
cexpd[2, IMAG] = 509.6208912659;
cexpd[3, IMAG] = 510.1023387619;
cexpd[4, IMAG] = 510.3976610617;
cexpd[5, IMAG] = 510.5948019802;
cexpd[6, IMAG] = 510.7404165783;
cexpd[7, IMAG] = 510.8576573661;
cexpd[8, IMAG] = 510.9577278523;
cexpd[9, IMAG] = 511.0460304483;
cexpd[10, IMAG] = 511.1252433800;
cexpd[11, IMAG] = 511.1968077718;
cexpd[12, IMAG] = 511.2616233064;
cexpd[13, IMAG] = 511.3203605551;
cexpd[14, IMAG] = 511.3735928093;
cexpd[15, IMAG] = 511.4218460548;
cexpd[16, IMAG] = 511.4656139760;
cexpd[17, IMAG] = 511.5053595966;
cexpd[18, IMAG] = 511.5415130407;
cexpd[19, IMAG] = 511.5744692211;
//
}
else if ((n1 == 512) && (n2 == 512) &&
(n3 == 512) && (nt == 20))
{
//
// Class C reference values.
//
cexpd[0, REAL] = 519.5078707457;
cexpd[1, REAL] = 515.5422171134;
cexpd[2, REAL] = 514.4678022222;
cexpd[3, REAL] = 514.0150594328;
cexpd[4, REAL] = 513.7550426810;
cexpd[5, REAL] = 513.5811056728;
cexpd[6, REAL] = 513.4569343165;
cexpd[7, REAL] = 513.3651975661;
cexpd[8, REAL] = 513.2955192805;
cexpd[9, REAL] = 513.2410471738;
cexpd[10, REAL] = 513.1971141679;
cexpd[11, REAL] = 513.1605205716;
cexpd[12, REAL] = 513.1290734194;
cexpd[13, REAL] = 513.1012720314;
cexpd[14, REAL] = 513.0760908195;
cexpd[15, REAL] = 513.0528295923;
cexpd[16, REAL] = 513.0310107773;
cexpd[17, REAL] = 513.0103090133;
cexpd[18, REAL] = 512.9905029333;
cexpd[19, REAL] = 512.9714421109;
cexpd[0, IMAG] = 514.9019699238;
cexpd[1, IMAG] = 512.7578201997;
cexpd[2, IMAG] = 512.2251847514;
cexpd[3, IMAG] = 512.1090289018;
cexpd[4, IMAG] = 512.1143685824;
cexpd[5, IMAG] = 512.1496764568;
cexpd[6, IMAG] = 512.1870921893;
cexpd[7, IMAG] = 512.2193250322;
cexpd[8, IMAG] = 512.2454735794;
cexpd[9, IMAG] = 512.2663649603;
cexpd[10, IMAG] = 512.2830879827;
cexpd[11, IMAG] = 512.2965869718;
cexpd[12, IMAG] = 512.3075927445;
cexpd[13, IMAG] = 512.3166486553;
cexpd[14, IMAG] = 512.3241541685;
cexpd[15, IMAG] = 512.3304037599;
cexpd[16, IMAG] = 512.3356167976;
cexpd[17, IMAG] = 512.3399592211;
cexpd[18, IMAG] = 512.3435588985;
cexpd[19, IMAG] = 512.3465164008;
}
double epsilon = 1.0E-12;
//
// Verification test for results.
//
if (nt <= 0)
{
}
else
{
for (int it = 0; it < nt; it++)
{
double csumr = (cksum[it, REAL] - cexpd[it, REAL]) / cexpd[it, REAL];
double csumi = (cksum[it, IMAG] - cexpd[it, IMAG]) / cexpd[it, IMAG];
if (Math.Abs(csumr) <= epsilon ||
Math.Abs(csumi) <= epsilon
)
{
if (verified == -1)
{
verified = 1;
}
}
else
{
verified = 0;
}
}
}
BMResults.printVerificationStatus(CLASS, verified, BMName);
return(verified);
}
public override int go()
{
int no_time_steps = Instance.niter_default;
double dt = Instance.dt_default;
grid_points = Problem.grid_points;
double[] xcrref = Instance.xcrref, xceref = Instance.xceref,
xcrdif = new double[5], xcedif = new double[5],
xce = Error_norm.xce, xcr = Rhs_norm.xcr;
double dtref = Instance.dtref;
int m;
PROBLEM_CLASS clss = Instance.CLASS;
//---------------------------------------------------------------------
// compute the error norm and the residual norm, and exit if not printing
//---------------------------------------------------------------------
// error_norm(xce);
Error_norm.go();
// copy_faces();
if (Ranks.Length > 1)
{
Copy_faces.go();
}
Compute_rhs.go();
//rhs_norm(xcr);
Rhs_norm.go();
for (m = 0; m < 5; m++)
{
xcr[m] /= dt;
}
//for (m = 0; m < 5; m++)
//{
// xcrref[m] = 1.0d;
// xceref[m] = 1.0d;
//}
//---------------------------------------------------------------------
// verification test for residuals if gridsize is either 12X12X12 or
// 64X64X64 or 102X102X102 or 162X162X162
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// Compute the difference of solution values and the known reference values.
//---------------------------------------------------------------------
for (m = 0; m < 5; m++)
{
xcrdif[m] = Math.Abs((xcr[m] - xcrref[m]) / xcrref[m]);
xcedif[m] = Math.Abs((xce[m] - xceref[m]) / xceref[m]);
}
//---------------------------------------------------------------------
// tolerance level
//---------------------------------------------------------------------
double epsilon = 1.0E-8d;
//---------------------------------------------------------------------
// Output the comparison of computed results to known cases.
//---------------------------------------------------------------------
if (clss != PROBLEM_CLASS.U)
{
Console.WriteLine(" Verification being performed for class " + clss);
Console.WriteLine(" Accuracy setting for epsilon = " + epsilon);
if (Math.Abs(dt - dtref) <= epsilon)
{
if (verified == -1)
{
verified = 1;
}
}
else
{
verified = 0;
clss = PROBLEM_CLASS.U;
Console.WriteLine("DT does not match the reference value of " + dtref);
}
Console.WriteLine(" Comparison of RMS-norms of residual");
}
else
{
Console.WriteLine(" Unknown CLASS");
Console.WriteLine(" RMS-norms of residual");
}
verified = BMResults.printComparisonStatus(clss.ToString()[0], verified, epsilon,
xcr, xcrref, xcrdif);
if (clss != PROBLEM_CLASS.U)
{
Console.WriteLine(" Comparison of RMS-norms of solution error");
}
else
{
Console.WriteLine(" RMS-norms of solution error");
}
verified = BMResults.printComparisonStatus(clss.ToString()[0], verified, epsilon,
xce, xceref, xcedif);
BMResults.printVerificationStatus(clss.ToString()[0], verified, BMName);
return(0);
} // end activate method
private void runBenchmark()
{
int node = worldcomm.Rank;
num = worldcomm.Size;
if (node == 0)
{
Console.WriteLine(" Size: " + isiz01 + " x " + isiz02 + " x " + isiz03);
}
if (node == 0)
{
Console.WriteLine(" Iterations: " + itmax);
}
if (node == 0)
{
Console.WriteLine(" Number of processes: " + num);
}
// proc_grid();
// neighbors();
// subdomain();
// setConstants();
// Process.configBlock();
//---------------------------------------------------------------------
// set the boundary values for dependent variables
//---------------------------------------------------------------------
Setbv.go();
//---------------------------------------------------------------------
// set the initial values for dependent variables
//---------------------------------------------------------------------
Setiv.go();
//---------------------------------------------------------------------
// compute the forcing term based on prescribed exact solution
//---------------------------------------------------------------------
Erhs.go();
//---------------------------------------------------------------------
// perform one SSOR iteration to touch all data and program pages
//---------------------------------------------------------------------
Ssor.setParameters(1);
Ssor.go();
//---------------------------------------------------------------------
// reset the boundary and initial values
//---------------------------------------------------------------------
Setbv.go();
Setiv.go();
//---------------------------------------------------------------------
// perform the SSOR iterations
//---------------------------------------------------------------------
Ssor.setParameters(itmax);
Ssor.go();
double[] rsdnm = Ssor.Rsdnm;
//---------------------------------------------------------------------
// compute the solution error
//---------------------------------------------------------------------
Error.go();
double[] errnm = Error.Errnm;
//---------------------------------------------------------------------
// compute the surface integral
//---------------------------------------------------------------------
Pintgr.go();
double frc = Pintgr.Frc;
//---------------------------------------------------------------------
// verification test
//---------------------------------------------------------------------
double maxtime = Ssor.Maxtime;
if (node == 0)
{
double mflops = ((double)(itmax)) * (1984.77 * ((double)(nx0)) * ((double)(ny0)) * ((double)(nz0)) - 10923.3 * pow2((((double)(nx0 + ny0 + nz0)) / 3.0)) + 27770.9 * ((double)(nx0 + ny0 + nz0)) / 3.0 - 144010.0) / (maxtime * 1000000.0);
Verify.setParameters(rsdnm, errnm, frc);
Verify.go();
int verified = Verify.Verified;
BMResults results = new BMResults(BMName,
problem_class.ToString()[0],
nx0,
ny0,
nz0,
itmax,
maxtime,
mflops,
"floating point",
verified,
true,
num,
-1);
results.print();
}
}
public void runBenchMark()
{
worldcomm = this.WorldComm;
np = worldcomm.Size;
node = worldcomm.Rank;
for (int i = 1; i <= T_max; i++)
{
Timer.resetTimer(i);
}
int niter = initialConfig();
Problem.problemConfig(np1, np2, layout_type);
Blocks.blocksConfig(nx, ny, nz, np1, np2, layout_type);
dims = Problem.dims;
twiddle = Problem.twiddle;
u0 = Problem.Field_u0;
u1 = Problem.Field_u1;
u2 = Problem.Field_u2;
Compute_index_map.setParameters(twiddle, dims[0, 2], dims[1, 2], dims[2, 2]);
Compute_index_map.go();
Compute_initial_conditions.setParameters(u1);
Compute_initial_conditions.go();
Fftinit.setParameters(dims[0, 0]);
Fftinit.go();
Fft.setParameters(1, u1, u0);
Fft.go();
for (int i = 1; i <= T_max; i++)
{
Timer.resetTimer(i);
}
worldcomm.Barrier();
Timer.start(T_total);
Compute_index_map.setParameters(twiddle, dims[0, 2], dims[1, 2], dims[2, 2]);
Compute_index_map.go();
Compute_initial_conditions.setParameters(u1);
Compute_initial_conditions.go();
Fftinit.setParameters(dims[0, 0]);
Fftinit.go();
Fft.setParameters(1, u1, u0);
Fft.go();
double[] sums = new double[niter_default * 2];
for (int iter = 0; iter < niter; iter++)
{
Evolve.setParameters(u0, u1, twiddle, dims[0, 0], dims[1, 0], dims[2, 0]);
Evolve.go();
Fft.setParameters(-1, u1, u2);
Fft.go();
Checksum.setParameters(iter, sums, u2, dims[0, 0], dims[1, 0], dims[2, 0]);
Checksum.go();
}
Verify.setParameters(niter, sums);
int verified = Verify.go();
Timer.stop(T_total);
double total_time = Timer.readTimer(T_total);
double ntotal_f = (double)(nx * ny * nz);
double mflops = 0.0;
if (total_time != 0)
{
mflops = 0.000001 * ntotal_f * (14.8157 + 7.19641 * Math.Log(ntotal_f) + (5.23518 + 7.21113 * Math.Log(ntotal_f)) * niter) / total_time;
}
else
{
mflops = 0.0;
}
if (node == 0)
{
BMResults results = new BMResults(BMName,
problem_class.ToString()[0],
nx,
ny,
nz,
niter,
total_time,
mflops,
"floating point",
verified,
true,
np,
-1);
results.print();
}
}
