[test-suite] Adding LCALS (Livermore Compiler Analysis Loop Suite) loop kernels to test suite.

[homerdin]

Summary

These changes are dependent on the changes purposed in https://reviews.llvm.org/D43314 and https://reviews.llvm.org/D43316.

This adds parts of LCALS as google benchmarks to the test suite. The loop suite is partitioned into 3 subsets based on their origins.

From README-LCALS_instructions.txt:
LCALS (“Livermore Compiler Analysis Loop Suite”) is a collection of loop kernels based, in part, on historical “Livermore Loops” benchmarks (See the 1986 technical report: “The Livermore Fortran Kernels: A Computer Test of the Numerical Performance Range”, by Frank H. McMahon, UCRL-53745.).

• Subset A: Loops representative of those found in application codes. They are implemented in source files named runA<variant>Loops.cxx.
• Subset B: Basic loops that help to illustrate compiler optimization issues. They are implemented in source files named runB<variant>Loops.cxx
• Subset C: Loops extracted from "Livermore Loops coded in C" developed by Steve Langer, which were derived from the Fortran version by Frank McMahon. They are implemented in source files runC<variant>Loops.cxx

Being added are google benchmark versions of the Raw and ForeachLambda variants in the 3 sizes.

• SubsetALambdaLoops: 18 tests (6 loops x 3 sizes)
• SubsetARawLoops: 18 tests (6 loops x 3 sizes)
• SubsetBLambdaLoops: 12 tests (4 loops x 3 sizes)
• SubsetBRawLoops: 12 tests (4 loops x 3 sizes)
• SubsetCLambdaLoops: 60 tests (20 loops x 3 sizes)
• SubsetCRawLoops: 60 tests (20 loops x 3 sizes)

When run on Intel(R) Xeon(R) CPU E5-2699 v4 @ 2.20GHz (Haswell):

• SubsetA takes around 22 seconds (18 tests reported).
• SubsetB takes around 16 seconds (12 tests reported).
• SubsetC takes around 61 seconds (60 tests reported).

The machine being used should not affect the runtime of the tests by much as the benchmark library will adjust the number of iterations up or down. There are several ways I can adjust the overall run time, but as this will be reporting multiple results from each executable I was unsure what the expectation would be.

[homerdin]

Include full context

[MatzeB]

• You should double check whether you really need to repeat the lit.local.cfg changes in each directory.
• I haven't actually tried compiling/running the benchmark but the changes LGTM.

MicroBenchmarks/LCALS/SubsetCRawLoops/lit.local.cfg

1–7 ↗

(On Diff #134438)

It's enough to have this at the toplevel /Microbenchmark directory I think, and you shouldn't need to repeat it for each subdirectory, is it not?

[homerdin]

Ya, just having the lit.local.cfg in /Microbenchmark will work. See inline.

MicroBenchmarks/LCALS/SubsetCRawLoops/lit.local.cfg

1–7 ↗

(On Diff #134438)

Tested it and you're right, everything works with it in the /Microbenchmark directory so long as the subdirectory ones are removed.

microbenchmark.py raises an exception if there are both. So I added the lit.local.cfg in /Microbenchmark in https://reviews.llvm.org/D43316 so nothing breaks in the XRay tests. Would be better to commit that change first anyways, cause without it these tests produce 1 big number.

# We need stdout outself to get the benchmark csv data.
if cmd.stdout is not None:
    raise Exception("Rerouting stdout not allowed for microbenchmarks")

[homerdin]

Updated to Remove lit.local.cfg files. Realizing I added the add_subdirectory(LCALS) in https://reviews.llvm.org/D43316 alongside the lit.local.cfg

LICENSE.TXT

 
 The following pieces of software have additional or alternate copyrights,
 licenses, and/or restrictions:
 
 Program             Directory
 -------             ---------
 Autoconf:           llvm-test/autoconf
 Benchmark:          llvm-test/libs/benchmark-1.1.0
+LCALS:              llvm-test/MicroBenchmarks/LCALS
 Burg:               llvm-test/MultiSource/Applications/Burg
 Aha:                llvm-test/MultiSource/Applications/aha
 SGEFA:              llvm-test/MultiSource/Applications/sgefa
 SIOD:               llvm-test/MultiSource/Applications/siod
 Spiff:              llvm-test/MultiSource/Applications/spiff
 D:                  llvm-test/MultiSource/Applications/d
 Lambda:             llvm-test/MultiSource/Applications/lambda-0.1.3
 hbd:                llvm-test/MultiSource/Applications/hbd

MicroBenchmarks/CMakeLists.txt

 file(COPY lit.local.cfg DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 
 add_subdirectory(libs)
 add_subdirectory(XRay)
+add_subdirectory(LCALS)

MicroBenchmarks/LCALS/CMakeLists.txt

+add_subdirectory(SubsetARawLoops)
+add_subdirectory(SubsetALambdaLoops)
+add_subdirectory(SubsetBRawLoops)
+add_subdirectory(SubsetBLambdaLoops)
+add_subdirectory(SubsetCRawLoops)
+add_subdirectory(SubsetCLambdaLoops)

MicroBenchmarks/LCALS/LCALSParams.hxx

+//
+// See README-LCALS_license.txt for access and distribution restrictions
+//
+
+//
+// Header file with macros and constants for data types, execution,
+// timing options, etc. used in LCALS
+//
+
+#ifndef LCALSParams_HXX
+#define LCALSParams_HXX
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// This file contains various parameters that control compilation and some
+// aspects of execution of the loop suite.  The macro constants and typedefs in
+// this file provide the ability to make changes that will propagate 
+// throughout the LCALS code when compiled.  Parameters in this file specify:
+//
+// o Timing and checksum output options
+// o Scalar data types and pointer types (e.g., restrict & alignment properties)
+// o Loop variants that can be built by each compiler 
+// o Loop execution policies for traversal templates (used with loop bodies
+//   represented as lambda expressions or functors)
+//
+//
+// IMPORTANT: MANY OF THE MACROS CONTROLLING THESE OPTIONS
+//            ARE SET IN THE LCALS_rules.mk FILE.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(LCALS_VERIFY_CHECKSUM_ABBREVIATED)
+static const int num_checksum_suite_passes = 1;
+static const int num_checksum_samples = 3;
+#endif
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Define/undefine macro constants and other paramters used to control data
+// type definitions.
+// 
+////////////////////////////////////////////////////////////////////////////////
+
+//
+//  Parameterized scalar data types.
+//
+
+typedef int     Index_type;
+
+#if defined(LCALS_USE_DOUBLE)
+///
+typedef double  Real_type;
+
+#elif defined(LCALS_USE_FLOAT)
+///
+typedef float  Real_type;
+
+
+#else
+#error LCALS Real_type is undefined!
+
+#endif
+
+#include<complex>
+typedef std::complex<Real_type> Complex_type;
+
+//
+// Use volatile keyword on loop variable for sampling loops to prevent 
+// compilers from potentially optimizing out loops where result is
+// identical for each sample iteration.
+// 
+typedef volatile int SampIndex_type;
+//
+// Use unsigned long for loop variable used in loops to flush cache to
+// allow for large caches with size possibly bigger than what int can adderss.
+// 
+typedef unsigned long CacheIndex_type;
+
+//
+//  Floating point array data alignmnent value.  Typically, same as
+//  SIMD vector width.
+//
+const int LCALS_DATA_ALIGN = 32;
+
+
+//
+//  Compiler-specific definitions for inline directives, data alignment
+//  intrinsics, and SIMD vector pragmas
+//
+//  Variables for compiler instrinsics, directives, typedefs
+//
+//     LCALS_INLINE - macro to enforce method inlining
+//
+//     LCALS_ALIGN_DATA(<variable>) - macro to express alignment of data,
+//                              loop bounds, etc.
+//
+//     LCALS_SIMD - macro to express SIMD vectorization pragma to force
+//                 loop vectorization
+//
+
+#if defined(LCALS_COMPILER_ICC)
+//
+// Configuration options for Intel compilers
+//
+
+#define LCALS_INLINE inline  __attribute__((always_inline))
+
+#if __ICC < 1300  // use alignment intrinsic
+#define LCALS_ALIGN_DATA(d) __assume_aligned(d, LCALS_DATA_ALIGN)
+#else
+#define LCALS_ALIGN_DATA(d)  // TODO: Define this...
+#endif
+
+#define LCALS_SIMD  // TODO: Define this...
+
+
+#elif defined(LCALS_COMPILER_GNU)
+//
+// Configuration options for GNU compilers
+//
+
+#define LCALS_INLINE inline  __attribute__((always_inline))
+
+#define LCALS_ALIGN_DATA(d) __builtin_assume_aligned(d, LCALS_DATA_ALIGN)
+
+#define LCALS_SIMD  // TODO: Define this...
+
+
+#elif defined(LCALS_COMPILER_XLC12)
+//
+// Configuration options for xlc v12 compiler (i.e., bgq/sequoia).
+//
+
+#define LCALS_INLINE inline  __attribute__((always_inline))
+
+#define LCALS_ALIGN_DATA(d) __alignx(LCALS_DATA_ALIGN, d)
+
+//#define LCALS_SIMD  _Pragma("simd_level(10)")
+#define LCALS_SIMD   // TODO: Define this...
+
+
+#elif defined(LCALS_COMPILER_CLANG)
+//
+// Configuration options for clang compilers
+//
+
+#define LCALS_INLINE inline  __attribute__((always_inline))
+
+#define LCALS_ALIGN_DATA(d) // TODO: Define this...
+
+#define LCALS_SIMD  // TODO: Define this...
+
+
+#else
+#error LCALS compiler is undefined!
+
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// The following items include some setup items for pointer type definitions 
+// that follow.
+// 
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(LCALS_COMPILER_ICC)
+//
+// alignment attribute supported for versions > 12
+//
+#if __ICC >= 1300
+typedef Real_type* __restrict__ __attribute__((align_value(LCALS_DATA_ALIGN))) TDRAReal_ptr;
+
+typedef const Real_type* __restrict__ __attribute__((align_value(LCALS_DATA_ALIGN))) const_TDRAReal_ptr;
+#endif
+
+
+#elif defined(LCALS_COMPILER_GNU)
+//
+// Nothing here for now because alignment attribute is not working...
+//
+
+
+#elif defined(LCALS_COMPILER_XLC12)
+extern
+#ifdef __cplusplus
+"builtin"
+#endif
+void __alignx(int n, const void* addr);
+
+
+#elif defined(LCALS_COMPILER_CLANG)
+typedef Real_type aligned_real_type __attribute__((aligned (LCALS_DATA_ALIGN)));
+typedef aligned_real_type* __restrict__ TDRAReal_ptr;
+
+typedef const aligned_real_type* __restrict__ const_TDRAReal_ptr;
+
+#else
+#error LCALS compiler is undefined!
+
+#endif
+
+
+#if defined(LCALS_USE_PTR_CLASS)
+/*!
+ ******************************************************************************
+ *
+ * \brief Class representing a restricted Real_type const pointer.
+ *
+ ******************************************************************************
+ */
+class ConstRestrictRealPtr
+{
+public:
+
+   ///
+   /// Ctors and assignment op.
+   ///
+
+   ConstRestrictRealPtr() : dptr(0) { ; }
+
+   ConstRestrictRealPtr(const Real_type* d) : dptr(d) { ; }
+
+   ConstRestrictRealPtr& operator=(const Real_type* d) {
+      ConstRestrictRealPtr copy(d);
+      std::swap(dptr, copy.dptr);
+      return *this;
+   }
+
+   ///
+   /// NOTE: Using compiler-generated copy ctor, dtor, and copy assignment op.
+   ///
+
+   ///
+   ///  Implicit conversion operator to bare const pointer.
+   ///
+   operator const Real_type*() { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to bare const pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   const Real_type* get() const { return dptr; }
+
+   ///
+   /// Bracket operator.
+   ///
+   const Real_type& operator [] (Index_type i) const
+   {
+      return( (const Real_type* __restrict__) dptr)[i];
+   }
+
+   ///
+   /// + operator for pointer arithmetic.
+   ///
+   const Real_type* operator+ (Index_type i) const { return dptr+i; }
+
+private:
+   const Real_type* dptr;
+};
+
+
+/*!
+ ******************************************************************************
+ *
+ * \brief Class representing a restricted Real_type (non-const) pointer.
+ *
+ ******************************************************************************
+ */
+class RestrictRealPtr
+{
+public:
+
+   ///
+   /// Ctors and assignment op.
+   ///
+
+   RestrictRealPtr() : dptr(0) { ; }
+
+   RestrictRealPtr(Real_type* d) : dptr(d) { ; }
+
+   RestrictRealPtr& operator=(Real_type* d) { 
+      RestrictRealPtr copy(d);
+      std::swap(dptr, copy.dptr);
+      return *this; 
+   }
+
+   ///
+   /// NOTE: Using compiler-generated copy ctor, dtor, and copy assignment op.
+   ///
+
+   ///
+   ///  Implicit conversion operator to (non-const) bare pointer.
+   ///
+   operator Real_type*() { return dptr; }
+
+   ///
+   ///  Implicit conversion operator to const bare pointer.
+   ///
+   operator const Real_type*() const { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to (non-const) bare pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   Real_type* get() { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to const bare pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   const Real_type* get() const { return dptr; }
+
+   ///
+   ///  Operator that enables implicit conversion from RestrictRealPtr to
+   ///  RestrictRealConstPtr.
+   ///
+   operator ConstRestrictRealPtr ()
+      { return ConstRestrictRealPtr(dptr); }
+
+
+   ///
+   /// Bracket operator.
+   ///
+   Real_type& operator [] (Index_type i)
+   {
+      return( (Real_type* __restrict__) dptr)[i];
+   }
+
+   ///
+   /// + operator for (non-const) pointer arithmetic.
+   ///
+   Real_type* operator+ (Index_type i) { return dptr+i; }
+
+   ///
+   /// + operator for const pointer arithmetic.
+   ///
+   const Real_type* operator+ (Index_type i) const { return dptr+i; }
+
+private:
+   Real_type* dptr;
+};
+
+
+/*!
+ ******************************************************************************
+ *
+ * \brief Class representing a restricted aligned Real_type const pointer.
+ *
+ ******************************************************************************
+ */
+class ConstRestrictAlignedRealPtr
+{
+public:
+
+   ///
+   /// Ctors and assignment op.
+   ///
+
+   ConstRestrictAlignedRealPtr() : dptr(0) { ; }
+
+   ConstRestrictAlignedRealPtr(const Real_type* d) : dptr(d) { ; }
+
+   ConstRestrictAlignedRealPtr& operator=(const Real_type* d) {
+      ConstRestrictAlignedRealPtr copy(d);
+      std::swap(dptr, copy.dptr);
+      return *this;
+   }
+
+   ///
+   /// NOTE: Using compiler-generated copy ctor, dtor, and copy assignment op.
+   ///
+
+   ///
+   ///  Implicit conversion operator to bare const pointer.
+   ///
+   operator const Real_type*() { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to bare const pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   const Real_type* get() const { return dptr; }
+
+   ///
+   /// Compiler-specific bracket operators.
+   ///
+#if defined(LCALS_COMPILER_ICC)
+   ///
+   const Real_type& operator [] (Index_type i) const
+   {
+#if __ICC < 1300 // use alignment intrinsic
+      LCALS_ALIGN_DATA(dptr);
+      return( (const Real_type* __restrict__) dptr)[i];
+#else // use alignment attribute
+      return( (const_TDRAReal_ptr) dptr)[i];
+#endif
+   }
+
+
+#elif defined(LCALS_COMPILER_GNU)
+   ///
+   const Real_type& operator [] (Index_type i) const
+   {
+#if 1 // NOTE: alignment instrinsic not available for older GNU compilers
+      return( (const Real_type* __restrict__) LCALS_ALIGN_DATA(dptr) )[i];
+#else
+      return( (const Real_type* __restrict__) dptr)[i];
+#endif
+   }
+
+
+#elif defined(LCALS_COMPILER_XLC12)
+   const Real_type& operator [] (Index_type i) const
+   {
+      LCALS_ALIGN_DATA(dptr);
+      return( (const Real_type* __restrict__) dptr)[i];
+   }
+
+
+#elif defined(LCALS_COMPILER_CLANG)
+   const Real_type& operator [] (Index_type i) const
+   {
+      return( (const_TDRAReal_ptr) dptr)[i];
+   }
+
+
+#else
+#error LCALS compiler macro is undefined!
+
+#endif
+
+   ///
+   /// + operator for pointer arithmetic.
+   ///
+   const Real_type* operator+ (Index_type i) const { return dptr+i; }
+
+private:
+   const Real_type* dptr;
+};
+
+
+/*!
+ ******************************************************************************
+ *
+ * \brief Class representing a restricted aligned Real_type (non-const) pointer.
+ *
+ ******************************************************************************
+ */
+class RestrictAlignedRealPtr
+{
+public:
+
+   ///
+   /// Ctors and assignment op.
+   ///
+
+   RestrictAlignedRealPtr() : dptr(0) { ; }
+
+   RestrictAlignedRealPtr(Real_type* d) : dptr(d) { ; }
+
+   RestrictAlignedRealPtr& operator=(Real_type* d) { RestrictAlignedRealPtr copy(d);
+                                                   std::swap(dptr, copy.dptr);
+                                                   return *this; }
+
+   ///
+   /// NOTE: Using compiler-generated copy ctor, dtor, and copy assignment op.
+   ///
+
+   ///
+   ///  Implicit conversion operator to (non-const) bare pointer.
+   ///
+   operator Real_type*() { return dptr; }
+
+   ///
+   ///  Implicit conversion operator to const bare pointer.
+   ///
+   operator const Real_type*() const { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to (non-const) bare pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   Real_type* get() { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to const bare pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   const Real_type* get() const { return dptr; }
+
+   ///
+   ///  Operator that enables implicit conversion from RestrictAlignedRealPtr to
+   ///  RestrictAlignedRealConstPtr.
+   ///
+   operator ConstRestrictAlignedRealPtr ()
+      { return ConstRestrictAlignedRealPtr(dptr); }
+
+
+   ///
+   /// Compiler-specific bracket operators.
+   ///
+
+#if defined(LCALS_COMPILER_ICC)
+   ///
+   Real_type& operator [] (Index_type i)
+   {
+#if __ICC < 1300 // use alignment intrinsic
+      LCALS_ALIGN_DATA(dptr);
+      return( (Real_type* __restrict__) dptr)[i];
+#else // use alignment attribute
+      return( (TDRAReal_ptr) dptr)[i];
+#endif
+   }
+
+   ///
+   const Real_type& operator [] (Index_type i) const
+   {
+#if __ICC < 1300 // use alignment intrinsic
+      LCALS_ALIGN_DATA(dptr);
+      return( (Real_type* __restrict__) dptr)[i];
+#else // use alignment attribute
+      return( (TDRAReal_ptr) dptr)[i];
+#endif
+   }
+
+#elif defined(LCALS_COMPILER_GNU)
+   ///
+   Real_type& operator [] (Index_type i)
+   {
+#if 1 // NOTE: alignment instrinsic not available for older GNU compilers
+      return( (Real_type* __restrict__) LCALS_ALIGN_DATA(dptr) )[i];
+#else
+      return( (Real_type* __restrict__) dptr)[i];
+#endif
+   }
+
+   ///
+   const Real_type& operator [] (Index_type i) const
+   {
+#if 1 // NOTE: alignment instrinsic not available for older GNU compilers
+      return( (Real_type* __restrict__) LCALS_ALIGN_DATA(dptr) )[i];
+#else
+      return( (Real_type* __restrict__) dptr)[i];
+#endif
+   }
+
+
+#elif defined(LCALS_COMPILER_XLC12)
+   ///
+   Real_type& operator [] (Index_type i)
+   {
+      LCALS_ALIGN_DATA(dptr);
+      return( (Real_type* __restrict__) dptr)[i];
+   }
+
+   ///
+   const Real_type& operator [] (Index_type i) const
+   {
+      LCALS_ALIGN_DATA(dptr);
+      return( (Real_type* __restrict__) dptr)[i];
+   }
+
+
+#elif defined(LCALS_COMPILER_CLANG)
+   ///
+   Real_type& operator [] (Index_type i)
+   {
+      return( (TDRAReal_ptr) dptr)[i];
+   }
+
+   ///
+   const Real_type& operator [] (Index_type i) const
+   {
+      return( (TDRAReal_ptr) dptr)[i];
+   }
+
+
+#else
+#error LCALS compiler macro is undefined!
+
+#endif
+
+   ///
+   /// + operator for (non-const) pointer arithmetic.
+   ///
+   Real_type* operator+ (Index_type i) { return dptr+i; }
+
+   ///
+   /// + operator for const pointer arithmetic.
+   ///
+   const Real_type* operator+ (Index_type i) const { return dptr+i; }
+
+private:
+   Real_type* dptr;
+};
+
+
+/*!
+ ******************************************************************************
+ *
+ * \brief Class representing a restricted Complex_type const pointer.
+ *
+ ******************************************************************************
+ */
+class ConstRestrictComplexPtr
+{
+public:
+
+   ///
+   /// Ctors and assignment op.
+   ///
+
+   ConstRestrictComplexPtr() : dptr(0) { ; }
+
+   ConstRestrictComplexPtr(const Complex_type* d) : dptr(d) { ; }
+
+   ConstRestrictComplexPtr& operator=(const Complex_type* d) {
+      ConstRestrictComplexPtr copy(d);
+      std::swap(dptr, copy.dptr);
+      return *this;
+   }
+
+   ///
+   /// NOTE: Using compiler-generated copy ctor, dtor, and copy assignment op.
+   ///
+
+   ///
+   ///  Implicit conversion operator to bare const pointer.
+   ///
+   operator const Complex_type*() const { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to bare const pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   const Complex_type* get() const { return dptr; }
+
+   ///
+   ///  Bracket operator.
+   ///
+   const Complex_type& operator [] (Index_type i) const
+   {
+      return( (const Complex_type* __restrict__) dptr)[i];
+   }
+
+   ///
+   /// + operator for pointer arithmetic.
+   ///
+   const Complex_type* operator+ (Index_type i) const { return dptr+i; }
+
+private:
+   const Complex_type* dptr;
+};
+
+
+/*!
+ ******************************************************************************
+ *
+ * \brief Class representing a restricted Complex_type (non-const) pointer.
+ *
+ ******************************************************************************
+ */
+class RestrictComplexPtr
+{
+public:
+
+   ///
+   /// Ctors and assignment op.
+   ///
+
+   RestrictComplexPtr() : dptr(0) { ; }
+
+   RestrictComplexPtr(Complex_type* d) : dptr(d) { ; }
+
+   RestrictComplexPtr& operator=(Complex_type* d) { RestrictComplexPtr copy(d);
+                                                    std::swap(dptr, copy.dptr);
+                                                    return *this; }
+
+   ///
+   /// NOTE: Using compiler-generated copy ctor, dtor, and copy assignment op.
+   ///
+
+   ///
+   ///  Implicit conversion operator to (non-const) bare pointer.
+   ///
+   operator Complex_type*() { return dptr; }
+
+   ///
+   ///  Implicit conversion operator to const bare pointer.
+   ///
+   operator const Complex_type*() const { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to (non-const) bare pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   Complex_type* get() { return dptr; }
+
+   ///
+   ///  "Explicit conversion operator" to const bare pointer,
+   ///  consistent with boost shared ptr.
+   ///
+   const Complex_type* get() const { return dptr; }
+
+   ///
+   ///  Operator that enables implicit conversion from RestrictComplexPtr to
+   ///  RestrictComplexConstPtr.
+   ///
+   operator ConstRestrictComplexPtr ()
+      { return ConstRestrictComplexPtr(dptr); }
+
+   ///
+   ///  (Non-const) bracket operator.
+   ///
+   Complex_type& operator [] (Index_type i)
+   {
+      return( (Complex_type* __restrict__) dptr)[i];
+   }
+
+   ///
+   ///  Const bracket operator.
+   ///
+   const Complex_type& operator [] (Index_type i) const
+   {
+      return( (Complex_type* __restrict__) dptr)[i];
+   }
+
+   ///
+   /// + operator for (non-const) pointer arithmetic.
+   ///
+   Complex_type* operator+ (Index_type i) { return dptr+i; }
+
+   ///
+   /// + operator for const pointer arithmetic.
+   ///
+   const Complex_type* operator+ (Index_type i) const { return dptr+i; }
+
+private:
+   Complex_type* dptr;
+};
+#endif  // defined(LCALS_USE_PTR_CLASS)
+
+
+/*
+ ******************************************************************************
+ *
+ * Finally, we define data pointer types based on definitions above and
+ * -D value given at compile time.
+ *
+ ******************************************************************************
+ */
+#if defined(LCALS_USE_BARE_PTR)
+typedef Real_type* Real_ptr;
+typedef const Real_type* const_Real_ptr;
+typedef Complex_type* Complex_ptr;
+typedef const Complex_type* const_Complex_ptr;
+
+typedef Real_type* UnalignedReal_ptr;
+typedef const Real_type* const_UnalignedReal_ptr;
+
+
+#elif defined(LCALS_USE_RESTRICT_PTR)
+typedef Real_type* __restrict__ Real_ptr;
+typedef const Real_type* __restrict__ const_Real_ptr;
+typedef Complex_type* __restrict__ Complex_ptr;
+typedef const Complex_type* __restrict__ const_Complex_ptr;
+
+typedef Real_type* __restrict__ UnalignedReal_ptr;
+typedef const Real_type* __restrict__ const_UnalignedReal_ptr;
+
+
+#elif defined(LCALS_USE_RESTRICT_ALIGNED_PTR)
+typedef TDRAReal_ptr Real_ptr;
+typedef const_TDRAReal_ptr const_Real_ptr;
+typedef Complex_type* __restrict__ Complex_ptr;
+typedef const Complex_type* __restrict__ const_Complex_ptr;
+
+typedef Real_type* __restrict__ UnalignedReal_ptr;
+typedef const Real_type* __restrict__ const_UnalignedReal_ptr;
+
+
+#elif defined(LCALS_USE_PTR_CLASS)
+typedef RestrictAlignedRealPtr Real_ptr;
+typedef ConstRestrictAlignedRealPtr const_Real_ptr;
+typedef RestrictComplexPtr Complex_ptr;
+typedef ConstRestrictComplexPtr const_Complex_ptr;
+
+typedef RestrictRealPtr UnalignedReal_ptr;
+typedef ConstRestrictRealPtr const_UnalignedReal_ptr;
+
+
+#else
+#error LCALS pointer type is undefined!
+
+#endif
+
+
+//
+// By default, all loop variants defined as supported in the
+// compiler-specific sections above are turned on here (for
+// both compilation and execution).
+//
+// Loop variants can be turned off via the #define/#undef macros below.
+// It's a bit cheesy, but it's simple and it works!
+//
+// Execution of individual loop variants can also be controlled
+// by modifying the strings that get added to the run_loop_variants
+// vector in main.cxx
+//
+
+
+//
+//  Execution policies applicable to "forall" loop variants.  
+//  Traversal method templates are defined in LCALSTraversalMethods.hxx 
+//  header files.
+//
+
+// Tag struct types define available forall method execution policies
+struct seq_exec {};
+struct simd_exec {};
+struct omp_parallel_for_exec {};
+struct omp_for_nowait_exec {};
+
+// 
+// Execution policy used in (non-OpenMP) "forall" loop variants.  
+// To use another policy in all such loops, change this typedef.
+//
+typedef simd_exec exec_policy;
+
+
+
+#endif  // closing endif for header file include guard

MicroBenchmarks/LCALS/LCALSStats.hxx

+//
+// See README-LCALS_license.txt for access and distribution restrictions
+//
+
+//
+// Header file defining routines and structures to gather and report
+// LCALS loop suite execution information.
+//
+
+#ifndef LCALSStats_HXX
+#define LCALSStats_HXX
+
+#include "LCALSParams.hxx"
+
+#include <vector>
+#include <map>
+#include <string>
+#include <iostream>
+
+#if defined(LCALS_USE_CYCLE)
+#include "cycle.h"
+typedef ticks LoopTime;
+
+#elif defined(LCALS_USE_CLOCK)
+#include <time.h>
+typedef clock_t LoopTime;
+
+#else
+#error LCALS_TIMER_TYPE is undefined!
+
+#endif
+
+
+class LoopStat;
+
+//
+// Loop timing should follow the implementation described here.
+// (See files containing loop implementations for details.)
+//
+// 1) Execute loop (identified by integer variable "iloop"):
+//
+//    LoopTimer ltimer;
+//
+//    flushCache(); 
+//
+//    TIMER_START(ltimer);
+//
+//        ...CODE FOR LOOP "iloop" GOES HERE...
+//
+//    TIMER_STOP(ltimer);
+//
+// 2) At some point after loop is run, but before next loop in file is run, 
+//    copy timing information to appropriate loop stat object:
+//
+//    copyTimers(loop_stat, ilength, ltimer);
+//
+
+struct LoopTimer
+{
+   LoopTime start;
+   LoopTime stop;
+   bool was_run;
+
+   LoopTimer() : start(0), stop(0), was_run(false) { ; }
+};
+
+void flushCache();
+void copyTimer(LoopStat& loop_stat, int ilength, 
+               const LoopTimer& loop_timer);
+
+#if defined(LCALS_USE_CYCLE)
+
+#define TIMER_START(lt)  lt.start = getticks(); 
+#define TIMER_STOP(lt)  lt.stop = getticks(); \
+
+#elif defined(LCALS_USE_CLOCK)
+
+#define TIMER_START(lt) lt.start = clock();
+#define TIMER_STOP(lt)  lt.stop = clock(); \
+                        lt.was_run = true;
+
+#else
+#error LCALS_TIMER_TYPE is undefined!
+
+#endif
+
+
+
+//////////////////////////////////////////////////////////////////
+//
+//  Routines to set up loop data, run loops, generate output, etc.
+//
+//////////////////////////////////////////////////////////////////
+
+//
+// Forward declarations for structs defined below.
+//
+struct LoopStat;
+struct LoopSuiteRunInfo;
+
+//
+// Routines for accessing loop suite run info.
+//
+LoopSuiteRunInfo& getLoopSuiteRunInfo();
+
+
+//
+// Routine to allocate and setup basic structures used to run loop suite
+// and free them when done.
+//
+void allocateLoopSuiteRunInfo(const std::string& host_name,
+                              unsigned num_loops,
+                              unsigned num_loop_lengths,
+                              unsigned num_suite_passes,
+                              bool run_loop_length[],
+                              CacheIndex_type cache_size);
+void freeLoopSuiteRunInfo();
+
+
+//
+// Routine to generate loop excution timing report.
+// 
+// Also write output files if non-empty directory name is given.
+//
+void generateTimingReport(const std::vector< std::string >& run_loop_variants,
+                          const std::string& output_dirname);
+
+//
+// Routine to generate report about loop checksums.
+// 
+// Also write output files if non-empty directory name is given.
+//
+void generateChecksumReport(const std::vector< std::string >& run_loop_variants,
+                            const std::string& output_dirname);
+
+//
+// Routine to generate FOM report.
+// 
+// Also write output files if non-empty directory name is given.
+//
+void generateFOMReport(const std::vector< std::string >& run_loop_variants,
+                       const std::string& output_dirname);
+
+
+
+//////////////////////////////////////////////////////////////////
+//
+//  Structures holding parameters defining execution of loop suite 
+//  and loop timing statistic information.
+//
+//////////////////////////////////////////////////////////////////
+
+class LoopStat
+{
+public:
+
+   bool loop_is_run; 
+
+   double loop_weight;
+
+   //
+   // The following vectors are indexed by loop length ID.
+   //
+   // The second vector index for loop_run_time
+   // is number of suite pass.
+   //
+
+   std::vector< std::vector<long double> > loop_run_time;
+   std::vector< unsigned long > loop_run_count;
+
+   std::vector< long double > mean;
+   std::vector< long double > std_dev;
+   std::vector< long double > min;
+   std::vector< long double > max;
+   std::vector< long double > harm_mean;
+   std::vector< long double > meanrel2ref;
+
+   std::vector< int > loop_length;
+   std::vector< int > samples_per_pass;
+
+   std::vector< long double > loop_chksum;
+
+   explicit LoopStat(unsigned num_loop_lengths)
+   : loop_is_run(false),
+     loop_weight(0.0),
+     loop_run_time(num_loop_lengths),
+     loop_run_count(num_loop_lengths, 0),
+     mean(num_loop_lengths, 0.0),
+     std_dev(num_loop_lengths, 0.0),
+     min(num_loop_lengths, 0.0),
+     max(num_loop_lengths, 0.0),
+     harm_mean(num_loop_lengths, 0.0),
+     meanrel2ref(num_loop_lengths, 0.0),
+     loop_length(num_loop_lengths, 0),
+     samples_per_pass(num_loop_lengths, 0),
+     loop_chksum(num_loop_lengths, 0.0)
+   { ; } 
+
+   //
+   // Print routine for debugging.
+   //
+   void print(std::ostream& os) const;
+
+private:
+   //
+   // The following methods are not implemented.
+   //
+   LoopStat();
+};
+
+class LoopSuiteRunInfo
+{
+public:
+
+   std::string host_name;
+
+   //
+   // The following vectors are indexed by loop ID.
+   //
+   unsigned num_loops;
+   std::vector<std::string> loop_names;
+
+   //
+   // The following vectors are indexed by loop length ID.
+   //
+   unsigned num_loop_lengths;
+   std::vector<bool> run_loop_length;
+   std::vector<std::string> loop_length_names;
+
+   unsigned num_suite_passes;
+   double loop_samp_frac;
+
+   LoopStat ref_loop_stat;
+   //
+   // The following vectors are indexed by loop WeightGroup
+   //
+   std::vector<double> loop_weights;
+
+   //
+   // The following vectors are indexed first by loop variant 
+   // (according to order in LoopStatMap, which is the same as 
+   // run_loop_variants vector in main.cxx) and then by loop length.  
+   // So we have NUM_LENGTHS values for each variant.
+   //
+   std::vector< std::vector< int > > num_loops_run;
+   std::vector< std::vector< long double > > tot_time;
+   std::vector< std::vector< long double > > fom_rel;
+   std::vector< std::vector< long double > > fom_rate;
+
+
+   CacheIndex_type cache_flush_data_len;
+   double* cache_flush_data;
+   long double cache_flush_data_sum;
+
+   LoopSuiteRunInfo()
+   : ref_loop_stat(static_cast<unsigned>(0)),
+     num_loops(0),
+     num_loop_lengths(0),
+     num_suite_passes(0),
+     loop_samp_frac(0.0),
+     cache_flush_data_len(0),
+     cache_flush_data(0),
+     cache_flush_data_sum(0.0)
+   { ; }
+
+
+   typedef std::map< std::string, std::vector<LoopStat>* > LoopStatMap;
+
+   ~LoopSuiteRunInfo() 
+   {
+      LoopStatMap::iterator lsi = loop_test_stats.begin();
+      for (  ; lsi != loop_test_stats.end(); ++ lsi ) {
+         delete (*lsi).second; 
+      }
+   }
+
+   //
+   // Add vector of loop stats for loop test with given name.
+   //
+   void addLoopStats(const std::string& name)
+   {
+      std::vector<LoopStat>* stat_vec = new std::vector<LoopStat>();
+      loop_test_stats.insert( LoopStatMap::value_type( name, stat_vec ) );
+   }
+
+   //
+   // Return reference to vector of loop stats for loop test with given name.
+   //
+   std::vector<LoopStat>& getLoopStats( const std::string& name )
+   {
+      LoopStatMap::iterator lsi = loop_test_stats.find(name);
+      return( *( (*lsi).second ) );
+   }
+
+private:
+   //
+   // The following methods are not implemented.
+   //
+   LoopSuiteRunInfo(const LoopSuiteRunInfo&);
+   LoopSuiteRunInfo& operator=(const LoopStat&); 
+
+   LoopStatMap loop_test_stats;
+};
+
+
+#endif  // closing endif for header file include guard

MicroBenchmarks/LCALS/LCALSStats.cxx

+//
+// See README-LCALS_license.txt for access and distribution restrictions
+//
+
+//
+// Source file containing routines used to gather and report
+// performance data for LCALS suite
+//
+
+#include "LCALSStats.hxx"
+
+#include<string>
+#include<iostream>
+#include<iomanip>
+#include<sstream>
+#include<fstream>
+#include<limits>
+#include<cstdlib>
+#include<cmath>
+
+using namespace std;
+
+//
+// LoopStat print routine for debugging.
+//
+void LoopStat::print(ostream& os) const
+{
+   os << "\nLoopStat::print..." << endl;
+   os << "\tloop_is_run = " <<  loop_is_run << endl;
+   os << "\tnum loop lengths = " <<  loop_length.size() << endl;
+   for (unsigned i = 0; i < loop_length.size(); ++i) {
+      os << "\t\t ilength = " <<  i << " --> " << endl;  
+      os << "\t\t\t loop_length = " <<  loop_length[i] << endl;
+      os << "\t\t\t samples_per_pass = " <<  samples_per_pass[i] << endl;
+      os << "\t\t\t loop_run_count = " <<  loop_run_count[i] << endl;
+      if ( loop_run_count[i] > 0 ) {
+         for (unsigned j = 0; j < loop_run_time[i].size(); ++j) {
+            os << "\t\t\t\t sample time = " <<  loop_run_time[i][j] << endl;
+         }
+         os << "\t\t\t\t mean = "            <<  mean[i] << endl; 
+         os << "\t\t\t\t std_dev = "         <<  std_dev[i] << endl; 
+         os << "\t\t\t\t min = "             <<  min[i] << endl; 
+         os << "\t\t\t\t max = "             <<  max[i] << endl; 
+         os << "\t\t\t\t harm_mean = "       <<  harm_mean[i] << endl; 
+         os << "\t\t\t\t meanrel2ref = "     <<  meanrel2ref[i] << endl; 
+         os << endl;
+         for (unsigned j = 0; j < loop_run_time[i].size(); ++j) {
+            os << "\t\t\t\t sample time = " <<  loop_run_time[i][j] << endl;
+         }
+      }    
+   }
+   os << endl;
+}
+
+
+//
+// File scope data holding structures needed to execute and time loops.
+//
+static LoopSuiteRunInfo* s_loop_suite_run_info = 0;
+
+//
+// Accessor routine for suite run info.
+//
+LoopSuiteRunInfo& getLoopSuiteRunInfo() { return *s_loop_suite_run_info; }
+
+
+//
+// Define how suite will run and initialize timing structures for loops.
+//
+void allocateLoopSuiteRunInfo(const string& host_name,
+                              unsigned num_loops,
+                              unsigned num_loop_lengths,
+                              unsigned num_suite_passes,
+                              bool run_loop_length[],
+                              CacheIndex_type cache_size)
+{
+#ifdef TESTSUITE
+   cout << "\n allocateLoopSuiteRunInfo..." << endl;
+#endif
+   if ( s_loop_suite_run_info == 0 ) { 
+      s_loop_suite_run_info = new LoopSuiteRunInfo(); 
+   }
+
+   s_loop_suite_run_info->host_name = host_name;
+
+   s_loop_suite_run_info->num_loops = num_loops;
+   s_loop_suite_run_info->num_loop_lengths = num_loop_lengths;
+   s_loop_suite_run_info->num_suite_passes = num_suite_passes;
+   for (unsigned ilen = 0; ilen < num_loop_lengths; ++ilen) {
+      s_loop_suite_run_info->run_loop_length.push_back(
+                                             run_loop_length[ilen]);
+   }
+
+   //
+   // To make sure all data cache levels are flushed completely, we
+   // define a data buffer with length equal to twice given cache size.
+   //
+   s_loop_suite_run_info->cache_flush_data_len = 
+                          (cache_size*2)/sizeof(Real_type);
+   s_loop_suite_run_info->cache_flush_data = 
+      new double[s_loop_suite_run_info->cache_flush_data_len];
+   for (CacheIndex_type i = 0; 
+        i < s_loop_suite_run_info->cache_flush_data_len; ++i) {
+      s_loop_suite_run_info->cache_flush_data[i] = drand48() + 0.1;
+   }
+
+}
+
+//
+// Free data structures defining loop suite execution.
+//
+void freeLoopSuiteRunInfo()
+{
+   if ( s_loop_suite_run_info ) { 
+      if ( s_loop_suite_run_info->cache_flush_data ) {
+         delete [] s_loop_suite_run_info->cache_flush_data;
+      }
+      delete s_loop_suite_run_info; 
+      s_loop_suite_run_info = 0;
+   }
+}
+
+//////////////////////////////////////////////////////////////////
+//
+//  Routines used for loop timing...
+//
+//////////////////////////////////////////////////////////////////
+
+//
+// Flush cache before each loop is run to minimize impact of one
+// loop on another's execution.
+//
+void flushCache()
+{
+   for (CacheIndex_type i = 0; 
+        i < s_loop_suite_run_info->cache_flush_data_len; ++i) {
+      s_loop_suite_run_info->cache_flush_data_sum +=
+         s_loop_suite_run_info->cache_flush_data[i];
+   }
+   s_loop_suite_run_info->cache_flush_data_sum /=
+      s_loop_suite_run_info->cache_flush_data_len; 
+}
+
+
+//
+// Copy loop run time to LoopStat.
+//
+void copyTimer(LoopStat& loop_stat, int ilength,
+               const LoopTimer& loop_timer)
+{
+   if ( loop_timer.was_run ) {
+#if defined(LCALS_USE_CYCLE)
+      long double run_time = elapsed(loop_timer.stop,
+                                     loop_timer.start);
+#elif defined(LCALS_USE_CLOCK)
+      long double run_time =
+         static_cast<long double>(loop_timer.stop -
+                                  loop_timer.start) / CLOCKS_PER_SEC;
+#else
+#error LCALS_TIMER_TYPE is undefined! 
+
+#endif
+      loop_stat.loop_run_time[ilength].push_back( run_time );
+   }
+}
+
+
+
+//
+// Compute statistics for loop run for variant with given index.
+//
+void computeStats( unsigned ilv, vector<LoopStat>& loop_stats,
+                   bool do_fom )
+{
+
+   // compute stats for each loop...
+   for ( unsigned iloop = 0; iloop < loop_stats.size(); ++iloop ) {
+
+      LoopStat& stat = loop_stats[iloop];
+
+      if ( stat.loop_is_run ) {
+
+         // compute stats for each length loop is run...
+         for ( unsigned ilen = 0; ilen < stat.loop_length.size(); ++ilen )  {
+   
+            if ( stat.loop_run_count[ilen] > 0 ) { 
+
+               vector<long double>& time_sample = 
+                                         stat.loop_run_time[ilen]; 
+               unsigned sample_size = time_sample.size();
+    
+               long double mean = 0.0;
+               long double sdev = 0.0;
+               long double max = -std::numeric_limits<long double>::max();
+               long double min = std::numeric_limits<long double>::max();
+               long double harm = 0.0;
+
+               for (unsigned is = 0; is < sample_size; ++is) {
+                  mean += time_sample[is];
+                  max = std::max(max, time_sample[is]);
+                  min = std::min(min, time_sample[is]);
+                  if ( time_sample[is] > 0.0 ) {
+                     harm += 1.0/time_sample[is];
+                  }
+               }
+
+               mean /= sample_size;
+   
+               if ( harm > 0.0 ) { harm = sample_size/harm; }
+
+               for (unsigned is = 0; is < sample_size; ++is) {
+                  sdev += (time_sample[is] - mean)*(time_sample[is] - mean);
+               }
+
+               sdev /= sample_size;
+
+               stat.mean[ilen]      = mean;
+               stat.std_dev[ilen]   = sdev;
+               stat.min[ilen]       = min;
+               stat.max[ilen]       = max;
+               stat.harm_mean[ilen] = harm;
+
+            }  // if loop length was run  
+
+         }  // iterate over loop lengths
+
+      }  // if loop is run
+
+   }  // iterate over loops
+
+   //
+   // FOM calculations (done separately for simplicity)
+   //
+   if ( do_fom ) {
+
+      LoopSuiteRunInfo& suite_info = getLoopSuiteRunInfo();
+      LoopStat& ref_loop_stat = suite_info.ref_loop_stat;
+
+      std::vector<int> num_loops_run(suite_info.num_loop_lengths, 0);
+      std::vector< long double > tot_weight(suite_info.num_loop_lengths, 0.0);
+      std::vector< long double > tot_time(suite_info.num_loop_lengths, 0.0);
+      std::vector< long double > fom_rel(suite_info.num_loop_lengths, 0.0);
+      std::vector< long double > fom_rate(suite_info.num_loop_lengths, 0.0);
+
+      for ( unsigned iloop = 0; iloop < loop_stats.size(); ++iloop ) {
+
+         LoopStat& stat = loop_stats[iloop];
+
+         if ( stat.loop_is_run ) {
+
+            for ( unsigned ilen = 0; ilen < stat.loop_length.size(); ++ilen )  {
+
+               if ( stat.loop_run_count[ilen] > 0 ) {
+
+                  num_loops_run[ilen]++;
+                  tot_weight[ilen]   += stat.loop_weight; 
+                  tot_time[ilen]     += stat.mean[ilen]; 
+   
+                  //
+                  // sum weighted loop time 
+                  //
+                  fom_rel[ilen] += stat.loop_weight * stat.mean[ilen];
+
+                  //
+                  // sum weighted loop iteration rate
+                  //
+                  fom_rate[ilen] += (stat.loop_weight * stat.mean[ilen]) /
+                      (stat.loop_length[ilen] * stat.samples_per_pass[ilen]);
+   
+               }  // if loop length was run
+   
+            }  // iterate over loop lengths
+   
+         }  // if loop is run
+   
+      }  // iterate over loops
+
+      for (unsigned ilen = 0; ilen < suite_info.num_loop_lengths; ++ilen) {
+         suite_info.num_loops_run[ilv][ilen] = num_loops_run[ilen];
+         suite_info.tot_time[ilv][ilen] = tot_time[ilen];
+
+         long double ref_time = ref_loop_stat.loop_run_time[ilen][0];
+   
+         if ( num_loops_run[ilen] > 0 ) {
+#if 0  // this makes 0 <= fom_rel <= 1/tot_time
+            suite_info.fom_rel[ilv][ilen] = 
+               ref_time * tot_weight[ilen] / ( tot_time[ilen] * fom_rel[ilen] );
+#else  // this makes 0 <= fom_rel <= 1
+            suite_info.fom_rel[ilv][ilen] = 
+               ref_time * tot_weight[ilen] / fom_rel[ilen] ;
+#endif
+            suite_info.fom_rate[ilv][ilen] = 1.0 / fom_rate[ilen];
+         }
+      }
+
+   }
+
+}
+
+
+//
+// Forward declarations for routines that write loop reports.
+//
+namespace {
+
+   void writeTimingSummaryReport(
+        const vector< string >& run_loop_variants,
+        ostream& os);
+
+   void writeChecksumReport(
+        const vector< string >& run_loop_variants,
+        ostream& os);
+
+   void writeFOMReport(
+        const vector< string >& run_loop_variants,
+        ostream& os);
+
+   void writeMeanTimeReport(const string& variant_name, 
+                            const string& output_dirname);
+
+   void writeRelativeTimeReport(const string& variant_name, 
+                                const string& output_dirname);
+
+   std::string buildVersionInfo();
+
+};  // unnamed namespace
+
+
+//
+// Routine called from main() to generate timing report(s).
+//
+void generateTimingReport(const vector< string >& run_loop_variants,
+                          const string& output_dirname)
+{
+   if ( run_loop_variants.size() == 0 ) return;
+
+   bool do_fom = true;
+
+   std::string ver_info = buildVersionInfo(); 
+
+   //
+   // Compute statistics for all loops.
+   //
+   LoopSuiteRunInfo& suite_run_info = getLoopSuiteRunInfo();
+   const unsigned nvariants = run_loop_variants.size();
+   for (unsigned ilv = 0; ilv < nvariants; ++ilv) {
+      computeStats( ilv, suite_run_info.getLoopStats(run_loop_variants[ilv]),
+                    do_fom );
+   }
+
+   //
+   // If output directory name is given, write files in that directory.
+   // Else, write only summary to standard output.  
+   //
+   if (!output_dirname.empty()) {
+
+      string timing_fname(output_dirname + "/" + "timing.txt");
+      ofstream file(timing_fname.c_str(), ios::out | ios::trunc);
+      if ( !file ) {
+         cout << " ERROR: Can't open output file " 
+                   << timing_fname << endl;
+      }
+      cout << "\n writeTimingSummaryReport...   " << timing_fname << endl;
+      writeTimingSummaryReport(run_loop_variants, file);
+
+      //
+      // Write mean run time file for each loop variant.
+      //
+      for (unsigned ilv = 0; ilv < nvariants; ++ilv) {
+         writeMeanTimeReport( run_loop_variants[ilv], output_dirname );
+      }
+
+      //
+      // Write relative run time file for each loop variant.
+      //
+      // NOTE: We assume variant "zero" is reference.
+      //
+      for (unsigned ilv = 1; ilv < nvariants; ++ilv) {
+         writeRelativeTimeReport( run_loop_variants[ilv], output_dirname );
+      }
+
+   } else {
+
+      writeTimingSummaryReport(run_loop_variants, cout);
+
+   }
+}
+
+//
+// Routine called from main() to generate checksum report.
+//
+void generateChecksumReport(
+   const vector< string >& run_loop_variants,
+   const string& output_dirname)
+{
+#if defined(LCALS_VERIFY_CHECKSUM)
+   if ( run_loop_variants.size() == 0 ) return;
+
+   //
+   // If output directory name is given, write file in that directory.
+   // Else, write summary to standard output.
+   //
+   if (!output_dirname.empty()) {
+      string checksum_fname(output_dirname + "/" + "checksum.txt");
+      ofstream file(checksum_fname.c_str(), ios::out | ios::trunc);
+      if ( !file ) {
+         cout << " ERROR: Can't open output file "                   
+                   << checksum_fname << endl;
+      }
+      cout << "\n writeChecksumReport...    " << checksum_fname << endl;
+      writeChecksumReport(run_loop_variants, file);   
+   } else {
+      writeChecksumReport(run_loop_variants, cout);
+   }
+#endif
+}
+
+//
+// Routine called from main() to generate FOM report.
+//
+void generateFOMReport(
+   const vector< string >& run_loop_variants,
+   const string& output_dirname)
+{
+   if ( run_loop_variants.size() == 0 ) return;
+
+   //
+   // If output directory name is given, write file in that directory.
+   // Else, write only summary to standard output.
+   //
+   if (!output_dirname.empty()) {
+      string fom_fname(output_dirname + "/" + "fom.txt");
+      ofstream file(fom_fname.c_str(), ios::out | ios::trunc);
+      if ( !file ) {
+         cout << " ERROR: Can't open output file "
+                   << fom_fname << endl;
+      }
+      cout << "\n writeFOMReport... " << fom_fname << endl;
+      writeFOMReport(run_loop_variants, file);   
+   } else {
+      writeFOMReport(run_loop_variants, cout);
+   }
+}
+ 
+
+//
+// Implementation of file-scope routines that write loop reports.
+//
+namespace {
+
+//
+// Write report about loop execution timings to given output stream.
+//
+void writeTimingSummaryReport(const vector< string >& run_loop_variants,
+                              ostream& os)
+{
+   LoopSuiteRunInfo& suite_run_info = getLoopSuiteRunInfo();
+   const unsigned nvariants = run_loop_variants.size();
+
+   const string& ref_variant = run_loop_variants[0];
+   vector<string>& loop_names = suite_run_info.loop_names;
+
+   //
+   //  Define some strings used to print summary table.
+   //
+   string equal_line("===========================================================================================================\n");
+   string dash_line("------------------------------------------------------------------------------------------------------------\n");
+   string dash_line_part("-------------------------------------------------------\n");
+   string dot_line_part("............................................\n");
+   vector<string> len_id(suite_run_info.loop_length_names.size());
+   for (unsigned ilen = 0; ilen < len_id.size(); ++ilen) {
+      len_id[ilen] = suite_run_info.loop_length_names[ilen][0];
+   }
+
+   std::string ver_info = buildVersionInfo();
+
+   //
+   //  Print compilation summary information.
+   //
+   os << "\n\n\n";
+   os << equal_line;
+   os << equal_line;
+
+   os << "LCALS compilation summary: " << endl;
+   os << ver_info << endl;
+
+   //
+   //  Print basic run summary information.
+   //
+   os << "\n\n";
+   os << equal_line;
+   os << equal_line;
+
+   os << "LCALS run summary: " << endl;
+   os << "sizeof(Real_type) = " << sizeof(Real_type) << endl;
+   os << "     num suite passes = " << suite_run_info.num_suite_passes << endl;
+   os << "     loop sample fraction = " << suite_run_info.loop_samp_frac << endl;
+   os << "     loop variants run : ";
+   for (unsigned ilv = 0; ilv < nvariants; ++ilv) {
+      string last_char;
+      if ( ilv+1 < run_loop_variants.size() ) last_char = string(" , ");
+      os << run_loop_variants[ilv] << last_char;
+   }
+   os << "\n     reference variant : " << ref_variant << endl;
+   os << equal_line;
+   os << equal_line;
+
+   //
+   // Set basic table formatting.
+   //
+   size_t max_name_len = 0;
+   for (size_t iloop = 0; iloop < loop_names.size(); ++iloop) {
+      max_name_len = max(max_name_len, loop_names[iloop].size()); 
+   }
+
+   size_t max_var_name_len = 0;
+   for (size_t ilv = 0; ilv < nvariants; ++ilv) {
+      max_var_name_len = 
+         max(max_var_name_len, run_loop_variants[ilv].size()); 
+   }
+
+   string var_field("Variant(length id)");
+   size_t var_field_len = var_field.size(); 
+   unsigned prec = 10;
+   unsigned prec_buf = prec + 8;
+   unsigned reldiff_prec = 6;
+
+   //
+   // Print table column headers.
+   //
+   os << "Loop name(Loop ID) -->   <length id>:(length, samples/pass), etc." 
+      << endl;
+   os <<left<< setw(var_field_len+1) << var_field;
+   os <<right<< setw(prec_buf) << "   Mean Time ";
+   os <<left<< setw(prec_buf) << "        Min Time";
+   os <<left<< setw(prec_buf) << "      Max Time";
+   os <<left<< setw(prec_buf) << "    Std. Dev.";
+   os <<left<< setw(prec_buf) << "Mean time rel to ref variant" << endl;
+   os << dash_line;
+
+
+   //
+   // Print timing results for all loops in a table.
+   //
+   for (unsigned iloop = 0; iloop < loop_names.size(); ++iloop) {
+
+      LoopStat& ref_variant_stat = suite_run_info.
+                                   getLoopStats(run_loop_variants[0])[iloop]; 
+      vector<long double> ref_mean(ref_variant_stat.mean); 
+
+      if ( !loop_names[iloop].empty() && ref_variant_stat.loop_is_run ) {
+
+         if ( iloop > 1 ) {  // magic numbers are bad!!
+            os << endl << dash_line_part;
+         }
+         os <<left << loop_names[iloop] << " (" << iloop << ") --> ";
+
+         for (unsigned ilv = 0; ilv < nvariants; ++ilv) {
+
+            LoopStat& stat = suite_run_info.
+                             getLoopStats(run_loop_variants[ilv])[iloop];
+
+            if ( stat.loop_is_run ) {
+
+               //
+               // Print separator line for new loop or new variant.
+               //
+               if ( ilv == 0 ) {
+
+                  for (unsigned ilen = 0; ilen < stat.loop_length.size(); ++ilen) {
+                     os << "   " << len_id[ilen] << ":(" 
+                        << stat.loop_length[ilen] << ", "
+                        << stat.samples_per_pass[ilen] << ")";
+                  }
+                  os << endl; 
+
+               } else {
+
+                  os << dot_line_part;
+
+               }
+
+               //
+               // Print statistics for each length of loop run.
+               //
+               for (unsigned ilen = 0; ilen < stat.loop_length.size(); ++ilen) {
+
+                  if ( stat.loop_run_count[ilen] > 0 ) {
+
+                     string var_string(run_loop_variants[ilv] + 
+                                         "(" + len_id[ilen] + ")");
+                  
+                     os << showpoint << setprecision(prec)
+                          <<left<< setw(var_field_len+1) << var_string;
+
+                     os <<right<< setw(prec_buf) << stat.mean[ilen];
+                     os <<right<< setw(prec_buf) << stat.min[ilen];
+                     os <<right<< setw(prec_buf) << stat.max[ilen];
+                     os <<right<< setw(prec_buf) << stat.std_dev[ilen];
+
+                     if ( ilv > 0 ) {
+                        // compare mean run time to reference variant 
+
+                        long double rel_mean_diff = 0;
+                        if ( ref_mean[ilen] != 0.0 ) {
+                           rel_mean_diff = 1.0 + 
+                              (stat.mean[ilen]-ref_mean[ilen])/ref_mean[ilen];
+                        }
+                        os <<right<< setprecision(reldiff_prec) << setw(prec_buf) 
+                             << rel_mean_diff << endl;
+                        stat.meanrel2ref[ilen] = rel_mean_diff;
+                     } else {
+                        os << endl;
+                     }
+
+                  }  // if loop length was run
+
+               } // iterate over loop lengths
+
+            } // if loop is run
+
+         }  // iterate over variants of loop run
+
+      }  // if loop name is not empty
+      
+   }  // iterate over loops
+
+
+   os << dash_line;
+   os << "\n\n\n"; 
+
+   os.flush();
+}
+
+
+//
+// Write report about loop chksums to given output stream.
+//
+void writeChecksumReport(const vector< string >& run_loop_variants,
+                         ostream& os)
+{
+   LoopSuiteRunInfo& suite_run_info = getLoopSuiteRunInfo();
+   const unsigned nvariants = run_loop_variants.size();
+   const string& ref_variant = run_loop_variants[0];
+   vector<string>& loop_names = suite_run_info.loop_names;
+
+   //
+   //  Define some strings used to print summary table.
+   //
+   string equal_line("===========================================================================================================\n");
+   string dash_line("------------------------------------------------------------------------------------------------------------\n");
+   string dash_line_part("-------------------------------------------------------\n");
+   string dot_line_part("............................................\n");
+   vector<string> len_id(suite_run_info.loop_length_names.size());
+   for (unsigned ilen = 0; ilen < len_id.size(); ++ilen) {
+      len_id[ilen] = suite_run_info.loop_length_names[ilen][0];
+   }
+
+   std::string ver_info = buildVersionInfo();
+
+   //
+   //  Print compilation summary information.
+   //
+   os << "\n\n\n";
+   os << equal_line;
+   os << equal_line;
+
+   os << "LCALS compilation summary: " << endl;
+   os << ver_info << endl;
+
+   //
+   //  Print checksum information.
+   //
+   os << "\n\n";
+   os << equal_line;
+   os << equal_line;
+
+   //
+   // Set basic table formatting.
+   //
+   size_t max_name_len = 0;
+   for (size_t iloop = 0; iloop < loop_names.size(); ++iloop) {
+      max_name_len = max(max_name_len, loop_names[iloop].size());
+   }
+
+   size_t max_var_name_len = 0;
+   for (size_t ilv = 0; ilv < nvariants; ++ilv) {
+      max_var_name_len =
+         max(max_var_name_len, run_loop_variants[ilv].size());
+   }
+
+   string var_field("Variant(length #)");
+   size_t var_field_len = var_field.size();
+   unsigned prec = 32;
+   unsigned prec_buf = prec + 8;
+
+   //
+   // Print table column headers.
+   //
+   os << "Loop name -->" << endl;
+   os <<left<< setw(var_field_len+1) << var_field;
+   os <<right<< setw(prec_buf) << "Check Sum    ";
+   os <<left<< setw(prec_buf) << "        Delta from reference" << endl;
+   os << dash_line;
+
+   //
+   // Print check sums for all loops in a table.
+   //
+   for (unsigned iloop = 0; iloop < loop_names.size(); ++iloop) {
+
+      LoopStat& ref_variant_stat = suite_run_info.
+                                   getLoopStats(run_loop_variants[0])[iloop];
+      vector<long double> ref_chksum(ref_variant_stat.loop_chksum);
+
+      if ( !loop_names[iloop].empty() && ref_variant_stat.loop_is_run ) {
+
+         if ( iloop > 1 ) {  // magic numbers are bad!!
+            os << endl << dash_line_part;
+         }
+         os <<left << loop_names[iloop] << " (" << iloop << ") --> ";
+
+         for (unsigned ilv = 0; ilv < nvariants; ++ilv) {
+
+            LoopStat& stat = suite_run_info.
+                             getLoopStats(run_loop_variants[ilv])[iloop];
+
+            if ( stat.loop_is_run ) {
+
+               //
+               // Print separator line for new loop or new variant.
+               //
+               if ( ilv == 0 ) {
+                  os << endl;
+               } else {
+                  os << dot_line_part;
+               }
+
+               //
+               // Print checksum for each length of loop run.
+               //
+               for (unsigned ilen = 0; ilen < stat.loop_length.size(); ++ilen) {
+
+                  if ( stat.loop_run_count[ilen] > 0 ) {
+
+                     string var_string(run_loop_variants[ilv] +
+                                         "(" + len_id[ilen] + ")");
+
+                     os << showpoint << setprecision(prec)
+                          <<left<< setw(var_field_len+1) << var_string;
+
+                     os <<right<< setw(prec_buf) << stat.loop_chksum[ilen];
+
+                     if ( ilv > 0 ) {
+                        // compare checksum to reference variant
+                        long double chksum_diff = fabs(
+                           stat.loop_chksum[ilen]-ref_chksum[ilen] );
+                        os <<right<< setw(prec_buf)
+                             << chksum_diff << endl;
+                     } else {
+                        os << endl;
+                     }
+
+                  }  // if loop length was run
+
+               } // iterate over loop lengths
+
+            } // if loop is run
+
+         }  // iterate over variants of loop run
+
+      }  // if loop name is not empty
+
+   }  // iterate over loops
+
+
+   os << dash_line;
+   os << "\n\n\n";
+
+   os.flush();
+}
+
+//
+// Generate FOM report file to given output stream.
+//
+void writeFOMReport(const vector< string >& run_loop_variants,
+                    ostream& os)
+{
+   LoopSuiteRunInfo& suite_run_info = getLoopSuiteRunInfo();
+   const unsigned nvariants = run_loop_variants.size();
+
+   //
+   //  Define some strings used to print FOM summary table.
+   //
+   string equal_line("===========================================================================================================\n");
+   string dash_line_part("-------------------------------------------------------\n");
+   string dot_line_part("............................................\n");
+
+   std::string ver_info = buildVersionInfo();
+
+   //
+   //  Print compilation summary information.
+   //
+   os << "\n\n\n";
+   os << equal_line;
+   os << equal_line;
+
+   os << "LCALS compilation summary: " << endl;
+   os << ver_info << endl;
+
+   //
+   //  Print checksum information.
+   //
+   os << "\n\n";
+   os << equal_line;
+   os << equal_line;
+
+   os << "LCALS FOM results: " << endl;
+   os << equal_line;
+
+   vector<string>& len_name = suite_run_info.loop_length_names;
+
+   unsigned prec = 32;
+   //
+   // Output FOM for each loop variant (and loop lengths)
+   //
+   for (unsigned ilv = 0; ilv < nvariants; ++ilv) {
+
+      vector< int >& num_loops_run    = suite_run_info.num_loops_run[ilv];
+      vector< long double >& tot_time = suite_run_info.tot_time[ilv];
+      vector< long double >& fom_rel  = suite_run_info.fom_rel[ilv];
+      vector< long double >& fom_rate = suite_run_info.fom_rate[ilv];
+
+      os <<left << "Loop variant -- " << run_loop_variants[ilv] << endl;
+
+      for (unsigned ilen = 0; ilen < len_name.size(); ++ilen) {
+         os << "\t" << len_name[ilen]
+                    << " :   # loops run = " << num_loops_run[ilen];
+         os << showpoint << setprecision(prec)
+                    << " ,   total exec time = " << tot_time[ilen] << endl;
+         os << "\t\tFOM_relative = " << fom_rel[ilen] << endl;
+#if 0  // It's not clear what this FOM rate means...
+         os << "\t\tFOM_rate     = " << fom_rate[ilen] << endl;
+#endif
+
+         if ( ilen < len_name.size() - 1 ) {
+            os << dot_line_part;
+         }
+      }
+
+      if ( ilv < nvariants - 1 ) {
+         os << endl << dash_line_part;
+      }
+
+   }
+
+   os << equal_line;
+   os << "\n\n\n";
+
+   os.flush();
+}
+
+//
+// Write mean run time report file.
+//
+void writeMeanTimeReport(const string& variant_name, 
+                         const string& output_dirname)
+{
+   string rept_fname(output_dirname + "/");
+   rept_fname += variant_name;
+   rept_fname += string("-meantime.txt");
+
+   ofstream file(rept_fname.c_str(), ios::out | ios::trunc);
+   if ( !file ) {
+      cout << " ERROR: Can't open output file " << rept_fname << endl;
+   }
+   cout << "\n writeMeanTimeReport...   " << rept_fname << endl;
+
+   LoopSuiteRunInfo& suite_run_info = getLoopSuiteRunInfo();
+
+   vector<string>& loop_names = suite_run_info.loop_names;
+   vector<string>& len_names = suite_run_info.loop_length_names;
+
+   const string sepchr(" , ");
+   unsigned prec = 8;
+
+   //
+   // Print title line.
+   // 
+   file << variant_name << " Mean Run Times ";
+   for (unsigned i = 0; i < len_names.size(); ++i) {
+      file << sepchr;
+   } 
+   file << endl;
+   
+   //
+   // Print column header line.
+   // 
+   for (unsigned i = 0; i < len_names.size(); ++i) {
+      file << sepchr << len_names[i];
+   } 
+   file << endl;
+
+   //
+   // Print row of times for each loop.
+   //
+   for (unsigned iloop = 0; iloop < loop_names.size(); ++iloop) {
+
+      LoopStat& stat = suite_run_info.
+                       getLoopStats(variant_name)[iloop]; 
+
+      if ( !loop_names[iloop].empty() && stat.loop_is_run ) {
+
+         file << loop_names[iloop];
+         for (unsigned ilen = 0; ilen < stat.loop_length.size(); ++ilen) {
+            file << sepchr << setprecision(prec) << stat.mean[ilen];
+         }
+         file << endl;
+
+      }
+
+   }
+
+   file.flush();
+}
+
+//
+// Write relative run time report file.
+//
+void writeRelativeTimeReport(const string& variant_name, 
+                             const string& output_dirname)
+{
+   string rept_fname(output_dirname + "/");
+   rept_fname += variant_name;
+   rept_fname += string("-reltime.txt");
+
+   ofstream file(rept_fname.c_str(), ios::out | ios::trunc);
+   if ( !file ) {
+      cout << " ERROR: Can't open output file " << rept_fname << endl;
+   }
+   cout << "\n writeRelativeTimeReport...   " << rept_fname << endl;
+
+   LoopSuiteRunInfo& suite_run_info = getLoopSuiteRunInfo();
+
+   vector<string>& loop_names = suite_run_info.loop_names;
+   vector<string>& len_names = suite_run_info.loop_length_names;
+
+   const string sepchr(" , ");
+   unsigned prec = 6;
+
+   //
+   // Print title line.
+   // 
+   file << variant_name << " Relative Run Times ";
+   for (unsigned i = 0; i < len_names.size(); ++i) {
+      file << sepchr;
+   } 
+   file << endl;
+   
+   //
+   // Print column header line.
+   // 
+   for (unsigned i = 0; i < len_names.size(); ++i) {
+      file << sepchr << len_names[i];
+   } 
+   file << endl;
+
+   //
+   // Print row of times for each loop.
+   //
+   for (unsigned iloop = 0; iloop < loop_names.size(); ++iloop) {
+
+      LoopStat& stat = suite_run_info.
+                       getLoopStats(variant_name)[iloop]; 
+
+      if ( !loop_names[iloop].empty() && stat.loop_is_run ) {
+
+         file << loop_names[iloop];
+         for (unsigned ilen = 0; ilen < stat.loop_length.size(); ++ilen) {
+            file << sepchr << setprecision(prec) << stat.meanrel2ref[ilen];
+         }
+         file << endl;
+
+      }
+
+   }
+
+   file.flush();
+}
+
+//
+// Build string containing LCALS compilation information from
+// file created when make is invoked.
+//
+std::string buildVersionInfo()
+{
+   std::ifstream infile("lcalsversioninfo.txt", std::ios::in);
+  
+   std::string ver_info;
+
+   infile.seekg(0, std::ios::end);
+   ver_info.reserve(infile.tellg());
+   infile.seekg(0, std::ios::beg);
+   
+   ver_info.assign((std::istreambuf_iterator<char>(infile)),
+                    std::istreambuf_iterator<char>());
+   infile.close(); 
+   
+#if 0
+   std::string ver_info = "LCALS compilation info: \n" 
+              << "\tUser = " << VER_PERSON << "\n"
+              << "\tDate, Time = " << VER_DATE << " , " << VER_TIME << "\n"
+              << "\tMachine = " << VER_MACHINE << "\n"
+              << "\tOS = " << VER_OS << "\n"
+              << "\t-----------------------------------------------" << "\n"
+              << "\tCompiler + options = " << lcals_ver_info_values[0] << "\n"
+              << "\tLCALS rules (defines) = " << lcals_ver_info_values[1] << "\n";
+#endif
+   return ver_info;
+}
+
+};  // unnamed namespace
+
+
+

MicroBenchmarks/LCALS/LCALSSuite.hxx

+//
+// 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

MicroBenchmarks/LCALS/LCALSSuite.cxx

+//
+// See README-LCALS_license.txt for access and distribution restrictions
+//
+
+//
+// Source file with routines to allocate data for LCALS suite
+// and define parameters controlling execution of each loop.
+//
+
+#include "LCALSSuite.hxx"
+#include "LCALSStats.hxx"
+
+#include "SubsetDataA.hxx"
+
+#include<cstdlib>
+#include<string>
+#include<iostream>
+
+#include<sys/types.h>
+#include<sys/stat.h>
+
+//#define LCALS_OMP_MEM_INIT
+#undef LCALS_OMP_MEM_INIT
+
+//
+// File scope data holding structures used in loop suite
+//
+static LoopData* s_loop_data = 0;
+
+
+//
+// Default value for static ADomain member;
+//
+double ADomain::loop_length_factor = 1.0;
+
+//
+// Prototypes for file scope routines used in to manage loop data and checksums
+//
+
+namespace {
+
+Real_ptr allocAndInitData(LoopData::RealArray& ra, Index_type len);
+Index_type* allocAndInitData(LoopData::IndxArray& ia, Index_type len);
+Complex_ptr allocAndInitData(LoopData::ComplexArray& ca, Index_type len);
+void initData(LoopData::RealArray& ra);
+void initData(LoopData::IndxArray& ia);
+void initData(LoopData::ComplexArray& ca);
+
+void initChksum(LoopStat& stat, LoopLength ilength);
+void updateChksum(LoopStat& stat, LoopLength ilength,
+                  const LoopData::RealArray& ra, Real_type scale_factor = 1.0);
+void updateChksum(LoopStat& stat, LoopLength ilength,
+                  Real_type val);
+void updateChksum(LoopStat& stat, LoopLength ilength,
+                  const LoopData::ComplexArray& ca, Real_type scale_factor = 1.0);
+
+}  // closing brace for unnamed namespace
+
+
+
+
+//
+// Accessor routine for suite kernel data.
+//
+LoopData& getLoopData() { return *s_loop_data; }
+
+
+//
+// Define how suite will run and initialize stat structures for loops.
+//
+// NOTE: Loop lengths, loop sample counts (and weights for optimization
+//       evaluation) are defined here!
+//
+// These values should be set large enough to accurately generate 
+// execution timings (i.e., not too small to be masked by CPU timing 
+// resolution and overhead).  The values set here were manually determined 
+// so that O(1) seconds of execution time is required to sample each loop 
+// on some of our fastest Intel machines.
+//
+void defineLoopSuiteRunInfo(const std::vector<LoopVariantID>& run_variants,
+                            bool run_loop[], 
+                            double sample_frac,
+                            double loop_length_factor)
+{
+#ifdef TESTSUITE
+   std::cout << "\n defineLoopSuiteRunInfo..." << std::endl;
+#endif
+   std::vector<std::string> run_variant_names = getVariantNames(run_variants);
+
+   if ( s_loop_data == 0 ) { 
+      s_loop_data = new LoopData(); 
+   }
+
+   //
+   //
+   // Enumeration defining loop groups for relative weighting of
+   // execution timing based on what we think is most important.
+   //
+   // In computation of figures of merit (FOM), loops with higher 
+   // weights will reduce FOM value more for higher run-time than 
+   // those with lower weights.
+   //
+   enum WeightGroup {
+
+      DATA_PARALLEL = 0,
+      ORDER_DEPENDENT,
+      TRANSCENDENTAL,
+      DATA_DEPENDENT,
+      POINTER_NEST,
+      COMPLEX,
+
+      NUM_WEIGHT_GROUPS  // Keep this one last and NEVER comment out (!!)
+   };
+
+
+   //
+   // Initialize structure holding loop suite execution data.
+   //
+   LoopSuiteRunInfo& suite_info = getLoopSuiteRunInfo();
+
+   suite_info.loop_samp_frac = sample_frac;
+
+   suite_info.loop_weights.resize(NUM_WEIGHT_GROUPS);
+   suite_info.loop_weights[DATA_PARALLEL]   = 2.0;
+   suite_info.loop_weights[ORDER_DEPENDENT] = 1.8;
+   suite_info.loop_weights[TRANSCENDENTAL]  = 1.7;
+   suite_info.loop_weights[DATA_DEPENDENT]  = 1.7;
+   suite_info.loop_weights[POINTER_NEST]    = 1.4;
+   suite_info.loop_weights[COMPLEX]         = 1.0;
+
+   suite_info.loop_length_names.resize(NUM_LENGTHS);
+   suite_info.loop_length_names[LONG] = std::string("LONG");
+   suite_info.loop_length_names[MEDIUM] = std::string("MEDIUM");
+   suite_info.loop_length_names[SHORT] = std::string("SHORT");
+
+   suite_info.num_loops_run.resize( run_variant_names.size() );
+   suite_info.tot_time.resize( run_variant_names.size() );
+   suite_info.fom_rel.resize( run_variant_names.size() );
+   suite_info.fom_rate.resize( run_variant_names.size() );
+
+   for (unsigned ilv = 0; ilv < run_variant_names.size(); ++ilv) {
+      suite_info.addLoopStats(run_variant_names[ilv]);
+
+      suite_info.num_loops_run[ilv].resize(NUM_LENGTHS, 0);
+      suite_info.tot_time[ilv].resize(NUM_LENGTHS, 0.0);
+      suite_info.fom_rel[ilv].resize(NUM_LENGTHS, 0.0);
+      suite_info.fom_rate[ilv].resize(NUM_LENGTHS, 0.0);
+   }
+
+
+   //
+   // Define common loop lengths for LONG, MEDIUM, SHORT loops.
+   //
+   // The values assigned here are propagated across all kernels 
+   // (with a few exceptions) to simplify suite configuration en masse.  
+   // These can also be set per-kernel below. 
+   //
+   std::vector< int > shared_loop_length(NUM_LENGTHS);
+   shared_loop_length[LONG]   = static_cast<int>(44217 * loop_length_factor);
+   shared_loop_length[MEDIUM] = static_cast<int>(5001 * loop_length_factor);
+   shared_loop_length[SHORT]  = static_cast<int>(171 * loop_length_factor);
+
+   ADomain::loop_length_factor = loop_length_factor;
+
+
+   std::vector<double>& weight = suite_info.loop_weights;
+
+   Index_type max_loop_length = 0;
+
+   for (unsigned iloop = 0 ; iloop < suite_info.num_loops; ++iloop) {
+
+      std::string loop_name;
+      LoopStat loop_stat(suite_info.num_loop_lengths);
+
+      Index_type max_loop_indx = 0;
+
+      if ( run_loop[iloop] ) {
+
+         switch ( iloop ) {
+   
+            case REF_LOOP : {
+               loop_name = std::string("REF_LOOP"); 
+               //
+               // Note: Reference loop stats are not used in
+               //       in suite.  Parameters are defined in 
+               //       defineReferenceLoopRunInfo( ) routine.
+               //
+               break;
+            }
+
+
+            //
+            // Parameters defining how loops in Subset A are run...
+            //
+            case PRESSURE_CALC   :
+            case PRESSURE_CALC_ALT   : {
+
+               if ( static_cast<LoopKernelID>(iloop) == PRESSURE_CALC ) {
+                  loop_name = std::string("PRESSURE_CALC");
+               } else {
+                  loop_name = std::string("PRESSURE_CALC_ALT");
+               }
+
+               loop_stat.loop_weight = weight[DATA_DEPENDENT]; 
+
+               for (int i = 0; i < NUM_LENGTHS; ++i) {
+                  loop_stat.loop_length[i] = shared_loop_length[i];
+               }
+               max_loop_indx = loop_stat.loop_length[LONG];
+
+               loop_stat.samples_per_pass[LONG]   = 15000;
+               loop_stat