Page MenuHomePhabricator
Differential D43319 Diff 139604 MicroBenchmarks/LCALS/main.cxx

Changeset View

Standalone View

View Options

MicroBenchmarks/LCALS/main.cxx

//
// See README-LCALS_license.txt for access and distribution restrictions
//
// This code is under continuing development. Go to http://codesign.llnl.gov
// to acquire the latest released version.
//
//
// Main program for LCALS suite.
//
#include <cstdlib>
#include<string>
#include<iostream>
#include<algorithm>
#include <unistd.h>
#include "LCALSSuite.hxx"
#include <benchmark/benchmark.h>
int main(int argc, char *argv[])
{
//
// Define some variables used to define part of suite execution.
//
bool do_fom = true;
bool run_misc = false;
bool input_error = false;
std::string output_dirname;
//
// Process command line args and report correct usage if necessary.
//
// if (argc == 1) no args to check...
#ifdef TESTSUITE
if (argc > 1) {
std::string arg = argv[1];
if ( arg == "-misc" ) {
run_misc = true;
} else {
output_dirname = argv[1];
}
}
if (argc > 2) {
if ( !run_misc ) {
input_error = true;
} else {
output_dirname = argv[2];
}
}
if ( argc > 3) {
input_error = true;
}
if ( !input_error ) {
if ( !output_dirname.empty() && !recursiveMkdir(output_dirname) ) {
std::cout << "Problem with given output directory name." << std::endl;
std::cout << "No file output will be generated." << std::endl;
}
} else {
std::cout << "ERROR RUNNING EXECUTABLE!\n\n";
std::cout << "CORRECT USAGE:\n";
std::cout << "\t" << argv[0]
<< " -misc <output directory name>, both args optional\n\n"
<< "\tIf '-misc' option is given, "
<< "benchmark variants plus others may be run.\n"
<< "\tActual loop variants to run are set below using the\n"
<< "\tvector 'run_variants'. Note that the compiler switch\n"
<< "\tin the Makefile may be required for full compilation.\n\n"
<< "\tWhen no output directory is provided,\n"
<< "\trun summary will be printed to standard output\n"
<< "\tIf directory name is provided, execution summary and\n"
<< "\ttext files suitable for importing into MS Excel will\n"
<< "\tbe written there." << std::endl;
exit(-1);
return -1;
}
#endif
//
// Define some parameters specifying how suite of loops will execute.
//
// See README-LCALS_instructions.txt file for additional description of how
// to control compilation and execution of loop suite.
//
unsigned num_suite_passes = 1;
#if defined(LCALS_VERIFY_CHECKSUM_ABBREVIATED)
//
// When verifying checksums, we only take one pass through the suite of loops
// as this is sufficient.
//
num_suite_passes = num_checksum_suite_passes;
#endif
//
// Specify fraction of pre-defined loop sample counts to use.
// Smaller value reduces total run time. However, a value too
// small will result in inaccurate timings.
//
double sample_frac = 1.0;
//
// Specify multiplication factor used to deviate from pre-defined loop
// lengths to use. For example, setting factor to 'a' will roughly
// multiply the length of "1D" loops by a and will multiply total number
// of iterations of "domain-based" loops by a^N, where N is the
// spatial dimension of the domain used by the loop.
//
double loop_length_factor = 1.0;
//
// Specify which loops lengths to run by true/false
// value in 'run_loop_length' array.
//
bool run_loop_length[NUM_LENGTHS];
run_loop_length[LONG] = true;
run_loop_length[MEDIUM] = true;
run_loop_length[SHORT] = true;
//
// Specify loop kernels to run by true/false value in 'run_loop' array.
//
// NOTE: If COMPILE_* macro constant associated with each lernel
// is not defined, then those kernels will not be compiled
// and thus will not be run.
//
bool run_loop[NUM_LOOP_KERNELS];
for (unsigned iloop = 0; iloop < NUM_LOOP_KERNELS; ++iloop) {
run_loop[iloop] = false;
}
#if defined(LCALS_DO_OMP_ONLY)
// Loop Subset A: Loops extracted from LLNL app codes.
run_loop[PRESSURE_CALC ] = true;
run_loop[PRESSURE_CALC_ALT ] = true;
run_loop[ENERGY_CALC ] = true;
run_loop[ENERGY_CALC_ALT ] = true;
run_loop[VOL3D_CALC ] = true;
run_loop[DEL_DOT_VEC_2D] = true;
run_loop[COUPLE ] = true;
run_loop[FIR ] = true;
// Loop Subset B: "Basic" Loops.
run_loop[INIT3 ] = true;
run_loop[MULADDSUB ] = true;
run_loop[IF_QUAD ] = true;
run_loop[TRAP_INT ] = true;
// Loop Subset C: Loops from older Livermore Loops in "C" suite.
run_loop[PIC_2D ] = true;
#else // else run all loop kernels
// Loop Subset A: Loops extracted from LLNL app codes.
run_loop[PRESSURE_CALC ] = true;
run_loop[ENERGY_CALC ] = true;
run_loop[VOL3D_CALC ] = true;
run_loop[DEL_DOT_VEC_2D] = true;
run_loop[COUPLE ] = true;
run_loop[FIR ] = true;
// Loop Subset B: "Basic" Loops.
run_loop[INIT3 ] = true;
run_loop[MULADDSUB ] = true;
run_loop[IF_QUAD ] = true;
run_loop[TRAP_INT ] = true;
// Loop Subset C: Loops from older Livermore Loops in "C" suite.
run_loop[HYDRO_1D ] = true;
run_loop[ICCG ] = true;
run_loop[INNER_PROD ] = true;
run_loop[BAND_LIN_EQ ] = true;
run_loop[TRIDIAG_ELIM ] = true;
run_loop[EOS ] = true;
run_loop[ADI ] = true;
run_loop[INT_PREDICT ] = true;
run_loop[DIFF_PREDICT ] = true;
run_loop[FIRST_SUM ] = true;
run_loop[FIRST_DIFF ] = true;
run_loop[PIC_2D ] = true;
run_loop[PIC_1D ] = true;
run_loop[HYDRO_2D ] = true;
run_loop[GEN_LIN_RECUR ] = true;
run_loop[DISC_ORD ] = true;
run_loop[MAT_X_MAT ] = true;
run_loop[PLANCKIAN ] = true;
run_loop[IMP_HYDRO_2D ] = true;
run_loop[FIND_FIRST_MIN] = true;
#endif
//
// Specify which loop variants are executed. To run different loop variants,
// change which enum values are pushed onto the run-variants vector here.
//
// IMPORTANT: The first variant added is used as the reference
// variant for reporting relative execution timing data
// and checksum comparisons.
//
std::vector<LoopVariantID> run_variants;
if ( !run_misc ) {
//
// These variants comprose the LCALS benchmark.
//
#if defined(LCALS_DO_OMP_ONLY)
run_variants.push_back(RAW_OMP);
run_variants.push_back(FORALL_LAMBDA_OMP);
#else // run other variants in addition to OMP variants
run_variants.push_back(RAW);
run_variants.push_back(FORALL_LAMBDA);
run_variants.push_back(RAW_OMP);
run_variants.push_back(FORALL_LAMBDA_OMP);
#endif
} else {
//
// These variants are used for miscellaneous studies.
//
#if defined(LCALS_DO_OMP_ONLY)
run_variants.push_back(RAW_OMP);
run_variants.push_back(FORALL_LAMBDA_OMP);
#if defined(LCALS_DO_MISC)
run_variants.push_back(FORALL_FUNCTOR_OMP);
// run_variants.push_back(FORALL_LAMBDA_OMP_TYPEFIX);
#endif // if LCALS_DO_MISC
#else // run other variants in addition to OMP variants
//
// Bechmark variants.
//
run_variants.push_back(RAW);
run_variants.push_back(FORALL_LAMBDA);
// run_variants.push_back(RAW_OMP);
// run_variants.push_back(FORALL_LAMBDA_OMP);
//
// Other available loop variants.
//
#if defined(LCALS_DO_MISC)
// run_variants.push_back(FORALL_HYBRID_LAMBDA);
// run_variants.push_back(FORALL_FUNCTOR);
// run_variants.push_back(FORALL_FUNCTOR_OMP);
// run_variants.push_back(RAW_FUNC);
// run_variants.push_back(FORALL_LAMBDA_TYPEFIX);
// run_variants.push_back(FORALL_LAMBDA_OMP_TYPEFIX);
// run_variants.push_back(FORALL_HYBRID_LAMBDA_TYPEFIX);
#endif // if LCALS_DO_MISC
#endif
}
//
// Obtain and report hostname.
//
const int host_namelen = 64;
char host[host_namelen];
gethostname( host, host_namelen );
std::string host_name(host);
#ifdef TESTSUITE
std::cout << "\n Running loop suite on " << host_name << std::endl;
#endif
//
// Specify size in bytes of largest data cache level on machine so that
// caches can be properly flushed between execution of different loops.
//
CacheIndex_type cache_size = 0;
if ( host_name.find("rzalastor") != std::string::npos ) {
cache_size = 12000000; // 12MB on rzalastor
} else if ( host_name.find("rzmerl") != std::string::npos ) {
cache_size = 20000000; // 20MB on rzmerl
} else if ( host_name.find("dawn") != std::string::npos ) {
cache_size = 8000000; // 8MB on dawn/rzdawndev
} else if ( host_name.find("rzuseq") != std::string::npos ||
host_name.find("vulcan") != std::string::npos ||
host_name.find("sequoia") != std::string::npos ) {
cache_size = 32000000; // 32MB on BG/Q
}
#ifdef TESTSUITE
else {
std::cout << "\n WARNING: unknown system cache size. "
<< "Timing results may be suspect!!" << std::endl;
}
#endif
//
// Allocate data for running loops and generating execution timings.
// Also, set structures that define how loops will be run.
//
allocateLoopSuiteRunInfo(host_name,
NUM_LOOP_KERNELS,
NUM_LENGTHS,
num_suite_passes,
run_loop_length,
cache_size);
defineLoopSuiteRunInfo( run_variants, run_loop, sample_frac,
loop_length_factor );
allocateLoopData();
if (do_fom) {
//
// Compute reference times for figure of merit (FOM) calculation.
//
computeReferenceLoopTimes();
}
/*************** TEST SUITE ****************
* *
* Using google benchmark as test Runner *
* *
*******************************************/
::benchmark::Initialize(&argc, argv);
if(::benchmark::ReportUnrecognizedArguments(argc, argv)) return 1;
::benchmark::RunSpecifiedBenchmarks();
#ifdef TESTSUITE
// Run loops, record timings, etc.
//
for (unsigned ipass = 0; ipass < num_suite_passes; ++ipass) {
std::cout << "\n run suite: pass = " << ipass << std::endl;
for (unsigned ivariant = 0; ivariant < run_variants.size(); ++ivariant) {
std::string loop_variant_name =
getVariantName(run_variants[ivariant]);
std::cout << "\t run loop variant ---> "
<< loop_variant_name << std::endl;
for (unsigned ilen = 0; ilen < NUM_LENGTHS; ++ilen) {
if (run_loop_length[ilen]) {
LoopLength rilen = static_cast<LoopLength>(ilen);
runLoopVariant(run_variants[ivariant], run_loop, rilen) ;
} // if loop length is run
} // iterate over loop lengths
} // iterate over loop variants
} // iterate over loop suite passes
#endif
#ifdef TESTSUITE
//
// Generate report(s).
//
std::cout << "\n generate reports...." << std::endl;
std::vector<std::string> run_variant_names = getVariantNames(run_variants);
generateTimingReport(run_variant_names, output_dirname);
generateChecksumReport(run_variant_names, output_dirname);
generateFOMReport(run_variant_names, output_dirname);
#endif
//
// Clean up.
//
freeLoopData();
#ifdef TESTSUITE
std::cout << "\n freeLoopSuiteRunInfo..." << std::endl;
#endif
freeLoopSuiteRunInfo();
#ifdef TESTSUITE
std::cout << "\n DONE!!! " << std::endl;
#endif
return 0 ;
}