| // |
| // See README-LCALS_license.txt for access and distribution restrictions |
| // |
| |
| // |
| // Header file with enums, macros, routines and structures used to |
| // compile and run loops in LCALS suite and to generate execution |
| // statistics. |
| // |
| |
| #ifndef LCALSSuite_HXX |
| #define LCALSSuite_HXX |
| |
| #include "LCALSParams.hxx" |
| #include "LCALSStats.hxx" |
| |
| #include <vector> |
| #include <string> |
| |
| |
| // |
| // Enumeration defining unique id for each loop KERNEL in suite. |
| // |
| // IMPORTANT: Generally, this should not need modification unless |
| // new loops (i.e., kernels) are added to the suite. |
| // |
| // Note: To keep output understandable, keep this consistent with |
| // routine defineLoopSuiteRunInfo(). |
| // |
| enum LoopKernelID { |
| |
| // Keep this one first and don't comment out (!!) |
| // This insures loop ids start at zero so all array indexing |
| // or data structures is correct. Also, this loop is not |
| // executed the same way the others are. |
| REF_LOOP = 0, |
| |
| // |
| // Loop Subset A: Loops extracted from LLNL app codes. |
| // They are implemented in runA<variant>Loops.cxx files. |
| // |
| PRESSURE_CALC, |
| PRESSURE_CALC_ALT, |
| ENERGY_CALC, |
| ENERGY_CALC_ALT, |
| VOL3D_CALC, |
| DEL_DOT_VEC_2D, |
| COUPLE, |
| FIR, |
| |
| // |
| // Loop Subset B: "Basic" Loops. |
| // They are implemented in runB<variant>Loops.cxx files. |
| // |
| INIT3, |
| MULADDSUB, |
| IF_QUAD, |
| TRAP_INT, |
| |
| // |
| // Loop Subset C: Loops from older Livermore Loops in "C" suite. |
| // They are implemented in runC<variant>Loops.cxx files. |
| // |
| HYDRO_1D, |
| ICCG, |
| INNER_PROD, |
| BAND_LIN_EQ, |
| TRIDIAG_ELIM, |
| EOS, |
| ADI, |
| INT_PREDICT, |
| DIFF_PREDICT, |
| FIRST_SUM, |
| FIRST_DIFF, |
| PIC_2D, |
| PIC_1D, |
| HYDRO_2D, |
| GEN_LIN_RECUR, |
| DISC_ORD, |
| MAT_X_MAT, |
| PLANCKIAN, |
| IMP_HYDRO_2D, |
| FIND_FIRST_MIN, |
| |
| NUM_LOOP_KERNELS // Keep this one last and NEVER comment out (!!) |
| |
| }; |
| |
| |
| // |
| // Enumeration defining unique id for each loop VARIANT in suite. |
| // |
| // IMPORTANT: Generally, this should not need modification unless |
| // new loop variants are added to the suite. |
| // |
| enum LoopVariantID { |
| // |
| // These variants define LCALS benchmark |
| // |
| RAW, |
| RAW_OMP, |
| FORALL_LAMBDA, |
| FORALL_LAMBDA_OMP, |
| |
| #if defined(LCALS_DO_MISC) |
| |
| // |
| // These variants are used in miscellaneous LCALS studies |
| // |
| FORALL_HYBRID_LAMBDA, |
| #if 0 // THESE ARE NOT AVAILABLE YET!!! |
| FORALL_HYBRID_LAMBDA_OMP, |
| #endif |
| FORALL_FUNCTOR, |
| FORALL_FUNCTOR_OMP, |
| #if 0 // THESE ARE NOT AVAILABLE YET!!! |
| FORALL_HYBRID_FUNCTOR, |
| FORALL_HYBRID_FUNCTOR_OMP, |
| #endif |
| RAW_FUNC, |
| FORALL_LAMBDA_TYPEFIX, |
| FORALL_LAMBDA_OMP_TYPEFIX, |
| FORALL_HYBRID_LAMBDA_TYPEFIX, |
| |
| #endif // if LCALS_DO_MISC |
| |
| }; |
| |
| |
| // |
| // Enumeration defining possible loop lengths to run. |
| // |
| enum LoopLength { |
| |
| LONG = 0, |
| MEDIUM, |
| SHORT, |
| |
| NUM_LENGTHS // Keep this one last (!!) |
| |
| }; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // The following macro constants define which loop VARIANTS can be compiled |
| // (and potentially) run for a given compiler. |
| // |
| // NOTE: The Makefile sets the LCALS_COMPILER_* macro constant. |
| // |
| // --> IMPORTANT: Actual selection of which loop variants are run is done |
| // in main.cxx via the vector 'run_variants'. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| #if defined(LCALS_COMPILER_ICC) |
| // |
| // Configuration options for Intel compilers |
| // |
| |
| #define COMPILE_RAW_VARIANTS |
| #define COMPILE_LAMBDA_VARIANTS |
| #define COMPILE_FUNCTOR_VARIANTS |
| #define COMPILE_OMP_VARIANTS |
| |
| |
| #elif defined(LCALS_COMPILER_GNU) |
| // |
| // Configuration options for GNU compilers |
| // |
| |
| #define COMPILE_RAW_VARIANTS |
| #define COMPILE_LAMBDA_VARIANTS |
| #define COMPILE_FUNCTOR_VARIANTS |
| #define COMPILE_OMP_VARIANTS |
| |
| |
| #elif defined(LCALS_COMPILER_XLC12) |
| // |
| // Configuration options for IBM xlC compilers |
| // |
| |
| // |
| // xlC compilers DO NOT support lambda functions currently!! |
| // |
| #define COMPILE_RAW_VARIANTS |
| #undef COMPILE_LAMBDA_VARIANTS |
| #define COMPILE_FUNCTOR_VARIANTS |
| #define COMPILE_OMP_VARIANTS |
| |
| |
| #elif defined(LCALS_COMPILER_CLANG) |
| // |
| // Configuration options for clang compilers |
| // |
| |
| // |
| // Clang compilers DO NOT support OpenMP currently!! |
| // |
| #define COMPILE_RAW_VARIANTS |
| #define COMPILE_LAMBDA_VARIANTS |
| #define COMPILE_FUNCTOR_VARIANTS |
| #undef COMPILE_OMP_VARIANTS |
| |
| |
| #else |
| #error LCALS compiler is undefined! |
| |
| #endif |
| |
| |
| // |
| // The following macro constants are used to turn on/off compilation of |
| // individual loop KERNELS in suite. Names are consistent with LoopID |
| // enum above. |
| // |
| |
| #if defined (LCALS_DO_OMP_ONLY) |
| // |
| // Only these loops have OpenMP implementations. The imlementations are |
| // found in runOMP<variant>Loops.cxx files. |
| // |
| |
| // Loop Subset A: Loops extracted from LLNL app codes. |
| #define COMPILE_PRESSURE_CALC |
| #define COMPILE_PRESSURE_CALC_ALT |
| #define COMPILE_ENERGY_CALC |
| #define COMPILE_ENERGY_CALC_ALT |
| #define COMPILE_VOL3D_CALC |
| #define COMPILE_DEL_DOT_VEC_2D |
| #define COMPILE_COUPLE |
| #define COMPILE_FIR |
| |
| // Loop Subset B: "Basic" Loops. |
| #define COMPILE_INIT3 |
| #define COMPILE_MULADDSUB |
| #define COMPILE_IF_QUAD |
| #define COMPILE_TRAP_INT |
| |
| // Loop Subset C: Loops from older Livermore Loops in "C" suite. |
| #define COMPILE_PIC_2D |
| |
| #else // compile all loop kernels |
| // |
| // Loop Subset A: Loops extracted from LLNL app codes. |
| // They are implemented in runA<variant>Loops.cxx files. |
| // |
| #define COMPILE_PRESSURE_CALC |
| #define COMPILE_PRESSURE_CALC_ALT |
| #define COMPILE_ENERGY_CALC |
| #define COMPILE_ENERGY_CALC_ALT |
| #define COMPILE_VOL3D_CALC |
| #define COMPILE_DEL_DOT_VEC_2D |
| #define COMPILE_COUPLE |
| #define COMPILE_FIR |
| |
| // |
| // Loop Subset B: "Basic" Loops. |
| // They are implemented in runB<variant>Loops.cxx files. |
| // |
| #define COMPILE_INIT3 |
| #define COMPILE_MULADDSUB |
| #define COMPILE_IF_QUAD |
| #define COMPILE_TRAP_INT |
| |
| // |
| // Loop Subset C: Loops from older Livermore Loops in "C" suite. |
| // They are implemented in runLCK<variant>Loops.cxx files. |
| // |
| #define COMPILE_HYDRO_1D |
| #define COMPILE_ICCG |
| #define COMPILE_INNER_PROD |
| #define COMPILE_BAND_LIN_EQ |
| #define COMPILE_TRIDIAG_ELIM |
| #define COMPILE_EOS |
| #define COMPILE_ADI |
| #define COMPILE_INT_PREDICT |
| #define COMPILE_DIFF_PREDICT |
| #define COMPILE_FIRST_SUM |
| #define COMPILE_FIRST_DIFF |
| #define COMPILE_PIC_2D |
| #define COMPILE_PIC_1D |
| #define COMPILE_HYDRO_2D |
| #define COMPILE_GEN_LIN_RECUR |
| #define COMPILE_DISC_ORD |
| #define COMPILE_MAT_X_MAT |
| #define COMPILE_PLANCKIAN |
| #define COMPILE_IMP_HYDRO_2D |
| #define COMPILE_FIND_FIRST_MIN |
| |
| #endif |
| |
| |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // Structure holding double arrays and scalars used in loops. |
| // |
| // Note: These are initialized in allocateLoopData(). |
| // |
| /////////////////////////////////////////////////////////////////// |
| |
| struct LoopData |
| { |
| |
| // |
| // Structures to hold data for easy reinitialization |
| // (useful for verifying result checksums, etc.) |
| // |
| struct RealArray |
| { |
| int id; |
| Real_ptr data; |
| Index_type len; |
| }; |
| |
| struct IndxArray |
| { |
| int id; |
| Index_type* data; |
| Index_type len; |
| }; |
| |
| struct ComplexArray |
| { |
| int id; |
| Complex_ptr data; |
| Index_type len; |
| }; |
| |
| |
| Index_type max_loop_length; |
| |
| // |
| // Static values indicating number of data arrays |
| // of various forms used in loop suite. |
| // |
| // NOTE: These number may need to change to accomodate new loops. |
| // Also, other arrays may need to be added. |
| // |
| static const unsigned s_num_1D_Real_arrays = 16; |
| static const unsigned s_num_1D_Nx4_Real_arrays = 2; |
| static const unsigned s_num_1D_Indx_arrays = 5; |
| static const unsigned s_num_1D_Complex_arrays = 5; |
| |
| static const unsigned s_num_2D_Nx25_Real_arrays = 4; |
| static const unsigned s_num_2D_7xN_Real_arrays = 11; |
| static const unsigned s_num_2D_64x64_Real_arrays = 1; |
| |
| static const unsigned s_num_3D_2xNx4_Real_arrays = 3; |
| |
| static const unsigned s_num_Real_scalars = 10; |
| |
| // |
| // NOTE: To see how the following data structures are related, |
| // please see the routine allocateLoopData() in the |
| // file LCALSSuite.cxx. |
| // |
| // The reason that we hold on to the same data in two |
| // different ways is two-fold: |
| // 1) The first set of arrays below makes it easy to |
| // access pointers to data based on what is used in |
| // each loop kernel; e.g., arrays of variaous dimensions. |
| // 2) The second set of arrays makes it easy to process |
| // arrays for (re)initialization and checksum |
| // computation to verify results; e.g., we simply |
| // iterate through 1-dim arrays without having to |
| // know their lengths, if they are really being used |
| // as 2- or 3-dimensional arrays, for example. |
| // |
| |
| // |
| // Data arrays and scalars used in loop execution. |
| // |
| Real_ptr array_1D_Real[s_num_1D_Real_arrays]; |
| Real_ptr array_1D_Nx4_Real[s_num_1D_Nx4_Real_arrays]; |
| Index_type* array_1D_Indx[s_num_1D_Indx_arrays]; |
| Complex_ptr array_1D_Complex[s_num_1D_Complex_arrays]; |
| |
| Real_ptr* array_2D_Nx25_Real[s_num_2D_Nx25_Real_arrays]; |
| Real_ptr* array_2D_7xN_Real[s_num_2D_7xN_Real_arrays]; |
| Real_ptr* array_2D_64x64_Real[s_num_2D_64x64_Real_arrays]; |
| |
| Real_ptr** array_3D_2xNx4_Real[s_num_3D_2xNx4_Real_arrays]; |
| |
| Real_type scalar_Real[s_num_Real_scalars]; |
| |
| // |
| // Arrays of structs holding data arrays used for data initialization |
| // and checksum verification. |
| // |
| RealArray RealArray_1D[s_num_1D_Real_arrays]; |
| RealArray RealArray_1D_Nx4[s_num_1D_Nx4_Real_arrays]; |
| IndxArray IndxArray_1D[s_num_1D_Indx_arrays]; |
| ComplexArray ComplexArray_1D[s_num_1D_Complex_arrays]; |
| |
| RealArray RealArray_2D_Nx25[s_num_2D_Nx25_Real_arrays]; |
| RealArray RealArray_2D_7xN[s_num_2D_7xN_Real_arrays]; |
| RealArray RealArray_2D_64x64[s_num_2D_64x64_Real_arrays]; |
| |
| RealArray RealArray_3D_2xNx4[s_num_3D_2xNx4_Real_arrays]; |
| |
| RealArray RealArray_scalars; |
| |
| }; |
| |
| // |
| // Routine to access data structure that holds data needed to execute loops. |
| // |
| LoopData& getLoopData(); |
| |
| |
| // |
| // Routine that generates vector of loop variant names string |
| // from vector of LoopVariantID enum values. |
| // |
| std::vector<std::string> getVariantNames( |
| const std::vector<LoopVariantID>& lvids); |
| |
| // |
| // Routine that maps LoopVariantID enum value (used in main to help |
| // insure correctness) to string (used in loop framework for flexibility). |
| // |
| std::string getVariantName(LoopVariantID lvid); |
| |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // Routines to define how loop suite will be run and |
| // to set up data for loop suite. |
| // |
| ////////////////////////////////////////////////////////////////// |
| |
| // |
| // Routines to define specific details about how to run loop suite. |
| // |
| // Note: Individual loop lengths and sampling parameters |
| // are defined in this routine. |
| // |
| void defineLoopSuiteRunInfo(const std::vector<LoopVariantID>& run_variants, |
| bool run_loop[], |
| double sample_frac, |
| double loop_length_factor ); |
| |
| |
| // |
| // Routines to allocate and initialize arrays (and scalars) for |
| // loops in suite and to free those arrays when done. |
| // |
| void allocateLoopData(); |
| void freeLoopData(); |
| |
| |
| // |
| // Routines to initialize and finalize loop data, statistics, timers, etc. |
| // |
| // Each of these routines must be called before and after the execution |
| // of each loop. |
| // |
| void loopInit(unsigned iloop, LoopStat& stat); |
| void loopInit(unsigned iloop); //, LoopStat& stat); |
| // |
| void loopFinalize(unsigned iloop, LoopStat& stat, LoopLength ilength); |
| |
| |
| // |
| // Routines to run reference loops for figure of merit (FOM) calculations. |
| // |
| void defineReferenceLoopRunInfo(); |
| void computeReferenceLoopTimes(); |
| |
| // |
| // Routine called in main to execute loops corresponding to given |
| // variant ID and length. The run_loop boolean array indicates which |
| // loop kernels in suite to execute |
| // |
| void runLoopVariant( LoopVariantID lvid, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| |
| // |
| // Routines to run specific loop variants for suite. |
| // |
| // THESE SHOULD NOT BE CALLED BY ROUTINE ABOVE, NOT DIRECTLY!!! |
| // |
| // loop_stats is vector of LoopStat objects corresponding to loop variant. |
| // run_loop boolean array indicates which loop kernels in suite to execute. |
| // ilength indicates which loop length to run (see LoopLength enum). |
| // |
| void runARawLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runBRawLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runCRawLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| void runARawFuncLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runBRawFuncLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runCRawFuncLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| void runOMPRawLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| |
| void runAForallLambdaLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runBForallLambdaLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runCForallLambdaLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runOMPForallLambdaLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| void runAForallLambdaLoops_TYPEFIX( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runBForallLambdaLoops_TYPEFIX( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runCForallLambdaLoops_TYPEFIX( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runOMPForallLambdaLoops_TYPEFIX( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| |
| void runAForallFunctorLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runBForallFunctorLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runCForallFunctorLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runOMPForallFunctorLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| void runAForallHybridLambdaLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runBForallHybridLambdaLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runCForallHybridLambdaLoops( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| void runAForallHybridLambdaLoops_TYPEFIX( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runBForallHybridLambdaLoops_TYPEFIX( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| void runCForallHybridLambdaLoops_TYPEFIX( std::vector<LoopStat>& loop_stats, |
| bool run_loop[], |
| LoopLength ilength ); |
| |
| // |
| // Recursively construct directories based on a relative or |
| // absolute path name. Return true if directory created |
| // successfully, else false. |
| // |
| bool recursiveMkdir(const std::string& path); |
| |
| |
| |
| |
| #endif // closing endif for header file include guard |
