basics.h

Go to the documentation of this file.

#ifndef TBCI_BASICS_H
#define TBCI_BASICS_H  

#include "tbci/tbci_version.h"

#ifdef HAVE_TBCICONFIG_H
# include "tbci/tbciconfig.h"
#else
# include "tbci/config_manual.h"
#endif

// We pass __GNUC_SUBVER__ on the commandline just in case
#if !defined(__GNUC_PATCHLEVEL__) && defined(__GNUC__SUBVER__)
# define __GNUC_PATCHLEVEL__ __GNUC_SUBVER__
#endif

/* Win vs. Unix
 *  - HAVE_WIN_32: In case somebody wants to know
 *  - HAVE_UNIX: For the symmetry
 */
#undef HAVE_WIN_32
#undef HAVE_UNIX
#ifdef unix
# define HAVE_UNIX 1
#endif
#ifdef _MSC_VER
# define HAVE_WIN_32 1
// Switch off annoying stuff
# pragma warning(disable: 4003)
#endif

// SMP?
#if defined(USE_SMP) && !defined(SMP)
# define SMP
#endif

// Use namespaces?
#if !defined(NO_NS) && !defined(HAVE_BUGGY_NAMESPACE)
# define USE_NS
# undef  NO_NS
#else
# undef USE_NS
#endif

// Signatures
#ifdef HAVE_SIGNATURE
# define SIGNATURE signature
#else
# define SIGNATURE class
#endif

// restrict
#if defined(HAVE_RESTRICT) && !defined(NO_RESTRICT)
# define RESTRICT restrict
#elif defined (HAVE___RESTRICT__) && !defined(NO_RESTRICT)
# define RESTRICT __restrict__
#else
# define RESTRICT  
#endif

#if defined(HAVE_BUILTIN_EXPECT) && !defined(NO_EXPECT)
# define LIKELY(expr)   __builtin_expect((expr) != 0, 1)
# define UNLIKELY(expr) __builtin_expect((expr) != 0, 0)
#else
# define LIKELY(expr)   (expr)
# define UNLIKELY(expr) (expr)
#endif

// Avoid using REGISTER keyword for C++-17 and newer
#if defined(__cplusplus) && __cplusplus >= 201703L
# define REGISTER
#else
# define REGISTER register
#endif

// http://gcc.gnu.org/wiki/Visibility
#ifdef _MSC_VER
# ifdef BUILDING_DLL
#  define TBCI_DLLEXPORT __declspec(dllexport)
# else
#  define TBCI_DLLEXPORT __declspec(dllimport)
# endif
# define TBCI_DLLLOCAL
#else
# ifdef HAVE_VISIBILITY_ATTR
#  define TBCI_DLLEXPORT __attribute__ ((visibility("default")))
#  define TBCI_DLLLOCAL __attribute__ ((visibility("hidden")))
# else
#  define TBCI_DLLEXPORT
#  define TBCI_DLLLOCAL
# endif
#endif

// pragma interface/implementation stuff
#if defined(HAVE_PRAGMA_IFACE_IMPL) && !defined(NO_PRAGMA_I)
# define PRAGMA_I
#endif

// guiding decl stuff; explicit template params
#ifdef HAVE_NEED_FOR_EXPL_TMPLPARM
# define FGD <>
# define FGDT <T>
# define FGDU <U>
# define FGDTD <T,dims>
# define FGDDT <dims,T>
# define FGDCT <cplx<T> >
# define FGDR <rank>
#else
# define FGD
# define FGDT
# define FGDU
# define FGDTD
# define FGDDT
# define FGDCT
# define FGDR
#endif

// BorlandC++ 0x570 compat with newer glibc headers
// This is a problems with Borland's cdefs.h; it replaces cdefs.h
// from glibc; glibc-2.3 has and needs the defs from below
#if defined(__BORLANDC__) && defined(__linux__)
# define __BEGIN_NAMESPACE_STD
# define __END_NAMESPACE_STD
# define __USING_NAMESPACE_STD(name)
# define __BEGIN_NAMESPACE_C99
# define __END_NAMESPACE_C99
# define __USING_NAMESPACE_C99(name)
#endif

// Include headers
# include <iostream>
# include <fstream>
# include <iomanip>
# include <string>
#ifndef HAVE_NO_NEW_HEADERS_BUG
# include <cstring>
# include <cstdarg>
# include <cstdlib>
# include <cmath>
//# include <sstream>
#else
//# include <iostream.h>
//# include <fstream.h>
//# include <ios.h>
//# include <iomanip.h>
# include <string.h>
# include <stdarg.h>
# include <stdlib.h>   
# include <math.h>   
// no way to include C++ string within this scheme ...
#endif

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#if defined(C_MEMALLOC) && defined(HAVE_MEMALIGN)
# include <malloc.h>
#endif

// IRIX defines MIN and MAX there
#ifdef HAVE_MINMAX_IN_SYS_PARAM_H
# include <sys/param.h>
#endif

#if !defined(HAVE_SSTREAM) || defined(HAVE_BUGGY_SSTREAM)
//# include <strstream>
# define ISTRINGSTREAM istrstream
# define OSTRINGSTREAM ostrstream
# define  STRINGSTREAM  strstream
#else
//# include <sstream>
# define ISTRINGSTREAM istringstream
# define OSTRINGSTREAM ostringstream
# define  STRINGSTREAM  stringstream
#endif


// long long and long doubel types
#ifdef HAVE_LONG_DOUBLE
# define LONG_DOUBLE long double
#else
# define LONG_DOUBLE double
#endif
#ifdef HAVE_LONG_LONG
# define LONG_LONG long long
#else
# define LONG_LONG long
#endif

// Auto instantiate using the auto_decl program
#ifdef AUTO_DECL
# define INST(x) _instantiate x
# define INST2(x,y) _instantiate x,y
# define INST3(x,y,z) _instantiate x,y,z
# define INST4(x,y,z,a) _instantiate x,y,z,a
# define INST5(x,y,z,a,b) _instantiate x,y,z,a,b
# define INST6(x,y,z,a,b,c) _instantiate x,y,z,a,b,c
# define NOINST _noinstantiate
# define INSTCTL(x) _instfile x
#else
# define INST(x) 
# define INST2(x,y) 
# define INST3(x,y,z) 
# define INST4(x,y,z,a) 
# define INST5(x,y,z,a,b) 
# define INST6(x,y,z,a,b,c) 
# define NOINST 
# define INSTCTL(x) 
#endif

// NULL
#ifndef NULL
# define NULL (0)
#endif

// Remark: The math functions should be put into std:: namespace
//         but neither egcs-1.1.x nor MSVC do this ...
//  egcs-1.1.x at least can access them via std:: though.

#if defined(NO_NS)
# define NAMESPACE_TBCI /* namespace TBCI { */
# define NAMESPACE_STD  /* namespace std { */
# define NAMESPACE_CSTD /* namespace std { */
# define NAMESPACE_GRID /* namespace Grid { */
# define NAMESPACE_CPLX /* namespace std { */
# define NAMESPACE_END  /* } namespace */
# define NAMESPACE_STD_END      /* } namespace std */
# define NAMESPACE_CSTD_END     /* } namespace std */
# define NAMESPACE_CPLX_END     /* } namespace std */
# define USING_TBCI     /* using namespace TBCI */
# define USING_GRID     /* using namespace Grid */
# define USING_FD       /* using namespace FD */
# define USING_END      /* using namespace std */
# define USIND_STD      /* using namespace std */
# define FRIEND_TBCI__          /* */
# define FRIEND_TBCI2__         /* */
# define TBCI__         /*TBCI::*/
# define __TBCI__       /* ::TBCI:: */
# define GRID__         /*Grid::*/
# define FD__           /*FD::*/
# define STD__          /*std::*/
# define CSTD__         /*std::*/ 
# define MATH__         /*std::*/
# define CPLX__         /*std::*/
# define GLBL__ ::      /* Look outside scope of class; */
# define GLBL2__ ::     /* Look outside scope of class; */
#elif defined(NO_NS_TBCI)
# define NAMESPACE_TBCI /* namespace TBCI { */
# define NAMESPACE_STD  namespace std {
# define NAMESPACE_CSTD namespace std {
# define NAMESPACE_CPLX namespace std {
# define NAMESPACE_GRID /* namespace Grid { */
# define NAMESPACE_FD   /* namespace Finite_Difference { */
# define NAMESPACE_END  /* } */;        /* namespace */
# define NAMESPACE_STD_END  }   /* namespace std */
# define NAMESPACE_CSTD_END }   /* namespace std */
# define NAMESPACE_CPLX_END }   /* namespace std */
# define USING_TBCI /* using namespace TBCI; */
# define USING_GRID /* using namespace Grid; */
# define USING_FD   /* using namespace Finite_Difference; */
# define USING_END  using namespace std; /* Don't use! */
# define USING_STD  using namespace std;
# define TBCI__     /*  TBCI::*/
# define __TBCI__   /*::TBCI::*/
# define FRIEND_TBCI__          /* */
# define FRIEND_TCBI2__         /* */
# define GRID__ /*::Grid::*/
# define FD__   /*::FD::*/
# define STD__  std::
# define MATH__ std::
# define CSTD__ std::
# define CPLX__ std::
# define GLBL__         /* not needed if ::std:: is used */
# define GLBL2__ ::     /* needed as TBCI__ is disabled */
#else
# define NAMESPACE_TBCI namespace TBCI {
# define NAMESPACE_STD  namespace std {
# define NAMESPACE_CSTD namespace std {
# define NAMESPACE_GRID namespace Grid {
# define NAMESPACE_FD   namespace Finite_Difference {
# define NAMESPACE_CPLX namespace std {
# define NAMESPACE_END  }       /* namespace */
# define NAMESPACE_STD_END  }   /* namespace std */
# define NAMESPACE_CSTD_END }   /* namespace std */
# define NAMESPACE_CPLX_END }   /* namespace std */
# define USING_TBCI using namespace TBCI;
# define USING_GRID using namespace Grid;
# define USING_FD   using namespace Finite_Difference;
# define USING_END  using namespace std; /* Don't use! */
# define USING_STD  using namespace std;
# define TBCI__ TBCI::
# define __TBCI__ ::TBCI::
# define FRIEND_TBCI__          /* */
# define FRIEND_TBCI2__         /* */
# define GRID__ Grid::
# define FD__   FD::
# define STD__  std::
# define MATH__ std::
# define CSTD__ std::
# define CPLX__ std::
# define GLBL__         /* not needed if ::std:: is used */
# define GLBL2__        /* not needed if ::TBCI:: is used */
#endif

#ifndef NO_NS

# ifdef HAVE_LIBC_GLOBAL_NS_BUG
#  undef  MATH__
#  define MATH__ ::
#  undef  CSTD__
#  define CSTD__ ::
#  undef  NAMESPACE_CSTD
#  define NAMESPACE_CSTD        /* namespace std { */
#  undef  NAMESPACE_CSTD_END
#  define NAMESPACE_CSTD_END    /* } namespace std */
# endif

# ifdef HAVE_CPP_GLOBAL_NS_BUG
#  undef  STD__
#  define STD__ ::
#  undef  USING_STD
#  define USING_STD  using namespace;
#  undef  NAMESPACE_STD
#  define NAMESPACE_STD         /* namespace std { */
#  undef  NAMESPACE_STD_END
#  define NAMESPACE_STD_END     /* } namespace std */
# endif

# ifdef HAVE_CPLX_GLOBAL_NS_BUG
#  undef  CPLX__
#  define CPLX__ ::
#  undef  NAMESPACE_CPLX
#  define NAMESPACE_CPLX  
#  undef  NAMESPACE_CPLX_END
#  define NAMESPACE_CPLX_END  
# endif

/* We might want to know that LIBC/MATH functions are in a namespace
 * different from std C++ stuff. Most notably affects sqrt(std::complex)
 * and friends. */
# if defined(HAVE_LIBC_GLOBAL_NS_BUG) && !defined(HAVE_CPP_GLOBAL_NS_BUG)
#  define HAVE_LIBC_NEQ_CPP_BUG
# endif
# if defined(HAVE_LIBC_GLOBAL_NS_BUG) && !defined(HAVE_CPLX_GLOBAL_NS_BUG)
#  define HAVE_LIBC_NEQ_CPLX_BUG
# endif

/* SGI MIPSpro thinks friend decls refer to global namespace,
 * others shadow friends with member fns of same name if not scoped */
# if (HAVE_FRIEND_GLOBAL_NS_BUG || HAVE_NEED_FOR_FRIEND_SCOPE) && !defined(AUTO_DECL) && !defined(NO_NS_TBCI)
#  undef  FRIEND_TBCI__
#  define FRIEND_TBCI__ TBCI::
#  ifdef HAVE_FRIEND_GLOBAL_NS_BUG
#   undef  FRIEND_TBCI2__
#   define FRIEND_TBCI2__ TBCI::
#  endif
# endif

#endif /* NO_NS */

/* Note that abortion is illegal in a lot of countries ;-) */
#ifdef ABORT_ON_ERR
# define ABORT_RET(x) abort ()
# define ABORT_RET_NR abort ()
#else
# define ABORT_RET(x) return x
# define ABORT_RET_NR do {} while (0)
#endif

#ifndef MIN_ALIGN
# define MIN_ALIGN 8
#endif
#ifndef MIN_ALIGN2
# define MIN_ALIGN2 16
#endif

#undef  ALIGN
#if defined(HAVE_ALIGN_ATTR) || defined(HAVE_NEW_ALIGN_ATTR)
# ifdef HAVE_NEW_ALIGN_ATTR
#  define ALIGN3(v,i,x) v __attribute__ ((aligned(x))) (i)
# else
#  define ALIGN3(v,i,x) v(i) __attribute__ ((aligned(x)))
# endif
# define ALIGN2(v,x)    v __attribute__ ((aligned(x)))
# define ALIGN(x)         __attribute__ ((aligned(x)))
#else
# ifdef HAVE_DECLSPEC_ALIGN
#  define ALIGN3(v,i,x) __declspec(align(x)) v(i)
#  define ALIGN2(v,x)   __declspec(align(x)) v
#  define ALIGN(x)        __attribute__ ((aligned(x)))
# else
#  define ALIGN3(v,i,x) v(i)
#  define ALIGN2(v,x)   v
#  define ALIGN(x) 
# endif
#endif
#ifdef HAVE_TEMPL_ALIGN_ATTR
# define TALIGN(x) ALIGN(x)
#else
# define TALIGN(x) 
#endif
        
#ifdef HAVE_CONST_ATTR
# define CONSTA          __attribute__ ((const))
# define TBCI_CONST(x) x      __attribute__ ((const)); x
#else
# define CONSTA
# define TBCI_CONST(x) x
#endif
#ifdef HAVE_REGPARM_ATTR
# define REGPARMA(n)     __attribute__ ((regparm(n)))
# define REGPARM(n,x) x  __attribute__ ((regparm(n))); x
#else
# define REGPARMA(n)
# define REGPARM(n,x) x
#endif

#ifdef HAVE_UNUSED_ATTR
# define UNUSED __attribute__((unused))
#else
# define UNUSED 
#endif


#ifdef HAVE_WEAK_ATTR
# define WEAKA           __attribute__ ((weak))
# define WEAK(x) x       __attribute__ ((weak)); x
#ifdef __INTEL_COMPILER         // Does not like that attr in templ specializations
# define TWEAK(x) x
#else   
# define TWEAK(x) x       __attribute__ ((weak)); x
#endif
#else
# define WEAKA  
# define WEAK(x) x
# define TWEAK(x) x
#endif

#if defined(HAVE_HOT_ATTR) && defined(USE_HOT)
# define HOT    __attribute__ ((hot))
# define COLD   __attribute__ ((cold))
# define HOTDECL(x) x __attribute__ ((hot)); x  
# define COLDDECL(x) x __attribute__ ((cold)); x
#else
# define HOT
# define COLD
# define HOTDECL(x) x 
# define COLDDECL(x) x
#endif


/* Exception stuff */
#if !defined(NO_EXCEPT) && !defined(HAVE_BUGGY_EXCEPTIONS)
# include "tbci/except.h"
#else
# define TBCI_DISABLE_EXCEPT
#endif

// Error checking

#ifndef HAVE_PRETTY_FUNCTION
# if defined(HAVE_FUNC) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
#  define __PRETTY_FUNCTION__ __func__
# else
#  define __PRETTY_FUNCTION__ "<unknown>"
# endif
#endif  


#define TBCIERRH1 __PRETTY_FUNCTION__ 
#define TBCIERRM(cond,exc,txt,ind)                                      \
        STD__ string(#exc) + " in " + TBCIERRH1 + ":\n " + #txt + " at "\
          + __FILE__ + ":" + TBCI__ ltoa(__LINE__) + ":\n (" + #cond    \
          + ") == TRUE! (" + #ind + " = " + TBCI__ ltoa(ind) + ")"
#define TBCIERRS(cond,exc,txt,ind) \
        #exc << " in " << TBCIERRH1 << ":\n " << #txt << " at "         \
          << __FILE__ << ":" << __LINE__ << ":\n (" << #cond            \
          << ") == TRUE! (" << #ind << " = " << ind << ")"


#ifndef TBCI_NO_ERRCHECK

#define BCHK(cond,exc,txt,ind,rtval)                            \
  /*if (UNLIKELY((cond) && __TBCI__ do_errcheck())) {   */      \
  if (UNLIKELY(__TBCI__ do_errcheck() && (cond))) {             \
    if (__TBCI__ do_except())                                   \
      throw exc ((TBCIERRM(cond,exc,txt,ind)).c_str(), ind);    \
    else                                                        \
      STD__ cerr << TBCIERRS(cond,exc,txt,ind) << STD__ endl;   \
    if (__TBCI__ do_abort())                                    \
      abort();                                                  \
    return rtval;                                               \
  }
#define BCHKNR(cond,exc,txt,ind)                                \
  if (UNLIKELY(__TBCI__ do_errcheck() && (cond))) {             \
    if (__TBCI__ do_except())                                   \
      throw exc ((TBCIERRM(cond,exc,txt,ind)).c_str(), ind);    \
    else                                                        \
      STD__ cerr << TBCIERRS(cond,exc,txt,ind) << STD__ endl;   \
    if (__TBCI__ do_abort())                                    \
      abort();                                                  \
  }
#else
#ifdef __GNUC__
# warning Error checking disabled
#endif
# define BCHK(cond,exc,txt,ind,rtval) do {} while(0)
# define BCHKNR(cond,exc,txt,ind)     do {} while(0)
#endif

/* Expensive checks */
#ifdef TBCI_EXPCHECK
#define EXPCHK(cond,exc,txt,ind,rtval)                          \
  /* if (UNLIKELY((cond) && do_expcheck())) { */                \
  if (UNLIKELY(__TBCI__ do_expcheck() && (cond) )) {            \
    if (__TBCI__ do_except())                                   \
      throw exc ((TBCIERRM(cond,exc,txt,ind)).c_str(), ind);    \
    else                                                        \
      STD__ cerr << TBCIERRS(cond,exc,txt,ind) << STD__ endl;   \
    if (__TBCI__ do_abort())                                    \
      abort();                                                  \
    return rtval;                                               \
  }
#define EXPCHKNR(cond,exc,txt,ind)                              \
  if (UNLIKELY(__TBCI__ do_expcheck() && (cond) )) {            \
    if (__TBCI__ do_except())                                   \
      throw exc ((TBCIERRM(cond,exc,txt,ind)).c_str(), ind);    \
    else                                                        \
      STD__ cerr << TBCIERRS(cond,exc,txt,ind) << STD__ endl;   \
    if (__TBCI__ do_abort())                                    \
      abort();                                                  \
  }
#ifdef __GNUC__
# warning Expensive error checking enabled
#endif
#else
/* OK, no expensive error checking */
# define EXPCHK(cond,exc,txt,ind,rtval) do {} while(0)
# define EXPCHKNR(cond,exc,txt,ind)     do {} while(0)
#endif


#if defined(HAVE_ALGORITHM) && defined(HAVE_STD_MINMAX) &&!defined(HAVE_GCC_MINMAX)
# include <algorithm>
#endif
        
NAMESPACE_TBCI
#ifndef MIN
# ifdef HAVE_GCC_MINMAX
#  define MIN(a,b) ((a) <? (b))
#  define MAX(a,b) ((a) >? (b))
# elif defined(HAVE_STD_MINMAX)
#  define MIN(a,b) std::min(a,b)
#  define MAX(a,b) std::max(a,b)
# else
//TBCI_CONST(template <typename T> inline T MIN (const T a, const T b))
//{ return (a < b ? a : b); }
//TBCI_CONST(template <typename T> inline T MAX (const T a, const T b))
//{ return (a > b ? a : b); }
#  define MIN(a,b) ((a) < (b)? (a) : (b))
#  define MAX(a,b) ((a) > (b)? (a) : (b))
# endif
#endif

/* DEBUGINFO */
#ifdef DEBUGINFO
# define INFO(x) cout << x
#else
# define INFO(x)
#endif


/* Makros for return value optimization for GNU g++ */
//return value optimization
#if defined(RETVAL_OPT) && defined(HAVE_NAMED_RETVAL)
# define RET(x) return(x);
# define CONSTR(x)
#else
# define RET(x) 
# define CONSTR(x) x
#endif /* RETVAL_OPT */

// Work around MSVC failure to delete[] something else than void*
#if defined(_MSC_VER)
# define _VOID (void*)
#else
# define _VOID  
#endif          

// Work around Borland C++ 0x570 bug not handling inline in 
// templated member functions
#ifndef HAVE_BCXX_TEMPL_INLINE_MFUNC_BUG
# define INLINE inline
#else
# define INLINE 
#endif
        
NAMESPACE_END

#if defined(_OPENMP) && !defined(TBCI_NO_OMP)
# define TBCI_OMP 
# include <omp.h>
# define OMP_FOR _Pragma("omp parallel for") 
# define OMP_FOR_REDUCE_F2 _Pragma("omp parallel for reduction(+:f2)")
# define OMP_FOR_REDUCE_F1F2 _Pragma("omp parallel for reduction(+:f1,f2)")

# define NOSMP_VECVEC

# define NOSMP_MATVEC
//# define NOSMP_BDMATVEC
//# define TBCI_NO_SIMD
#else
# define OMP_FOR
# define OMP_FOR_REDUCE_F2
# define OMP_FOR_REDUCE_F1F2
#endif

#include "perf_opt.h"
#include "tbci_traits.h"
#include "tbci_param.h"

// prefetch
// loc argument gives hint on whether the accessed variable
// should be left in cache. 3 = Yes (all caches), 0 = No (cache),
// 1, 2 are intermediate (only some of the caches)
#if defined(HAVE_BUILTIN_PREFETCH) && !defined(NO_PREFETCH)
# define PREFETCH_R(addr,loc) __builtin_prefetch(addr, 0, loc )
# define PREFETCH_W(addr,loc) __builtin_prefetch(addr, 1, loc )
# define USE_PREFETCH 1
#else

# if defined(__alpha__) && defined(AXP_PREFETCH) && !defined(NO_PREFETCH) && defined(__GNUC__)
#  define PREFETCH_R(addr,loc) asm (" lda $31,%0 \n" :  : "m" (*(addr)) )
#  define PREFETCH_W(addr,loc) asm (" lda $31,%0 \n" :  : "m" (*(addr)) )
#  define USE_PREFETCH 1
# else
#  if defined(__i386__) && defined(SSE_PREFETCH) && !defined(NO_PREFETCH) && (defined(__GNUC__) || defined(__INTEL_COMPILER))
#   define PREFETCH_R(addr,loc) asm (" prefetcht0 %0 \n" :  : "m" (*(addr)) )
#   define PREFETCH_W(addr,loc) asm (" prefetcht0 %0 \n" :  : "m" (*(addr)) )
#   define USE_PREFETCH 1
#  else
#   if defined(__i386__) && defined(AMD_PREFETCH) && !defined(NO_PREFETCH) && (defined(__GNUC__) || defined(__INTEL_COMPILER))
#    define PREFETCH_R(addr,loc) asm (" prefetch  %0 \n" :  : "m" (*(addr)) )
#    define PREFETCH_W(addr,loc) asm (" prefetchw %0 \n" :  : "m" (*(addr)) )
#    define USE_PREFETCH 1
#   else
#    define PREFETCH_R(addr,loc) do {} while (0)
#    define PREFETCH_W(addr,loc) do {} while (0)
#    undef  USE_PREFETCH
#   endif
#  endif
# endif
#endif

#ifdef USE_PREFETCH
# define PREFETCH_R_MANY(addr,loc)      \
        for (char* _prefaddr = (char*)addr; _prefaddr < (char*)addr+CACHELINE_SZ*PREFETCH_AHEAD; _prefaddr += CACHELINE_SZ)     \
                PREFETCH_R(_prefaddr,loc)
# define PREFETCH_W_MANY(addr,loc)      \
        for (char* _prefaddr = (char*)addr; _prefaddr < (char*)addr+CACHELINE_SZ*PREFETCH_AHEAD; _prefaddr += CACHELINE_SZ)     \
                PREFETCH_W(_prefaddr,loc)
#else
# define PREFETCH_R_MANY(addr,loc) do {} while(0)
# define PREFETCH_W_MANY(addr,loc) do {} while(0)
#endif


#ifdef HAVE_TLS
# define THREAD__ __thread
#elif defined(HAVE_DTLS)
# define THREAD__ __declspec(thread)
#else
# define THREAD__  
#endif

//#if !defined(_WIN_32) && !defined(CYGWIN)
#ifdef HAVE_UNISTD_H
# include "smp.h"
#else 
# define MAIN_PID (getpid())
# define num_threads (0)
# define thrno (0)
# define ismainthread (1)
#endif


#ifdef __SSE2__
# define TBCI_SIMD_ALIGN 16
#endif

#ifdef USE_PLAIN_VEC_KERNELS
# include "plain_def.h"
#elif defined(USE_UNR_VEC_KERNELS2)
# include "unroll_prefetch_def2.h"
#else
# include "unroll_prefetch_def.h"
#endif


NAMESPACE_TBCI

template <typename T>
inline void SWAP (T& a, T& b)
{
        REGISTER T ALIGN(MIN_ALIGN) tmp = a; a = b; b = tmp;
}

#ifdef C_MEMALLOC

# if defined(__GNUC__) && !defined(C_MEMALLOC_WE_KNOW_WHAT_WE_DO)
#  warning "Don't define C_MEMALLOC if you use containers with elements which need intitalization"
#  warning " or take care yourself ! (Read basics.h:690)"
# endif
# ifdef HAVE_MEMALIGN
#  define NEW(t,s) (t*) /*CSTD__*/ memalign (sizeof(t)*MIN(4,s>>1), sizeof(t)*(s))
# else
#  define NEW(t,s) (t*) CSTD__ malloc (sizeof(t)*s)
# endif
# define  TBCIDELETE(t,v,sz) do { BCHKNR(!v,NumErr,free null ptr,0); CSTD__ free (v); v = 0; } while (0)
# define  TBCIDELETE_RO(t,v,sz) do { BCHKNR(!v,NumErr,free null ptr,0); CSTD__ free (v); } while (0)
# define  REALLOC(v,os,t,s) v = (t*) CSTD__ realloc ((v), sizeof(t)*(s))
#elif !defined(NO_MALLOC_CACHE) //&& !defined(SMP)
NAMESPACE_END
# if defined(PRAGMA_I) && defined(PRAGMA_IMPL_MALLOC_CACHE)
#  pragma implementation "malloc_cache.h"
# endif
# include "malloc_cache.h"
NAMESPACE_TBCI
#else           /* ! C_MEMALLOC && NO_MALLOC_CACHE */
# define  NEW(t,s) new t[s]
# define  TBCIDELETE(t,v,sz) do { BCHKNR(!v,NumErr,delete[] null ptr,0); delete[] _VOID v; v = 0; } while (0)
# define  TBCIDELETE_RO(t,v,sz) do { BCHKNR(!v,NumErr,delete[] null ptr,0); delete[] _VOID v; } while (0)
# ifdef ALLOW_MEMCPY
#  define  REALLOC(v,os,t,s) do {                               \
    t* _tmp = (v);                                              \
    if (LIKELY(s)) (v) = new t[(s)]; else (v) = 0;              \
    if (LIKELY(_tmp != (v) && _tmp && (v) && (os) && (s)))      \
      CSTD__ memcpy ((v), _tmp, sizeof(t)*MIN((os),(s)));       \
    if (LIKELY(_tmp)) delete[] (_tmp);                          \
} while (0)
# else
#  define  REALLOC(v,os,t,s) do {                                       \
    t* _tmp = (v);                                                      \
    if (LIKELY(s)) (v) = new t[(s)]; else (v) = 0;                      \
    if (LIKELY(_tmp != (v) && _tmp && (v) && (os) && (s))) {            \
        for (REGISTER unsigned long _i = 0; _i < MIN((s),(os)); _i++)   \
            (v)[_i] = _tmp[_i]; }                                       \
    if (LIKELY(_tmp)) delete[] (_tmp);                                  \
   } while (0)
# endif
#endif

#if defined(C_MEMALLOC) || defined(ALLOW_MEMCPY)
# if defined(__GNUC__) && !defined(C_MEMALLOC_WE_KNOW_WHAT_WE_DO)
#  warning "Don't define C_MEMALLOC or ALLOW_MEMCPY if you use containers with elements which"
#  warning " use dynamic memory allocation or handle with pointers somehow. Copying otherwise"
#  warning " will break things. (Read basics.h:740)"
# endif
# define TBCICOPY(n,o,t,s) CSTD__ memcpy ((n),(o),(s)*sizeof(t))
#else
# define VEC_INLINE inline
# define COPY2(res,v1,f1,f2)    res = v1
  VKERN_TEMPL_2V(_tbci_copy,COPY2)
# ifdef SMP
template <typename T> 
void _par_copy (const unsigned long sz, T* v1, const T* v2);
#  define TBCICOPY(n,o,t,s) _par_copy < t > (s,n,o)
# else
#  define TBCICOPY(n,o,t,s) _tbci_copy < t > (s,n,o)
#endif  
# undef VEC_INLINE
#endif
        

#if defined(C_MEMALLOC) || defined(ALLOW_MEMSET)
# define TBCICLEAR(n,t,s) CSTD__ memset ((n), 0, (s)*sizeof(t))
#else
# define VEC_INLINE /*inline*/
# define FILL1(res,f1,f2)       res = f2
  VKERN_TEMPL_1V_C(_tbci_fill,FILL1)
# ifdef SMP
template <typename T>
void  _par_fill (const unsigned long, T * const, typename tbci_traits<T>::loop_const_refval_type);
#  define TBCIFILL(n,v,t,s) _par_fill < t > (s,n,v)
#  define TBCICLEAR(n,t,s) _par_fill < t > (s,n,t(0))
# else
#  define TBCIFILL(n,v,t,s) _tbci_fill < t > (s,n,v)
#  define TBCICLEAR(n,t,s) _tbci_fill < t > (s,n,t(0))
# endif
# undef VEC_INLINE
#endif

template <typename T>
class vec_fill_fn {
    public:
        T (*fn)(const unsigned long idx, void* par);
        vec_fill_fn(T (*f)(const unsigned long, void*))
                :fn(f) {};
};

template <typename T>
void _tbci_fill_fn(const unsigned long sz, T* vec, vec_fill_fn<T> fn, void* par)
{
        for (REGISTER unsigned long i = 0; i < sz; ++i)
                vec[i] = fn.fn(i, par);
}


#if defined(C_MEMALLOC) || defined(ALLOW_MEMCMP)
# define TBCICOMP(n,o,t,s) CSTD__ memcmp ((n),(o),(s)*sizeof(t))
// Filling
# define TBCIFILL(n,v,t,s)                                      \
  do { for (REGISTER unsigned long _i = 0; _i < (s); _i++)      \
                (n)[_i] = (t)(v);       } while (0)
#else
# if defined(__GNUG__) && !defined(PEDANTIC)
#  define _TBCICOMP(n,o,t,s) ({                                         \
        REGISTER int _r; REGISTER unsigned long _i;             \
        for (_r=0, _i=0; _i<(s) && !_r; _i++) {                 \
                _r = (int)((n)[_i] != (o)[_i]);                 \
                if (_r) break;                                  \
        }                                                       \
        _r;                                                     \
})
# else          

HOTDECL(template <typename T>
inline int _tbci_comp (const unsigned long s, T const *n, T const *o))
{
        // if (n == o) return 0;
        for (REGISTER unsigned long _i = 0; _i < (s); _i++)
                if (UNLIKELY((n)[_i] != (o)[_i])) return 1;
        return 0;
}       
#  define TBCICOMP(n,o,t,s) _tbci_comp ((s),(n),(o))
# endif
#endif

#define VEC_INLINE /*inline*/
#define COMP2(r,v1,f1,f2)       if (r != v1) { ++f2; i = sz; goto _fin; /* break; */ }
VKERN_TEMPL_2V_T(do_vv_comp, COMP2, volatile long);
#ifdef SMP
template <typename T> 
int _par_comp (const unsigned long sz, const T* v1, const T* v2);
# define TBCICOMP(n,o,t,s) _par_comp< t > (s, n, o)
#else 
# define TBCICOMP(n,o,t,s) ({ long res; do_vv_comp<t>(s,n,o,res); res; })
#endif
#undef VEC_INLINE

// Helper functions

template <typename T>
unsigned long _bin_search(const T* vec, T el, unsigned long start, unsigned long end)
{
        if (end == start || end-1 == start)
                return (unsigned long)-1;
        unsigned long half = (end+start)/2;
        T hel = vec[half];
        if (hel == el)
                return half;
        else if (hel < el)
                return _bin_search(vec, el, half, end);
        else
                return _bin_search(vec, el, start, half);
}

template <typename T>
unsigned long bin_search(const T* vec, T el, unsigned long start, unsigned long end)
{
        if (end == start)
                return (unsigned long)-1;
        if (vec[start] == el)
                return start;
        else if (vec[end-1] == el)
                return end-1;
        if (vec[start] > el)
                return (unsigned long)-1;
        if (vec[end-1] < el)
                return (unsigned long)-1;
        BCHK(vec[end-1] < vec[start], NumErr, unsorted vector in bin_search, end-1, (unsigned long)-1);
        return _bin_search(vec, el, start, end);
}

NAMESPACE_END

NAMESPACE_CPLX
#define _REF_
TBCI_CONST(inline int      conj (const int _REF_  arg))         {return arg;}
TBCI_CONST(inline unsigned conj (const unsigned _REF_  arg))    {return arg;}
TBCI_CONST(inline long     conj (const long _REF_  arg))        {return arg;}
TBCI_CONST(inline short    conj (const short _REF_  arg))       {return arg;}
TBCI_CONST(inline char     conj (const char _REF_  arg))        {return arg;}
TBCI_CONST(inline float    conj (const float _REF_  arg))       {return arg;}
TBCI_CONST(inline double   conj (const double _REF_  arg))      {return arg;}

TBCI_CONST(inline int      real (const int _REF_  d))           { return d; }
TBCI_CONST(inline unsigned real (const unsigned _REF_  d))      { return d; }
TBCI_CONST(inline float    real (const float _REF_  d))         { return d; }
TBCI_CONST(inline double   real (const double _REF_  d))        { return d; }

TBCI_CONST(inline int      imag (const int _REF_  d))           { return 0; }
TBCI_CONST(inline unsigned imag (const unsigned _REF_  d))      { return 0; }
TBCI_CONST(inline float    imag (const float _REF_  d))         { return 0; }
TBCI_CONST(inline double   imag (const double _REF_  d))        { return 0; }

#ifdef HAVE_LONG_DOUBLE
TBCI_CONST(inline long double conj (const long double _REF_  arg))      {return arg;}
TBCI_CONST(inline long double real (const long double _REF_  d))        { return d; }
TBCI_CONST(inline long double imag (const long double _REF_  d))        { return 0; }
#endif
#ifdef HAVE_LONG_LONG
TBCI_CONST(inline long long     conj (const long long _REF_  arg))      {return arg;}
TBCI_CONST(inline long long     real (const long long _REF_  d))        { return d; }
TBCI_CONST(inline long long     imag (const long long _REF_  d))        { return 0; }
#endif
#undef _REF_
NAMESPACE_CPLX_END
                
#ifdef _INCLUDE_CPLX_H
# include "cplx.h"
#endif

#ifdef _INCLUDE_STDCPLX_H
# include "std_cplx.h"
#endif
                
#ifdef _INCLUDE_BUILTINCPLX_H
# include "builtin_cplx.h"
#endif
                

NAMESPACE_TBCI
// intel C++ 6.00 has a preprocessor (!) bug
#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 600)
template <typename T> inline int sign (const T& x)
#else                   
TBCI_CONST(template <typename T> inline int sign (const T& x))
#endif                          
{
  if     (LIKELY(CPLX__ real(x) > 0)) return  1;
  else if(LIKELY(CPLX__ real(x) < 0)) return -1;
  else return 0;
}

#ifdef TEMPLATED_FABSSQR
TBCI_CONST(template <typename T> inline double fabssqr (const T& a))
{ return CPLX__ real(a * CPLX__ conj(a)); }
#else
# define FABSSQR(T)                             \
TBCI_CONST(inline double fabssqr (const T a))   \
{ return CPLX__ real(a * CPLX__ conj(a)); }
        
FABSSQR(double)
FABSSQR(float)
FABSSQR(int)
FABSSQR(unsigned)
# ifdef HAVE_LONG_DOUBLE
FABSSQR(long double)
# endif
# ifdef HAVE_LONG_LONG
FABSSQR(long long)
# endif
# undef FABSSQR
#endif  /* TEMPLATED_FABSSQR */

// Square
#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 600)
template <typename T> inline T sqr (const T& a)
#else
TBCI_CONST(template <typename T> inline T sqr (const T& a))
#endif                  
{ return a*a; }

// Dot product  
#if !defined(HAVE_WIN_32) && !defined (NO_NS) // Problems with other dot
# if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 600)
template <typename T> inline T dot (const T& a1, const T& a2)
# else
TBCI_CONST(template <typename T> inline T dot (const T& a1, const T& a2))
# endif                 
{ return a1 * CPLX__ conj (a2); }
#endif

NAMESPACE_END

NAMESPACE_CSTD
                
#if 0
/* For the std namespace, we don't want to use templated functions */
TBCI_CONST(template <typename T> inline double fabs (const T& a))
{ return a<(T)0?(double)-a:(double)a; }

#else
        
/* hopefully the std::fabs(double) is not extern "C" ... */
# define FABS(T)                                \
TBCI_CONST(inline double fabs (const T a))      \
{ return a<(T)0?(double)-a:(double)a; }
/* Also provide sqrt(int) functions ... */
# define SQRT(T)                                \
TBCI_CONST(inline double sqrt (const T a))      \
{ return MATH__ sqrt ((double)a); }

# ifdef HAVE_LONG_DOUBLE
#  if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ < 97
FABS(long double)
SQRT(long double)
#  endif
# endif
//FABS(float);
FABS(int)
SQRT(int)
//SQRT(unsigned int); // MSVC does not like it ...
# ifdef HAVE_LONG_LONG
FABS(long long)
SQRT(long long)
# endif
//FABS(unsigned int); // MSVC should not like it either ...
TBCI_CONST(inline double fabs (const unsigned int a))
{ return (double)a; }

# undef FABS
#endif  /* 0 */

NAMESPACE_CSTD_END

NAMESPACE_CSTD
#if 0
/* For the std namespace, we don't want to use templated functions */
TBCI_CONST(template <typename T> inline T abs (const T& a))
{ return a<(T)0?-a:a; }

#else

# define ABS(T)                                 \
TBCI_CONST(inline T abs (const T a))            \
{ return a<(T)0?-a:a; }

# ifdef HAVE_MISS_CSTD_ABS_BUG
#  ifdef HAVE_LONG_DOUBLE
ABS(long double)
#  endif
ABS(double)
ABS(float)
#  ifdef HAVE_LONG_LONG
//ABS(long long)
#  endif
//ABS(unsigned)
# endif

# if 1 //defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 600)
ABS(unsigned)
# endif 
# undef ABS
#endif  /* 0 */

NAMESPACE_CSTD_END

#ifdef INLINE_VEC_KERNELS
# define VEC_INLINE inline
#else
# define VEC_INLINE  
#endif
                
NAMESPACE_TBCI

enum _vararg { vag0=0, vag1, vag2, vag3, vag4, vag5, vag6, vag7, vag8,
               vag9, vag10, vag11, vag12, vag13, vag14, vag15, vag16,
                vag_max = 4294967295U};

typedef enum _vararg vararg;

NAMESPACE_END

#ifndef _NO_INCLUDE_COST_H              
# include "cost.h"
#endif

#if !defined(NO_NS) && defined (USING_STD_NS)
using std::cin;
using std::cout;
using std::cerr;
using std::endl;
using std::flush;
using std::dec;
using std::hex;
using std::setw;
using std::setprecision;
using std::istream;
using std::ostream;
using std::ifstream;
using std::ofstream;
using std::string;      
# if defined(HAVE_SSTREAM) && !defined(HAVE_BUGGY_SSTREAM)
using std::istringstream;
using std::ostringstream;
# else
using std::istrstream;
using std::ostrstream;
# endif
#endif

#endif /* TBCI_BASICS_H */