//
// 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 ;
}