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