1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":92,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"vectors-4-AVX.h"},"src_code":{"kind":"string","value":"// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors.cc\nvectors-8-SSE2.h\nmacros/vectors-8-AVX.h\nmacros/vectors-4-default.h\nmacros/vectors-4-SSE.h\nmacros/vectors-8-default.h\nmacros/vectors-8-SSE2.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":93,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"vectors.cc"},"src_code":{"kind":"string","value":"#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors-4-AVX.h\nvectors-8-SSE2.h\nmacros/vectors-8-AVX.h\nmacros/vectors-4-default.h\nmacros/vectors-4-SSE.h\nmacros/vectors-8-default.h\nmacros/vectors-8-SSE2.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":94,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"vectors-8-SSE2.h"},"src_code":{"kind":"string","value":"// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors-4-AVX.h\nvectors.cc\nmacros/vectors-8-AVX.h\nmacros/vectors-4-default.h\nmacros/vectors-4-SSE.h\nmacros/vectors-8-default.h\nmacros/vectors-8-SSE2.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":95,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"macros/vectors-8-AVX.h"},"src_code":{"kind":"string","value":"// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors-4-AVX.h\nvectors.cc\nvectors-8-SSE2.h\nmacros/vectors-4-default.h\nmacros/vectors-4-SSE.h\nmacros/vectors-8-default.h\nmacros/vectors-8-SSE2.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":96,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"macros/vectors-4-default.h"},"src_code":{"kind":"string","value":"// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors-4-AVX.h\nvectors.cc\nvectors-8-SSE2.h\nmacros/vectors-8-AVX.h\nmacros/vectors-4-SSE.h\nmacros/vectors-8-default.h\nmacros/vectors-8-SSE2.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":97,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"macros/vectors-4-SSE.h"},"src_code":{"kind":"string","value":"// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors-4-AVX.h\nvectors.cc\nvectors-8-SSE2.h\nmacros/vectors-8-AVX.h\nmacros/vectors-4-default.h\nmacros/vectors-8-default.h\nmacros/vectors-8-SSE2.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":98,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"macros/vectors-8-default.h"},"src_code":{"kind":"string","value":"// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors-4-AVX.h\nvectors.cc\nvectors-8-SSE2.h\nmacros/vectors-8-AVX.h\nmacros/vectors-4-default.h\nmacros/vectors-4-SSE.h\nmacros/vectors-8-SSE2.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-SSE2.h:\n```\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}},{"rowIdx":99,"cells":{"thorn_name":{"kind":"string","value":"CactusUtils/Vectors"},"url":{"kind":"string","value":"https://bitbucket.org/cactuscode/cactusutils.git"},"configuration":{"kind":"string","value":"# Configuration definitions for thorn Vectors\n\nPROVIDES Vectors\n{\n SCRIPT configure.sh\n LANG bash\n OPTIONS \\\n VECTORISE \\\n VECTORISE_ALIGNED_ARRAYS \\\n VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \\\n VECTORISE_ALWAYS_USE_ALIGNED_LOADS \\\n VECTORISE_INLINE \\\n VECTORISE_STREAMING_STORES\n}\n\nREQUIRES Vectors\n"},"interface":{"kind":"string","value":"# Interface definition for thorn Vectors\n\nIMPLEMENTS: Vectors\n\nINCLUDE HEADER: vectors.h IN vectors.h\n"},"param":{"kind":"string","value":"# Parameter definitions for thorn Vectors\n\nBOOLEAN verbose \"Verbose output during vector tests\"\n{\n} \"no\"\n"},"schedule":{"kind":"string","value":"# Schedule definitions for thorn Vectors\n\nschedule Vectors_Startup at CCTK_STARTUP\n{\n LANG: C\n} \"Print startup message\"\n\nschedule Vectors_Test at CCTK_PARAMCHECK\n{\n LANG: C\n} \"Run correctness tests.\"\n"},"src_filename":{"kind":"string","value":"macros/vectors-8-SSE2.h"},"src_code":{"kind":"string","value":"// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m128d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n long long i[2];\n double f[2];\n __m128i vi;\n __m128d vf;\n};\n\n#define K8_IMIN ((long long)0x8000000000000000ULL)\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm_set1_pd(a))\n#define vec8_set(a,b) (_mm_set_pd(b,a)) // note reversed arguments\n\n// original order is 01\n#define vec8_swap10(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1)); \\\n })\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm_load_pd(&(p)))\n#define vec8_loadu(p) (_mm_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n _mm_shuffle_pd(vec8_load((&p)[-1]), \\\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) vec8_store(p,x)\n#else\n# define vec8_store_nta(p,x) (_mm_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_stream_sd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_stream_sd(&p+1, vec8_swap10(x)); \\\n } \\\n })\n#else\n# define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store_nta(p,x); \\\n } else if (v8stp_lo) { \\\n _mm_storel_pd(&p,x); \\\n } else if (v8stp_hi) { \\\n _mm_storeh_pd(&p+1,x); \\\n } \\\n })\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_storel_pd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) (_mm_storeh_pd(&(p)+1,x))\n#else\n# if defined(__SSE4A__)\n# define vec8_store_nta_partial_lo(p,x,n) (_mm_stream_sd(&(p),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm_stream_sd(&(p)+1, vec8_swap10(x)))\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\n# define vec8_store_nta_partial_lo(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storel_pd(&p,x); \\\n /* _mm_clflush(&p); */ \\\n })\n# define vec8_store_nta_partial_hi(p_,x,n) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n _mm_storeh_pd(&p+1,x); \\\n /* _mm_clflush(&p+1); */ \\\n })\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\n#define vec8_store_nta_partial_lo(p,x,n) \\\n vec8_store_nta(p, _mm_loadh_pd(x,&(p)+1))\n#define vec8_store_nta_partial_hi(p,x,n) \\\n vec8_store_nta(p, _mm_loadl_pd(x,&(p)))\n#endif\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, }};\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\n#define k8neg(x) (_mm_xor_pd(k8sign_mask.vf,x))\n\n#define k8add(x,y) (_mm_add_pd(x,y))\n#define k8sub(x,y) (_mm_sub_pd(x,y))\n#define k8mul(x,y) (_mm_mul_pd(x,y))\n#define k8div(x,y) (_mm_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm_or_pd(_mm_andnot_pd(k8sign_mask.vf,x), \\\n _mm_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm_max_pd(x,y))\n#define k8fmin(x,y) (_mm_min_pd(x,y))\n#define k8fnabs(x) (_mm_or_pd(k8sign_mask.vf,x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_pd(vec8_set1(0.0), x); \\\n CCTK_REAL_VEC const sign = _mm_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_pd(vec8_set1(1.0), sign); \\\n k8ifthen(iszero, vec8_set1(0.0), signedone); \\\n })\n#define k8sqrt(x) (_mm_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ = {{ +0LL, +0LL, }};\nstatic const k8const_t k8ltrue_ = {{ -1LL, -1LL, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm_and_pd(x,y))\n#define k8lor(x,y) (_mm_or_pd(x,y))\n#define k8lxor(x,y) (_mm_xor_pd(x,y))\n\n#ifdef __SSE4_1__\n# define k8ifthen(x,y,z) (_mm_blendv_pd(z,y,x))\n#elif 0\n// This is slow (but this is what Intel/PGI produce by themselves)\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n int const m = _mm_movemask_pd(x); \\\n CCTK_REAL8_VEC r; \\\n switch (m) { \\\n case 0: r = y; break; \\\n case 1: r = _mm_move_sd(y,z); break; \\\n case 2: r = _mm_move_sd(z,y); break; \\\n case 3: r = z; break; \\\n } \\\n r; \\\n })\n#elif 0\n# ifdef __cplusplus\n# define k8signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k8signbit(x) (signbit(x))\n# endif\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n vec8_set(k8signbit(vec8_elt0(x)) ? vec8_elt0(y) : vec8_elt0(z), \\\n k8signbit(vec8_elt1(x)) ? vec8_elt1(y) : vec8_elt1(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\nstatic const k8const_t k8ione = {{ 0x1ULL, 0x1ULL, }};\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1 */ \\\n __m128i const x_int = *(__m128i const*)&x; \\\n __m128i const imask_int = \\\n _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi); \\\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y)); \\\n })\n#else\n# define k8ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const z__=(z_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n CCTK_REAL8_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_pd(_mm_and_pd(x, y), _mm_andnot_pd(x, z)); \\\n })\n#endif\n\n#define k8cmpeq(x,y) (_mm_cmpeq_pd(x,y))\n#define k8cmpne(x,y) (_mm_cmpneq_pd(x,y))\n#define k8cmpgt(x,y) (_mm_cmpgt_pd(x,y))\n#define k8cmpge(x,y) (_mm_cmpge_pd(x,y))\n#define k8cmplt(x,y) (_mm_cmplt_pd(x,y))\n#define k8cmple(x,y) (_mm_cmple_pd(x,y))\n"},"context_filenames":{"kind":"string","value":"vectors-8-VSX.h\nvectors-8-DoubleHummer.h\nvectors-8-AVX.h\nvectors-4-default.h\nvectors-4-SSE.h\nvectors-8-MIC.h\nvectors.h\nvectors-8-default.h\nvectors-4-Altivec.h\nmake.code.defn\ntest.cc\nvectors-8-QPX.h\nvectors-4-AVX.h\nvectors.cc\nvectors-8-SSE2.h\nmacros/vectors-8-AVX.h\nmacros/vectors-4-default.h\nmacros/vectors-4-SSE.h\nmacros/vectors-8-default.h\nindirect/vectors-intel.hh\nindirect/vectors-default.hh\nindirect/vectors-power.hh\nindirect/vectors-pseudo.hh\nindirect/vectors.hh\n"},"context":{"kind":"string","value":"vectors-8-VSX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec VSX (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>\n\n\n\n#include <altivec.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"VSX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector double CCTK_REAL8_VEC;\ntypedef vector signed long long CCTK_INTEGER8_VEC;\ntypedef vector bool long long CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef long long CCTK_INTEGER8;\ntypedef unsigned long long CCTK_BOOLEAN8;\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#define vec8_set1i(a) (vec_splats(a))\n#define vec8_set(a,b) \\\n ({ \\\n CCTK_REAL8_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x; \\\n })\n\n#define vec8_elt0(x) ((x)[0])\n#define vec8_elt1(x) ((x)[1])\n// #define vec8_elt(x,d) ((x)[d])\n// #define vec8_elti(x,d) ((x)[d])\n// #define vec8_eltb(x,d) ((x)[d])\nstatic inline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC x, int d) { return x[d]; }\nstatic inline CCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC x,int d) { return x[d]; }\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (*(CCTK_REAL8_VEC const*)&(p))\n#define vec8_loadu(p) (*(CCTK_REAL8_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n#define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n#define vec8_storeu(p,x) (*(CCTK_REAL8_VEC*)&(p)=(x))\n// stvxl instruction doesn't exist for double precision\n#define vec8_store_nta(p,x) vec8_store(p,x)\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL8_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=(x)[0])\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=(x)[1])\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (vec_madd(x,y,z))\n#define k8msub(x,y,z) (vec_msub(x,y,z))\n#define k8nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k8nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k8copysign(x,y) (vec_cpsgn(y,x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x,y) (vec_max(x,y))\n#define k8fmin(x,y) (vec_min(x,y))\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__=(x_); \\\n CCTK_REAL8_VEC x=x__; \\\n CCTK_BOOLEAN8_VEC iszero = k8cmpeq(x,vec8_set1((CCTK_REAL8)0.0)); \\\n CCTK_REAL8_VEC signedone = k8copysign(vec8_set1((CCTK_REAL8)1.0),x); \\\n k8ifthen(iszero, vec8_set1((CCTK_REAL8)0.0), signedone); \\\n })\n#define k8sqrt(x) (vec_sqrt(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is -1LL, canonical false is 0LL\n// truth values are interpreted bit-wise\n// #define k8lfalse ({ CCTK_BOOLEAN8_VEC dummy; vec_xor(dummy,dummy); })\n// #define k8ltrue (k8lnot(k8lfalse))\nstatic inline CCTK_BOOLEAN8_VEC k8lfalse1()\n{\n CCTK_BOOLEAN8_VEC dummy;\n return vec_xor(dummy,dummy);\n}\n#define k8lfalse (k8lfalse1())\n#define k8ltrue (k8lnot(k8lfalse))\n\n// #define k8lnot(x_) \\\n// ({ \\\n// CCTK_BOOLEAN8_VEC x__=(x_); \\\n// CCTK_BOOLEAN8_VEC x=x__; \\\n// vec_nor(x,x); \\\n// })\nstatic inline CCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC x)\n{\n return vec_nor(x,x);\n}\n\n#define k8land(x,y) (vec_and(x,y))\n#define k8lor(x,y) (vec_or(x,y))\n#define k8lxor(x,y) (vec_xor(x,y))\n#define k8ifthen(x,y,z) (vec_sel(z,y,x))\n\n#define k8cmpeq(x,y) (vec_cmpeq(x,y))\n#define k8cmpne(x,y) (k8lnot(vec_cmpeq(x,y)))\n#define k8cmpgt(x,y) (vec_cmpgt(x,y))\n#define k8cmpge(x,y) (vec_cmpge(x,y))\n#define k8cmplt(x,y) (vec_cmplt(x,y))\n#define k8cmple(x,y) (vec_cmple(x,y))\n\n```\n\nvectors-8-DoubleHummer.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/P Double Hummer (Power)\n\n// Use the type double _Complex directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>\n\n\n\n#include <assert.h>\n\n#ifdef __cplusplus\n# include <builtins.h>\n#endif\n\n\n\n#define vec8_architecture \"Double Hummer\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC double _Complex\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n\n\n\nunion k8const_t {\n double f[2];\n unsigned long long i[2];\n CCTK_REAL8_VEC vf;\n};\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (__cmplx(a,a))\n#define vec8_set(a,b) (__cmplx(a,b))\n\n#define vec8_elt0(x) (__creal(x))\n#define vec8_elt1(x) (__cimag(x))\n#define vec8_elt(x_,d) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 a; \\\n switch (d) { \\\n case 0: a=vec8_elt0(x); break; \\\n case 1: a=vec8_elt1(x); break; \\\n } \\\n a; \\\n })\n#define vec8_elti(x,d) vec8_elt(x,d)\n#define vec8_eltb(x,d) vec8_elt(x,d)\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (__lfpd((CCTK_REAL8 *)&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n vec8_set((&p)[0],(&p)[1]); \\\n })\n#else\n#if 0\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = __lfxd((CCTK_REAL8 *)(&p-1)); \\\n CCTK_REAL8_VEC const hi = __lfxd((CCTK_REAL8 *)(&p+1)); \\\n __fpsel(vec8_set(-1.0,+1.0),lo,hi); \\\n })\n#endif\n# define vec8_load_off1(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n CCTK_REAL8_VEC const lo = vec8_load((&p)[-1]); \\\n CCTK_REAL8_VEC const hi = vec8_load((&p)[+1]); \\\n __fxmr(__fpsel(vec8_set(+1.0,-1.0),lo,hi)); \\\n })\n#endif\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n int const off = (ptrdiff_t)&p & 0xf; \\\n off==0 ? vec8_load(p) : vec8_load_off1(p); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) vec8_loadu(p)\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu(p)\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (__stfpd(&(p),x))\n#define vec8_storeu(p,x) (__stfpd(&(p),x)) // this may not work\n#define vec8_store_nta(p,x) (__stfpd(&(p),x)) // this doesn't avoid the cache\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin,imax) \\\n bool const v8stp_lo = (i)>=(imin); \\\n bool const v8stp_hi = (i)+CCTK_REAL_VEC_SIZE-1<(imax)\n#define vec8_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL8& p__=(p_); \\\n CCTK_REAL8& p=p__; \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_lo and v8stp_hi, true)) { \\\n vec8_store(p,x); \\\n } else if (v8stp_lo) { \\\n (&p)[0]=vec8_elt0(x); \\\n } else if (v8stp_hi) { \\\n (&p)[1]=vec8_elt1(x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p,x,n) ((&(p))[0]=vec8_elt0(x))\n#define vec8_store_nta_partial_hi(p,x,n) ((&(p))[1]=vec8_elt1(x))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) assert(0)\n\n\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (__fpneg(x))\n\n#define k8add(x,y) (__fpadd(x,y))\n#define k8sub(x,y) (__fpsub(x,y))\n#define k8mul(x,y) (__fpmul(x,y))\n// Estimate for reciprocal\n#define k8inv_init(x) (__fpre(x))\n// One Newton iteration for reciprocal\n#define k8inv_iter(x_,r_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const r__=(r_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r=r__; \\\n /* r + r * (1 - x*r) */ \\\n k8madd(r, k8nmsub(x, r, vec8_set1(1.0)), r); \\\n })\n// Reciprocal: First estimate, then apply two Newton iterations\n#define k8inv(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const r0 = k8inv_init(x); \\\n CCTK_REAL8_VEC const r1 = k8inv_iter(x,r0); \\\n CCTK_REAL8_VEC const r2 = k8inv_iter(x,r1); \\\n r2; \\\n })\n#define k8div(x,y) (__fpmul(x,k8inv(y)))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (__fpmadd(z,x,y))\n#define k8msub(x,y,z) (__fpmsub(z,x,y))\n#define k8nmadd(x,y,z) (__fpnmadd(z,x,y))\n#define k8nmsub(x,y,z) (__fpnmsub(z,x,y))\n\n// Cheap functions\n// TODO: handle -0 correctly\n#define k8copysign(x,y) (k8ifthen(y,k8fabs(x),k8fnabs(x)))\n#define k8fabs(x) (__fpabs(x))\n#define k8fmax(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(y,x),x,y); \\\n })\n#define k8fmin(x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n __fpsel(k8sub(x,y),x,y); \\\n })\n#define k8fnabs(x) (__fpnabs(x))\nstatic const k8const_t k8zero = {{ 0.0, 0.0, }};\nstatic const k8const_t k8one = {{ +1.0, +1.0, }};\nstatic const k8const_t k8mone = {{ -1.0, -1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = k8fnabs(x); \\\n CCTK_REAL_VEC signedone = k8ifthen(x, k8one.vf, k8mone.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n// Estimate for reciprocal square root\n#define k8rsqrt_init(x) (__fprsqrte(x))\n// One Newton iteration for reciprocal square root\n#define k8rsqrt_iter(x_,rs_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const rs__=(rs_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs=rs__; \\\n /* rs (3/2 - x/2 rs^2) */ \\\n k8mul(rs, k8msub(vec8_set1(1.5), x2, k8mul(rs, rs))); \\\n })\n// Reciprocal square root: First estimate, then apply two Newton iterations\n#define k8rsqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const rs0 = k8rsqrt_init(x); \\\n CCTK_REAL8_VEC const x2 = k8mul(vec8_set1(0.5),x); \\\n CCTK_REAL8_VEC const rs1 = k8rsqrt_iter(x2,rs0); \\\n CCTK_REAL8_VEC const rs2 = k8rsqrt_iter(x2,rs1); \\\n rs2; \\\n })\n#define k8sqrt(x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n k8mul(x, k8rsqrt(x)); \\\n })\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8fmod(x,y) K8REPL2(fmod,x,y)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true (?), nan is false (?)\nstatic const k8const_t k8lfalse_ = {{ -1.0, -1.0, }};\nstatic const k8const_t k8ltrue_ = {{ +1.0, +1.0, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (k8ifthen(x,k8lfalse,k8ltrue))\n#define k8land(x,y) (k8ifthen(x,y,k8lfalse))\n#define k8lor(x,y) (k8ifthen(x,k8ltrue,y))\n#define k8lxor(x,y) (k8ifthen(x,k8lnot(y),y))\n#define k8ifthen(x,y,z) (__fpsel(x,z,y))\n\n#define k8cmpeq(x,y) (__fpnabs((x)-(y)))\n#define k8cmpne(x,y) (k8lnot(__fpnabs((x)-(y))))\n#define k8cmpgt(x,y) (k8lnot(k8cmple(x,y)))\n#define k8cmpge(x,y) ((x)-(y))\n#define k8cmplt(x,y) (k8lnot(k8cmpge(x,y)))\n#define k8cmple(x,y) ((y)-(x))\n\n```\n\nvectors-8-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256d CCTK_REAL8_VEC;\ntypedef __m256i CCTK_INTEGER8_VEC;\ntypedef __m256i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_pd(x)\n#define R2I(x) _mm256_castpd_si256(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm256_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n return _mm256_set1_epi64x(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a,\n CCTK_REAL8 const b,\n CCTK_REAL8 const c,\n CCTK_REAL8 const d)\n{\n return _mm256_set_pd(d,c,b,a); // note reversed arguments\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_seti(CCTK_INTEGER8 const a,\n CCTK_INTEGER8 const b,\n CCTK_INTEGER8 const c,\n CCTK_INTEGER8 const d)\n{\n return _mm256_set_epi64x(d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm256_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm256_loadu_pd(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm256_stream_pd(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v8stp_mask = */\n /* _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0));\n __m128i const termup01 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0));\n __m128i const term01 = _mm_andnot_si128(termlo01, termup01);\n __m128i const termlo23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2));\n __m128i const termup23 =\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2));\n __m128i const term23 = _mm_andnot_si128(termlo23, termup23);\n mask = _mm256_insertf128_si256(_mm256_castsi128_si256(term01), term23, 1);\n }\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n vec8_store_partial_prepare_fixed_(v8stp_all, v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_fixed_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL8_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n mask = vec8_seti(i+0>=imin and i+0<imax ? ~0 : 0,\n i+1>=imin and i+1<imax ? ~0 : 0,\n i+2>=imin and i+2<imax ? ~0 : 0,\n i+3>=imin and i+3<imax ? ~0 : 0);\n }\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_store_nta(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_all, v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const all, __m256i const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec8_storeu(p, x);\n } else {\n _mm256_maskstore_pd(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\n/*static*/ k8const_t const k8store_lo[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n/*static*/ k8const_t const k8store_hi[5] =\n {\n {{ 0, 0, 0, 0, }},\n {{ 0, 0, 0, ~0, }},\n {{ 0, 0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd(&p, I2R(k8store_lo[nlo].vi & k8store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_pd(&p, k8store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_pd\n (&p,\n R2I(_mm256_and_pd(I2R(k8store_lo[nlo].vi), I2R(k8store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm256_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_or_pd(_mm256_and_pd(I2R(k8notsign), x),\n _mm256_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm256_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm256_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm256_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm256_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm256_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm256_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm256_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm256_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm256_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_pd(x, y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm256_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm256_pow_pd(x, _mm256_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm256_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm256_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm256_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm256_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm256_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm256_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm256_blendv_pd(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm256_cmp_pd(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm256_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm256_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-4-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_INT4\n#define CCTK_BOOLEAN4 CCTK_INT4\n#define CCTK_INTEGER4_VEC CCTK_INT4\n#define CCTK_BOOLEAN4_VEC CCTK_INT4\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) ((CCTK_REAL4)(a))\n// Create a vector from N scalars\n#define vec4_set(a) ((CCTK_REAL4)(a))\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n#define vec4_elti(x,d) (x)\n#define vec4_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fmod(x,y) (fmodf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL4 x__=(x_); \\\n CCTK_REAL4 x=x__; \\\n x==(CCTK_REAL4)0.0 ? (CCTK_REAL4)0.0 : std::copysign((CCTK_REAL4)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4lfalse 0\n#define k4ltrue 1\n#define k4lnot(x) (!(x))\n#define k4land(x,y) ((x) && (y))\n#define k4lor(x,y) ((x) || (y))\n#define k4lxor(x,y) (!(x) != !(y))\n\n#define k4ifthen(x,y,z) ((x)?(y):(z))\n\n#define k4cmpeq(x,y) ((x)==(y))\n#define k4cmpne(x,y) ((x)!=(y))\n#define k4cmpgt(x,y) ((x)>(y))\n#define k4cmpge(x,y) ((x)>=(y))\n#define k4cmplt(x,y) ((x)<(y))\n#define k4cmple(x,y) ((x)<=(y))\n\n```\n\nvectors-4-SSE.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstring>\n\n\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128 CCTK_REAL4_VEC;\ntypedef __m128i CCTK_INTEGER4_VEC;\ntypedef __m128i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_REAL4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_ps(x)\n#define R2I(x) _mm_castps_si128(x)\n\n\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d)\n{\n return _mm_set_ps(d,c,b,a); // note reversed arguments\n}\n\n// original order is 0123\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap1032(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(2,3,0,1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap2301(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_swap3210(CCTK_REAL4_VEC const x)\n{\n return _mm_shuffle_ps(x, x, _MM_SHUFFLE(0,1,2,3));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm_loadu_ps(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off1(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const hi2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo, hi2, _MM_SHUFFLE(2,1,3,0));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off2(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-2]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+2]);\n return _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(1,0,3,2));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load_off3(CCTK_REAL4 const& p)\n{\n CCTK_REAL4_VEC const lo = vec4_load((&p)[-1]);\n CCTK_REAL4_VEC const hi = vec4_load((&p)[+3]);\n CCTK_REAL4_VEC const lo2 = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(0,1,2,3));\n return _mm_shuffle_ps(lo2, hi, _MM_SHUFFLE(3,0,2,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n // The :? operator probably breaks with the Intel compiler\n //return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n if (off % CCTK_REAL4_VEC_SIZE == 0) return vec4_load(p);\n return vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n// We ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_partial_prepare(i, imin, imax) \\\n std::ptrdiff_t v4stp_lo_skip, v4stp_hi_skip; \\\n vec4_store_partial_prepare_(v4stp_lo_skip, v4stp_hi_skip, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(std::ptrdiff_t& lo_skip,\n std::ptrdiff_t& hi_skip,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo_skip = std::max(std::ptrdiff_t(0), imin - i);\n hi_skip = std::max(std::ptrdiff_t(0), i+CCTK_REAL4_VEC_SIZE - imax);\n}\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v8stp_lo_skip, v8stp_hi_skip, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(std::ptrdiff_t const lo_skip,\n std::ptrdiff_t const hi_skip,\n CCTK_REAL4& p,\n CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo_skip==0 and hi_skip==0, true)) {\n vec4_store_nta(p, x);\n } else {\n // these cases fall through\n switch (lo_skip) {\n case 0:\n (&p)[0] = vec4_elt(x, 0);\n case 1:\n if (hi_skip>=3) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (hi_skip>=2) break;\n (&p)[2] = vec4_elt(x, 2);\n case 3:\n if (hi_skip>=1) break;\n (&p)[3] = vec4_elt(x, 3);\n }\n }\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[2] = vec4_elt(x, 2);\n case 2: (&p)[1] = vec4_elt(x, 1);\n case 1: (&p)[0] = vec4_elt(x, 0);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const n)\n{\n // these cases fall through\n switch (n) {\n case 3: (&p)[1]=vec4_elt(x, 1);\n case 2: (&p)[2]=vec4_elt(x, 2);\n case 1: (&p)[3]=vec4_elt(x, 3);\n }\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n std::ptrdiff_t const nlo,\n std::ptrdiff_t const nhi)\n{\n // these cases fall through\n switch (nhi) {\n case 3:\n if (nlo<2) break;\n (&p)[1] = vec4_elt(x, 1);\n case 2:\n if (nlo<3) break;\n (&p)[2] = vec4_elt(x, 2);\n }\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm_xor_ps(I2R(k4sign), x);\n}\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply to AVX as well.\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n // TODO: maybe use k4inv and k4mul instead\n return _mm_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_or_ps(_mm_and_ps(I2R(k4notsign), x),\n _mm_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm_or_ps(I2R(k4sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n // TODO: maybe use rsqrt and Newton-Raphson\n return _mm_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm_pow_ps(x, _mm_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_ps(z,y,I2R(x));\n#elif 0\n return vec4_set(std::signbit(vec4_elt(x,0)) ? vec4_elt(y,0) : vec4_elt(z,0),\n std::signbit(vec4_elt(x,1)) ? vec4_elt(y,1) : vec4_elt(z,1),\n std::signbit(vec4_elt(x,2)) ? vec4_elt(y,2) : vec4_elt(z,2),\n std::signbit(vec4_elt(x,3)) ? vec4_elt(y,3) : vec4_elt(z,3));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n CCTK_REAL4_VEC const mask = (__m128)_mm_srai_epi32((__m128i)x, 31);\n // (z & ~mask) | (y & mask)\n return _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_ps(_mm_and_ps(I2R(x), y), _mm_andnot_ps(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpeq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpneq_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpgt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmpge_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmplt_ps(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm_cmple_ps(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors-8-MIC.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's MIC\n\n// Use the type __m512d directly, without introducing a wrapper class\n\n// See\n// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>\n// and\n// <http://software.intel.com/sites/default/files/forum/278102/327364001en.pdf>.\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n#include <immintrin.h>\n\n\n\n#define vec8_architecture \"MIC (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\ntypedef __m512d CCTK_REAL8_VEC;\ntypedef __m512i CCTK_INTEGER8_VEC;\ntypedef __mmask8 CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef bool CCTK_BOOLEAN8;\n\n\n\n#define k8sign (vec8i_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8i_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm512_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8i_set1i(CCTK_INT8 const a)\n{\n return _mm512_set1_epi64(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a0,\n CCTK_REAL8 const a1,\n CCTK_REAL8 const a2,\n CCTK_REAL8 const a3,\n CCTK_REAL8 const a4,\n CCTK_REAL8 const a5,\n CCTK_REAL8 const a6,\n CCTK_REAL8 const a7)\n{\n return _mm512_set_pd(a7,a6,a5,a4,a3,a2,a1,a0); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n return _mm512_mask2int(x) & (1 << d);\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm512_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n CCTK_REAL8_VEC x = _mm512_undefined_pd();\n x = _mm512_loadunpacklo_pd(x, &p);\n x = _mm512_loadunpackhi_pd(x, &p+8);\n return x;\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS is not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm512_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: Intel erratum suggests that hi should come before lo\n _mm512_packstorehi_pd(&p+8, x);\n _mm512_packstorelo_pd(&p , x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n#if VECTORISE_STREAMING_STORES\n // non-temporal hint:\n // _mm512_extstore_pd(&p, x, _MM_DOWNCONV_PD_NONE, _MM_HINT_NT);\n // no-read hint:\n _mm512_storenr_pd(&p, x);\n _mm_clevict(&p, _MM_HINT_T1);\n // no-read hint, not globally ordered (requires fence?):\n // _mm512_storenrngo_pd(&p, x);\n // _mm_clevict(&p, _MM_HINT_T1);\n\n#else\n _mm512_store_pd(&p, x);\n#endif\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n __mmask8 v8stp_mask; \\\n vec8_store_partial_prepare_(v8stp_mask, i, imin, imax)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(__mmask8& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n unsigned char m = 255;\n if (i < imin) {\n /* clear lower imin-i bits */\n m &= 255 << (imin-i);\n }\n if (i+CCTK_REAL8_VEC_SIZE > imax) {\n /* clear upper i+CCTK_REAL8_VEC_SIZE-imax bits */\n m &= 255 >> (i+CCTK_REAL8_VEC_SIZE-imax);\n }\n mask = _mm512_int2mask(m);\n}\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(__mmask8 const mask,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n // TODO: use vec8_store_nta(p, x) if all=true?\n _mm512_mask_store_pd(&p, mask, x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 >> (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm512_mask_store_pd(&p, _mm512_int2mask(255 << (8-n)), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm512_mask_store_pd\n (&p, _mm512_int2mask((255 >> (8-nlo)) & (255 << (8-nhi))), x);\n}\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n // Could also multiply by -1\n // Could also invert sign bit\n return _mm512_sub_pd(_mm512_set1_pd(0.0), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmadd_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm512_fnmadd_pd(x, y, z);\n}\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC iy = _mm512_castpd_si512(y);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(_mm512_and_epi64(k8notsign, ix),\n _mm512_and_epi64(k8sign , iy));\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmax(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_and_epi64(k8notsign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmax_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_gmin_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n // Could also do k8fmin(x, k8neg(x))\n CCTK_INTEGER8_VEC ix = _mm512_castpd_si512(x);\n CCTK_INTEGER8_VEC ir = _mm512_or_epi64(k8sign, ix);\n return _mm512_castsi512_pd(ir);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm512_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n// These implementations are very expensive\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)), \\\n f(vec8_elt(x,2)), \\\n f(vec8_elt(x,3)), \\\n f(vec8_elt(x,4)), \\\n f(vec8_elt(x,5)), \\\n f(vec8_elt(x,6)), \\\n f(vec8_elt(x,7)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a), \\\n f(vec8_elt(x,2),a), \\\n f(vec8_elt(x,3),a), \\\n f(vec8_elt(x,4),a), \\\n f(vec8_elt(x,5),a), \\\n f(vec8_elt(x,6),a), \\\n f(vec8_elt(x,7),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)), \\\n f(vec8_elt(x,2),vec8_elt(y,2)), \\\n f(vec8_elt(x,3),vec8_elt(y,3)), \\\n f(vec8_elt(x,4),vec8_elt(y,4)), \\\n f(vec8_elt(x,5),vec8_elt(y,5)), \\\n f(vec8_elt(x,6),vec8_elt(y,6)), \\\n f(vec8_elt(x,7),vec8_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\n// These implementations lead to an ICE with icpc 13.0.1\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm512_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm512_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm512_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm512_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm512_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm512_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm512_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm512_pow_pd(x, _mm512_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm512_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm512_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm512_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm512_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n// TODO: try k8lxor(x,x) and k8lxnor(x,x)\n#define k8lfalse (_mm512_int2mask( 0))\n#define k8ltrue (_mm512_int2mask(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return _mm512_knot(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kand(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return _mm512_kxor(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n // This leads to an ICE\n // return _mm512_mask_blend_pd(x, z, y);\n#if 0\n // This works:\n return _mm512_mask_mov_pd(z, x, y);\n#endif\n // Intel suggests this:\n return x==0 ? z : _mm512_mask_blend_pd(x, z, y);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpeq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpneq_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnle_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmpnlt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmplt_pd_mask(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm512_cmple_pd_mask(x, y);\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_BOOLEAN8_VEC const isneg = k8cmplt(x, vec8_set1(0.0));\n return k8ifthen(iszero, vec8_set1(0.0),\n k8ifthen(isneg, vec8_set1(-1.0), vec8_set1(+1.0)));\n}\n\n```\n\nvectors.h:\n```\n// -*-C++-*-\n\n#ifndef VECTORS_H\n#define VECTORS_H\n\n#include <cctk.h>\n\n\n\n#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }\n\n\n\n#if VECTORISE\n\n# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-4-AVX.h\"\n# elif defined __SSE__ // Intel SSE\n# include \"vectors-4-SSE.h\"\n# elif defined __ALTIVEC__ // Power Altivec\n# include \"vectors-4-Altivec.h\"\n# endif\n\n# if defined __MIC__ // Intel MIC\n# include \"vectors-8-MIC.h\"\n# elif defined __AVX__ && !defined DISABLE_AVX // Intel AVX\n# include \"vectors-8-AVX.h\"\n# elif defined __SSE2__ // Intel SSE2\n# include \"vectors-8-SSE2.h\"\n# elif defined __bgq__ && defined __VECTOR4DOUBLE__ // Blue Gene/Q QPX\n# include \"vectors-8-QPX.h\"\n# elif defined __ALTIVEC__ && defined _ARCH_PWR7 // Power VSX\n# include \"vectors-8-VSX.h\"\n# elif defined _ARCH_450D // Blue Gene/P Double Hummer\n# include \"vectors-8-DoubleHummer.h\"\n# endif\n\n#endif\n\n// Default implementation, do not vectorise\n#ifndef CCTK_REAL4_VEC_SIZE\n# include \"vectors-4-default.h\"\n#endif\n#ifndef CCTK_REAL8_VEC_SIZE\n# include \"vectors-8-default.h\"\n#endif\n\n\n\n// Operation counters\n#ifndef VEC_COUNT\n# define VEC_COUNT(x)\n#endif\n// This expects variables declared as\n// ptrdiff_t vec_op_counter, vec_mem_counter;\n#define vec_op_inc ((void)(VEC_COUNT(vec_op_counter+=CCTK_REAL_VEC_SIZE)+0))\n#define vec_mem_inc ((void)(VEC_COUNT(vec_mem_counter+=CCTK_REAL_VEC_SIZE)+0))\n\n\n\n// Define macros for CCTK_REAL\n\n#if defined CCTK_REAL_PRECISION_4 \n\n# define vec_architecture vec4_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL4_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL4_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER4\n# define CCTK_BOOLEAN CCTK_BOOLEAN4\n# define CCTK_INTEGER_VEC CCTK_INTEGER4_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN4_VEC\n\n# define vec_set1 vec4_set1\n# define vec_set vec4_set\n\n# define vec_elt vec4_elt\n# define vec_elti vec4_elti\n# define vec_eltb vec4_eltb\n\n# define vec_load(p) (vec_mem_inc, vec4_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec4_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec4_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec4_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec4_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec4_store_nta(p,x))\n# define vec_store_partial_prepare vec4_store_partial_prepare\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec4_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec4_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec4_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec4_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec4_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k4neg(x))\n\n# define kadd(x,y) (vec_op_inc, k4add(x,y))\n# define ksub(x,y) (vec_op_inc, k4sub(x,y))\n# define kmul(x,y) (vec_op_inc, k4mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k4div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k4madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k4msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k4nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k4nmsub(x,y,z))\n\n# define kacos k4acos\n# define kacosh k4acosh\n# define kasin k4asin\n# define kasinh k4asinh\n# define katan k4atan\n# define katan2 k4atan2\n# define katanh k4atanh\n# define kcopysign(x,y) (vec_op_inc, k4copysign(x,y))\n# define kcos k4cos\n# define kcosh k4cosh\n# define kexp k4exp\n# define kfabs(x) (vec_op_inc, k4fabs(x))\n# define kfmax(x,y) (vec_op_inc, k4fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k4fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k4fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k4fnabs(x))\n# define klog k4log\n# define kpow k4pow\n# define ksignbit(x) (vec_op_inc, k4signbit(x))\n# define ksin k4sin\n# define ksinh k4sinh\n# define ksgn k4sgn\n# define ksqrt k4sqrt\n# define ktan k4tan\n# define ktanh k4tanh\n\n# define klfalse k4lfalse\n# define kltrue k4ltrue\n# define klnot k4lnot\n# define kland k4land\n# define klor k4lor\n# define klxor k4lxor\n# define kifthen k4ifthen\n\n# define kcmpeq k4cmpeq\n# define kcmpne k4cmpne\n# define kcmpgt k4cmpgt\n# define kcmpge k4cmpge\n# define kcmplt k4cmplt\n# define kcmple k4cmple\n\n#elif defined CCTK_REAL_PRECISION_8 \n\n# define vec_architecture vec8_architecture\n\n# define CCTK_REAL_VEC CCTK_REAL8_VEC\n# define CCTK_REAL_VEC_SIZE CCTK_REAL8_VEC_SIZE\n# define CCTK_INTEGER CCTK_INTEGER8\n# define CCTK_BOOLEAN CCTK_BOOLEAN8\n# define CCTK_INTEGER_VEC CCTK_INTEGER8_VEC\n# define CCTK_BOOLEAN_VEC CCTK_BOOLEAN8_VEC\n\n# define vec_set1 vec8_set1\n# define vec_set vec8_set\n\n# define vec_elt vec8_elt\n# define vec_elti vec8_elti\n# define vec_eltb vec8_eltb\n\n# define vec_load(p) (vec_mem_inc, vec8_load(p))\n# define vec_loadu(p) (vec_mem_inc, vec8_loadu(p))\n# define vec_loadu_maybe(off,p) (vec_mem_inc, vec8_loadu_maybe(off,p))\n# define vec_loadu_maybe3(off1,off2,off3,p) \\\n (vec_mem_inc, vec8_loadu_maybe3(off1,off2,off3,p))\n# define vec_store(p,x) (vec_mem_inc, vec8_store(p,x))\n# define vec_store_nta(p,x) (vec_mem_inc, vec8_store_nta(p,x))\n# define vec_store_partial_prepare vec8_store_partial_prepare\n# define vec_store_partial_prepare_fixed \\\n vec8_store_partial_prepare_fixed\n# define vec_store_nta_partial(p,x) (vec_mem_inc, vec8_store_nta_partial(p,x))\n# define vec_storeu_partial(p,x) (vec_mem_inc, vec8_storeu_partial(p,x))\n# define vec_store_nta_partial_lo vec8_store_nta_partial_lo\n# define vec_store_nta_partial_hi vec8_store_nta_partial_hi\n# define vec_store_nta_partial_mid vec8_store_nta_partial_mid\n\n# define kneg(x) (vec_op_inc, k8neg(x))\n\n# define kadd(x,y) (vec_op_inc, k8add(x,y))\n# define ksub(x,y) (vec_op_inc, k8sub(x,y))\n# define kmul(x,y) (vec_op_inc, k8mul(x,y))\n# define kdiv(x,y) (vec_op_inc, k8div(x,y))\n\n# define kmadd(x,y,z) (vec_op_inc, vec_op_inc, k8madd(x,y,z))\n# define kmsub(x,y,z) (vec_op_inc, vec_op_inc, k8msub(x,y,z))\n# define knmadd(x,y,z) (vec_op_inc, vec_op_inc, k8nmadd(x,y,z))\n# define knmsub(x,y,z) (vec_op_inc, vec_op_inc, k8nmsub(x,y,z))\n\n# define kacos k8acos\n# define kacosh k8acosh\n# define kasin k8asin\n# define kasinh k8asinh\n# define katan k8atan\n# define katan2 k8atan2\n# define katanh k8atanh\n# define kcopysign(x,y) (vec_op_inc, k8copysign(x,y))\n# define kcos k8cos\n# define kcosh k8cosh\n# define kexp k8exp\n# define kfabs(x) (vec_op_inc, k8fabs(x))\n# define kfmax(x,y) (vec_op_inc, k8fmax(x,y))\n# define kfmin(x,y) (vec_op_inc, k8fmin(x,y))\n# define kfmod(x,y) (vec_op_inc, k8fmod(x,y))\n# define kfnabs(x) (vec_op_inc, k8fnabs(x))\n# define klog k8log\n# define kpow k8pow\n# define ksignbit(x) (vec_op_inc, k8signbit(x))\n# define ksin k8sin\n# define ksinh k8sinh\n# define ksgn k8sgn\n# define ksqrt k8sqrt\n# define ktan k8tan\n# define ktanh k8tanh\n\n# define klfalse k8lfalse\n# define kltrue k8ltrue\n# define klnot k8lnot\n# define kland k8land\n# define klor k8lor\n# define klxor k8lxor\n# define kifthen k8ifthen\n\n# define kcmpeq k8cmpeq\n# define kcmpne k8cmpne\n# define kcmpgt k8cmpgt\n# define kcmpge k8cmpge\n# define kcmplt k8cmplt\n# define kcmple k8cmple\n\n#else\n\n# error \"Unknown CCTK_REAL_PRECISION\"\n\n#endif\n\n\n\n// Deprecated\n#define kifmsb(a,b,c) kifthen(a,b,c)\n#define kifneg(a,b,c) kifmsb(a,b,c)\n#define kifpos(a,b,c) kifmsb(a,c,b)\n\n#define kisgn(a) (-42424242)\n\n\n\n#if CCTK_REAL_VEC_SIZE == 1\n# define vec_index vec_set(0)\n#elif CCTK_REAL_VEC_SIZE == 2\n# define vec_index vec_set(0,1)\n#elif CCTK_REAL_VEC_SIZE == 4\n# define vec_index vec_set(0,1,2,3)\n#elif CCTK_REAL_VEC_SIZE == 8\n# define vec_index vec_set(0,1,2,3,4,5,6,7)\n#elif CCTK_REAL_VEC_SIZE == 16\n# define vec_index vec_set(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)\n#else\n# error \"Unsupported vector size\"\n#endif\n\n \n\n// Define a class template for easier access from C++\n\n#ifdef __cplusplus\n\n#include <cmath>\n#include <cstdlib>\n\ntemplate<typename T>\nstruct vecprops {\n typedef T scalar_t;\n typedef T vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size()\n {\n return 1;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return a;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, std::ptrdiff_t const d)\n {\n return x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return -x;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return x+y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return x-y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return x*y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return x/y;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return x*y+z;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return std::sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL4> {\n typedef CCTK_REAL4 scalar_t;\n typedef CCTK_REAL4_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL4_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec4_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec4_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec4_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec4_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k4neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k4add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k4sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k4mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k4div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k4madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k4sqrt(x);\n }\n};\n\ntemplate<>\nstruct vecprops<CCTK_REAL8> {\n typedef CCTK_REAL8 scalar_t;\n typedef CCTK_REAL8_VEC vector_t;\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n int size()\n {\n return CCTK_REAL8_VEC_SIZE;\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t load (scalar_t const& a)\n {\n return vec8_load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t loadu (scalar_t const& a)\n {\n return vec8_loadu(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t set1 (scalar_t const& a)\n {\n return vec8_set1(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt (vector_t const& x, int const d)\n {\n return vec8_elt(x,d);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t neg (vector_t const& x)\n {\n return k8neg(x);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t add (vector_t const& x, vector_t const& y)\n {\n return k8add(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sub (vector_t const& x, vector_t const& y)\n {\n return k8sub(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t mul (vector_t const& x, vector_t const& y)\n {\n return k8mul(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t div (vector_t const& x, vector_t const& y)\n {\n return k8div(x,y);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t madd (vector_t const& x, vector_t const& y, vector_t const& z)\n {\n return k8madd(x,y,z);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vector_t sqrt (vector_t const& x)\n {\n return k8sqrt(x);\n }\n};\n\ntemplate<typename T>\nclass vectype {\n typedef vecprops<T> props;\npublic:\n typedef typename props::vector_t vector_t;\n typedef typename props::scalar_t scalar_t;\n vector_t v;\n vectype() { }\n vectype(vectype const& x): v(x.v) { }\n vectype(vector_t const& x): v(x) { }\n explicit vectype(scalar_t const& a): v(props::set1(a)) { }\n operator vector_t() const { return v; }\n vectype& operator=(vectype const& x) { v=x.v; return *this; }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n std::size_t size() const {\n return props::size();\n }\n \n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype load(scalar_t const& a)\n {\n return props::load(a);\n }\n static inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype loadu(scalar_t const& a)\n {\n return props::loadu(a);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n scalar_t elt(std::ptrdiff_t const d) const\n {\n return props::elt(*this, d);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+() const\n {\n return *this;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-() const\n {\n return props::neg(*this);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator+(vectype const& x) const\n {\n return props::add(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator-(vectype const& x) const\n {\n return props::sub(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator*(vectype const& x) const\n {\n return props::mul(*this, x);\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype operator/(vectype const& x) const\n {\n return props::div(*this, x);\n }\n \n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator+=(vectype const& x)\n {\n return *this = *this+x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator-=(vectype const& x)\n {\n return *this = *this-x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator*=(vectype const& x)\n {\n return *this = *this*x;\n }\n inline CCTK_ATTRIBUTE_ALWAYS_INLINE\n vectype& operator/=(vectype const& x)\n {\n return *this = *this/x;\n }\n};\n\ntemplate<typename T>\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvectype<T> sqrt(vectype<T> const& x)\n{\n return vecprops<T>::sqrt(x);\n}\n\n#endif\n\n\n\n// Cache information\n\n// Size of a a cache line in bytes\n#ifndef CCTK_CACHELINE_SIZE\n// TODO: Determine this properly\n# define CCTK_CACHELINE_SIZE 64\n#endif\n\n// Number of CCTK_REALs in a cache line\n#define CCTK_REAL_CACHELINE_SIZE (CCTK_CACHELINE_SIZE / CCTK_REAL_PRECISION)\n// If this fails, something is most likely wrong -- this would be a\n// very weird (and inefficient?) architecture indeed\n#if CCTK_REAL_CACHELINE_SIZE % CCTK_REAL_VEC_SIZE != 0\n# error \"The cache line size is not a multiple of sizeof(CCTK_REAL_VEC)\"\n#endif\n\n\n\n// For Kranc\n\n#ifdef KRANC_C\n\n# undef KRANC_DIFF_FUNCTIONS\n# if ! VECTORISE_INLINE\n# define KRANC_DIFF_FUNCTIONS\n# endif\n\n# undef ToReal\n# define ToReal(x) (vec_set1(CCTK_REAL(x)))\n\n# undef IfThen\n# if (defined __PGI || \\\n defined _ARCH_450D || \\\n (defined __ALTIVEC__ && defined _ARCH_PWR7))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL_VEC vec_IfThen(CCTK_BOOLEAN x, CCTK_REAL_VEC y, CCTK_REAL_VEC z)\n{\n if (x) return y; else return z;\n}\n# define IfThen(x,y,z) vec_IfThen(x,y,z)\n# else\n# define IfThen(x,y,z) ((x) ? CCTK_REAL_VEC(y) : CCTK_REAL_VEC(z))\n# endif\n\n# undef KRANC_GFOFFSET3D\n# define KRANC_GFOFFSET3D(var,i,j,k) \\\n vec_loadu_maybe3((i),(j),(k), \\\n *(CCTK_REAL const*)& \\\n ((char const*)(var))[cdi*(i)+cdj*(j)+cdk*(k)])\n\n#endif // KRANC_C\n\n#endif // #ifndef VECTORS_H\n\n```\n\nvectors-8-default.h:\n```\n// -*-C++-*-\n// Fallback vectorisation implementation: Do not vectorise\n\n\n\n#include <cassert>\n#include <cmath>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_INT8\n#define CCTK_INTEGER8_VEC CCTK_INT8\n#define CCTK_BOOLEAN8_VEC CCTK_INT8\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) ((CCTK_REAL8)(a))\n// Create a vector from N scalars\n#define vec8_set(a) ((CCTK_REAL8)(a))\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n#define vec8_elti(x,d) (x)\n#define vec8_eltb(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (CCTK_BUILTIN_UNREACHABLE())\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (CCTK_BUILTIN_UNREACHABLE())\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (std::copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fmod(x,y) (fmod(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n#define k8signbit(x) (std::signbit(x))\n\n#define k8lfalse 0\n#define k8ltrue 1\n#define k8lnot(x) (!(x))\n#define k8land(x,y) ((x) && (y))\n#define k8lor(x,y) ((x) || (y))\n#define k8lxor(x,y) (!(x) != !(y))\n\n#define k8ifthen(x,y,z) ((x)?(y):(z))\n\n#define k8cmpeq(x,y) ((x)==(y))\n#define k8cmpne(x,y) ((x)!=(y))\n#define k8cmpgt(x,y) ((x)>(y))\n#define k8cmpge(x,y) ((x)>=(y))\n#define k8cmplt(x,y) ((x)<(y))\n#define k8cmple(x,y) ((x)<=(y))\n\nstatic inline CCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n return x==(CCTK_REAL8)0.0 ? (CCTK_REAL8)0.0 : k8copysign((CCTK_REAL8)1.0, x);\n}\n\n```\n\nvectors-4-Altivec.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Altivec (Power)\n\n// Use the type vector double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <altivec.h>\n\n\n\n#define vec4_architecture \"Altivec\"\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC vector float\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (vec_splats(a))\n#define vec4_set(a,b,c,d) \\\n ({ \\\n CCTK_REAL4_VEC x; \\\n x[0]=(a); \\\n x[1]=(b); \\\n x[2]=(c); \\\n x[3]=(d); \\\n x; \\\n })\n\n#define vec4_elt0(x) ((x)[0])\n#define vec4_elt1(x) ((x)[1])\n#define vec4_elt2(x) ((x)[2])\n#define vec4_elt3(x) ((x)[3])\n#define vec4_elt(x,d) ((x)[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (*(CCTK_REAL4_VEC const*)&(p))\n#define vec4_loadu(p) (*(CCTK_REAL4_VEC const*)&(p))\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#define vec4_loadu_maybe(off,p) (vec4_loadu(p))\n#define vec4_loadu_maybe3(off1,off2,off3,p) (vec4_loadu(p))\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#define vec4_storeu(p,x) (*(CCTK_REAL4_VEC*)&(p)=(x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) (vec4_store(p,x))\n#else\n// use stvxl instruction\n# define vec4_store_nta(p,x) (vec_stl(x,0,(CCTK_REAL4_VEC*)&(p)))\n#endif\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[2]=x[2]; \\\n case 2: (&p)[1]=x[1]; \\\n case 1: (&p)[0]=x[0]; \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n switch (n) { \\\n case 3: (&p)[1]=x[1]; \\\n case 2: (&p)[2]=x[2]; \\\n case 1: (&p)[3]=x[3]; \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo_,nhi_) \\\n ({ \\\n CCTK_REAL4 const& p__ =(p_); \\\n CCTK_REAL4_VEC const x__ =(x_); \\\n int const nlo__=(nlo_); \\\n int const nhi__=(nhi_); \\\n CCTK_REAL4 const& p =p__; \\\n CCTK_REAL4_VEC const x =x__; \\\n int const nlo=nlo__; \\\n int const nhi=nhi__; \\\n if (nlo==3 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n (&p)[2]=x[2]; \\\n } else if (nlo==2 and nhi==3) { \\\n (&p)[1]=x[1]; \\\n } else if (nlo==3 and nhi==2) { \\\n (&p)[2]=x[2]; \\\n } \\\n })\n\n\n\n// Functions and operators\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (vec_madd(x,y,z))\n#define k4msub(x,y,z) (vec_msub(x,y,z))\n#define k4nmadd(x,y,z) (vec_nmadd(x,y,z))\n#define k4nmsub(x,y,z) (vec_nmsub(x,y,z))\n\n// Cheap functions\n#define k4fabs(x) (vec_abs(x))\n#define k4fmax(x,y) (vec_max(x,y))\n#define k4fmin(x,y) (vec_min(x,y))\n#define k4fnabs(x) (vec_nabs(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4fmod(x,y) K4REPL2(fmodf,x,y)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\n#define k4ifmsb(x,y,z) \\\n (vec_sel((z), (y), vec_sra(vec_convert((x), &(vector int*)0), 31)))\n\n```\n\nmake.code.defn:\n```\n# Main make.code.defn file for thorn Vectors\n\n# Source files in this directory\nSRCS = vectors.cc test.cc\n\n# Subdirectories containing source files\nSUBDIRS = \n\n```\n\ntest.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\n#include <cassert>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <limits>\n\nusing namespace std;\n\ninline CCTK_REAL my_sgn(CCTK_REAL const x) {\n return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_REAL)1.0, x);\n}\n\n#define SCALARTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL const res = (scalarexpr); \\\n CCTK_REAL const vecres = (vecexpr); \\\n CCTK_REAL const eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: expected %.17g, received %.17g\", \\\n testname, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } while (0)\n\n#define VECTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_REAL_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_REAL res = (scalarexpr); \\\n CCTK_REAL vecres = vec_elt(rv, i); \\\n CCTK_REAL eps = numeric_limits<CCTK_REAL>::epsilon(); \\\n if ((fabs(vecres - res) <= 10 * eps) or \\\n (CCTK_isnan(vecres) and CCTK_isnan(res))) { \\\n passed++; \\\n } else { \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %.17g, received %.17g\", \\\n testname, i, (double)res, (double)vecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\n#define VECBITTEST(testname, vecexpr, scalarexpr) \\\n do { \\\n if (verbose) { \\\n CCTK_VInfo(CCTK_THORNSTRING, \"Test %s...\", testname); \\\n fflush(stdout); \\\n } \\\n CCTK_BOOLEAN_VEC rv = (vecexpr); \\\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) { \\\n CCTK_BOOLEAN res = (scalarexpr); \\\n CCTK_BOOLEAN vecres = vec_eltb(rv, i); \\\n if (memcmp(&vecres, &res, sizeof vecres) == 0) { \\\n passed++; \\\n } else { \\\n CCTK_INTEGER ires, ivecres; \\\n memcpy(&ires, &res, sizeof ires); \\\n memcpy(&ivecres, &vecres, sizeof ivecres); \\\n CCTK_VParamWarn(CCTK_THORNSTRING, \\\n \"Failed test %s: \" \\\n \"for element %d, expected %lld, received %lld\", \\\n testname, i, (long long)ires, (long long)ivecres); \\\n } \\\n numtests++; \\\n } \\\n } while (0)\n\nextern \"C\" void Vectors_Test(CCTK_ARGUMENTS) {\n DECLARE_CCTK_ARGUMENTS;\n DECLARE_CCTK_PARAMETERS;\n\n CCTK_INFO(\"Testing vectorisation... [errors may result in segfaults]\");\n fflush(stdout);\n\n char testname[100];\n\n int passed = 0, numtests = 0;\n\n CCTK_REAL a[CCTK_REAL_VEC_SIZE];\n CCTK_REAL b[CCTK_REAL_VEC_SIZE];\n CCTK_REAL c[CCTK_REAL_VEC_SIZE];\n CCTK_REAL x[CCTK_REAL_VEC_SIZE]; // small\n CCTK_REAL y[CCTK_REAL_VEC_SIZE]; // small and positive\n CCTK_REAL z[CCTK_REAL_VEC_SIZE]; // >=1\n\n for (int i = 0; i < CCTK_REAL_VEC_SIZE; i++) {\n a[i] = (i + 1) * 1.23456789;\n b[i] = -(i + 1) * 9.87654321;\n c[i] = (i + 1) * 1.01010101;\n x[i] = (i + 1) * 0.00123 * (i % 2 ? +1 : -1);\n y[i] = (i + 1) * 0.00234;\n z[i] = (i)*0.00234 + 1.0;\n }\n\n CCTK_REAL_VEC av = vec_loadu(a[0]);\n CCTK_REAL_VEC bv = vec_loadu(b[0]);\n CCTK_REAL_VEC cv = vec_loadu(c[0]);\n CCTK_REAL_VEC xv = vec_loadu(x[0]);\n CCTK_REAL_VEC yv = vec_loadu(y[0]);\n CCTK_REAL_VEC zv = vec_loadu(z[0]);\n\n /* l and lv are similar to a and av, except that it is larger, and\n guaranteed to be aligned */\n CCTK_REAL_VEC lv[4];\n lv[0] = vec_loadu(a[0]);\n lv[1] = vec_loadu(b[0]);\n lv[2] = vec_loadu(c[0]);\n lv[3] = vec_loadu(a[0]);\n CCTK_REAL *const l = (CCTK_REAL *)&lv[0];\n\n /* s and sv are similar to a and av, but are aligned and not\n initialised */\n CCTK_REAL_VEC sv;\n CCTK_REAL *const s = (CCTK_REAL *)&sv;\n\n VECTEST(\"vec_set1\", vec_set1(a[0]), a[0]);\n#if CCTK_REAL_VEC_SIZE == 1\n VECTEST(\"vec_set\", vec_set(a[0]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 2\n VECTEST(\"vec_set\", vec_set(a[0], a[1]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 4\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3]), a[i]);\n#elif CCTK_REAL_VEC_SIZE == 8\n VECTEST(\"vec_set\", vec_set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]),\n a[i]);\n#else\n#error \"Unsupported vector size\"\n#endif\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_elt[%d]\", d);\n SCALARTEST(testname, vec_elt(av, d), a[d]);\n }\n\n /* These tests will probably fail with a segfault, if they fail */\n VECTEST(\"vec_load\", vec_load(*l), l[i]);\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu[%d]\", d);\n VECTEST(testname, vec_loadu(l[d]), l[i + d]);\n }\n for (int d = 0; d < CCTK_REAL_VEC_SIZE; ++d) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe[%d]\", d);\n VECTEST(testname, vec_loadu_maybe(d, l[d]), l[i + d]);\n }\n for (int d1 = 0; d1 < CCTK_REAL_VEC_SIZE; ++d1) {\n for (int d2 = 0; d2 < CCTK_REAL_VEC_SIZE; ++d2) {\n for (int d3 = 0; d3 < CCTK_REAL_VEC_SIZE; ++d3) {\n if (not(VECTORISE and VECTORISE_ALIGNED_ARRAYS) or\n (d2 == 0 and d3 == 0)) {\n snprintf(testname, sizeof testname, \"vec_loadu_maybe3[%d,%d,%d]\", d1,\n d2, d3);\n VECTEST(testname, vec_loadu_maybe3(d1, d2, d3, l[d1 + d2 + d3]),\n l[i + d1 + d2 + d3]);\n }\n }\n }\n }\n\n /* These tests may fail with a segfault, if they fail */\n sv = av;\n vec_store(*s, bv);\n VECTEST(\"vec_store\", sv, b[i]);\n sv = av;\n vec_store_nta(*s, bv);\n VECTEST(\"vec_store_nta\", sv, b[i]);\n int const arenaitems = 3;\n int const arenasize = arenaitems * CCTK_REAL_VEC_SIZE;\n for (int ilo = 0; ilo < arenasize; ++ilo) {\n for (int ihi = 0; ihi < arenasize; ++ihi) {\n // Initialise arena to a everywhere\n for (int n = 0; n < arenaitems; ++n) {\n lv[n] = av;\n }\n // Set arena to b in the \"interior\"\n for (int i = (ilo & -CCTK_REAL_VEC_SIZE); i < ihi;\n i += CCTK_REAL_VEC_SIZE) {\n vec_store_partial_prepare(i, ilo, ihi);\n vec_store_nta_partial(l[i], bv);\n }\n for (int i = 0; i < arenasize; ++i) {\n snprintf(testname, sizeof testname, \"vec_store_nta_partial[%d..%d][%d]\",\n ilo, ihi, i);\n SCALARTEST(\n testname, l[i],\n (i >= ilo and i < ihi ? b : a)[i & (CCTK_REAL_VEC_SIZE - 1)]);\n }\n }\n }\n /* The partial stores are not implemented for d==0 and\n d==CCTK_REAL_VEC_SIZE (because these are trivial) */\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_lo(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_lo[%d]\", d);\n VECTEST(testname, sv, i < d ? b[i] : a[i]);\n }\n for (int d = 1; d < CCTK_REAL_VEC_SIZE - 1; ++d) {\n sv = av;\n vec_store_nta_partial_hi(*s, bv, d);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_hi[%d]\", d);\n VECTEST(testname, sv, i >= CCTK_REAL_VEC_SIZE - d ? b[i] : a[i]);\n }\n for (int dlo = 1; dlo < CCTK_REAL_VEC_SIZE - 1; ++dlo) {\n for (int dhi = 1; dhi < CCTK_REAL_VEC_SIZE - 1; ++dhi) {\n sv = av;\n vec_store_nta_partial_mid(*s, bv, dlo, dhi);\n snprintf(testname, sizeof testname, \"vec_store_nta_partial_mid[%d,%d]\",\n dlo, dhi);\n VECTEST(testname, sv,\n i < dlo and i >= CCTK_REAL_VEC_SIZE - dhi ? b[i] : a[i]);\n }\n }\n\n VECTEST(\"kneg\", kneg(av), -a[i]);\n\n VECTEST(\"kadd\", kadd(av, bv), a[i] + b[i]);\n VECTEST(\"ksub\", ksub(av, bv), a[i] - b[i]);\n VECTEST(\"kmul\", kmul(av, bv), a[i] * b[i]);\n VECTEST(\"kdiv\", kdiv(av, bv), a[i] / b[i]);\n\n VECTEST(\"kmadd\", kmadd(av, bv, cv), +a[i] * b[i] + c[i]);\n VECTEST(\"kmsub\", kmsub(av, bv, cv), +a[i] * b[i] - c[i]);\n VECTEST(\"knmadd\", knmadd(av, bv, cv), -a[i] * b[i] - c[i]);\n VECTEST(\"knmsub\", knmsub(av, bv, cv), -a[i] * b[i] + c[i]);\n\n VECTEST(\"kacos\", kacos(xv), acos(x[i]));\n VECTEST(\"kacosh\", kacosh(zv), acosh(z[i]));\n VECTEST(\"kasin\", kasin(xv), asin(x[i]));\n VECTEST(\"kasinh\", kasinh(xv), asinh(x[i]));\n VECTEST(\"katan\", katan(xv), atan(x[i]));\n VECTEST(\"katan2\", katan2(xv, yv), atan2(x[i], y[i]));\n VECTEST(\"katanh\", katanh(xv), atanh(x[i]));\n VECTEST(\"kcopysign\", kcopysign(xv, yv), copysign(x[i], y[i]));\n VECTEST(\"kcos\", kcos(xv), cos(x[i]));\n VECTEST(\"kcosh\", kcosh(xv), cosh(x[i]));\n VECTEST(\"kexp\", kexp(xv), exp(x[i]));\n VECTEST(\"kfabs\", kfabs(xv), fabs(x[i]));\n VECTEST(\"kfmax\", kfmax(xv, yv), fmax(x[i], y[i]));\n VECTEST(\"kfmin\", kfmin(xv, yv), fmin(x[i], y[i]));\n VECTEST(\"kfmod\", kfmod(xv, yv), fmod(x[i], y[i]));\n VECTEST(\"kfnabs\", kfnabs(xv), -fabs(x[i]));\n VECTEST(\"klog\", klog(yv), log(y[i]));\n VECTEST(\"kpow\", kpow(yv, x[0]), pow(y[i], x[0]));\n VECTEST(\"ksin\", ksin(xv), sin(x[i]));\n VECTEST(\"ksinh\", ksinh(xv), sinh(x[i]));\n VECTEST(\"ksgn\", ksgn(xv), my_sgn(x[i]));\n VECTEST(\"ksqrt\", ksqrt(yv), sqrt(y[i]));\n VECTEST(\"ktan\", ktan(xv), tan(x[i]));\n VECTEST(\"ktanh\", ktanh(xv), tanh(x[i]));\n\n#if 0\n VECTEST(\"kifpos positive\",\n kifpos(av, bv, cv), CCTK_SIGNBIT(a[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos negative\",\n kifpos(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? c[i] : b[i]);\n VECTEST(\"kifpos 0\", kifpos(vec_set1(0.),bv,cv), b[i]);\n VECTEST(\"kifpos -0\", kifpos(vec_set1(-0.),bv,cv), c[i]);\n\n VECTEST(\"kifneg positive\",\n kifneg(av, bv, cv), CCTK_SIGNBIT(a[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg negative\",\n kifneg(bv, bv, cv), CCTK_SIGNBIT(b[i]) ? b[i] : c[i]);\n VECTEST(\"kifneg 0\", kifneg(vec_set1(0.),bv,cv), c[i]);\n VECTEST(\"kifneg -0\", kifneg(vec_set1(-0.),bv,cv), b[i]);\n#endif\n\n CCTK_BOOLEAN klfalse1 = vec_eltb(klfalse, 0);\n CCTK_BOOLEAN kltrue1 = vec_eltb(kltrue, 0);\n VECBITTEST(\"constant F\", klfalse, klfalse1);\n VECBITTEST(\"constant T\", kltrue, kltrue1);\n VECBITTEST(\"klnot F\", klnot(klfalse), kltrue1);\n VECBITTEST(\"klnot T\", klnot(kltrue), klfalse1);\n VECBITTEST(\"kland FF\", kland(klfalse, klfalse), klfalse1);\n VECBITTEST(\"kland FT\", kland(klfalse, kltrue), klfalse1);\n VECBITTEST(\"kland TF\", kland(kltrue, klfalse), klfalse1);\n VECBITTEST(\"kland TT\", kland(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klor FF\", klor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klor FT\", klor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klor TF\", klor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klor TT\", klor(kltrue, kltrue), kltrue1);\n VECBITTEST(\"klxor FF\", klxor(klfalse, klfalse), klfalse1);\n VECBITTEST(\"klxor FT\", klxor(klfalse, kltrue), kltrue1);\n VECBITTEST(\"klxor TF\", klxor(kltrue, klfalse), kltrue1);\n VECBITTEST(\"klxor TT\", klxor(kltrue, kltrue), klfalse1);\n VECTEST(\"kifthen F\", kifthen(klfalse, av, bv), b[i]);\n VECTEST(\"kifthen T\", kifthen(kltrue, av, bv), a[i]);\n\n VECBITTEST(\"kcmpeq\", kcmpeq(av, bv), a[i] == b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpne\", kcmpne(av, bv), a[i] != b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpgt\", kcmpgt(av, bv), a[i] > b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmpge\", kcmpge(av, bv), a[i] >= b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmplt\", kcmplt(av, bv), a[i] < b[i] ? kltrue1 : klfalse1);\n VECBITTEST(\"kcmple\", kcmple(av, bv), a[i] <= b[i] ? kltrue1 : klfalse1);\n\n CCTK_VInfo(CCTK_THORNSTRING, \"%d/%d tests passed \", passed, numtests);\n fflush(stdout);\n if (passed != numtests) {\n CCTK_VWarn(CCTK_WARN_ALERT, __LINE__, __FILE__, CCTK_THORNSTRING,\n \"Failed %d correctness tests\", numtests - passed);\n }\n}\n\n```\n\nvectors-8-QPX.h:\n```\n// -*-C++-*-\n// Vectorise using IBM's Blue Gene/Q QPX (Power)\n\n#ifndef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// Note: bgxlC_r does not like const declarations, so we need to cast\n// them away and/or omit them everywhere\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n// Argonne\n#ifdef __cplusplus\n#include <builtins.h>\n#endif\n#include <mass_simd.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\n// We use a struct to avoid the \"const\" issue\n// #define CCTK_REAL8_VEC vector4double\nstruct CCTK_REAL8_VEC {\n vector4double v;\n CCTK_REAL8_VEC() {}\n CCTK_REAL8_VEC(CCTK_REAL8_VEC const &x) : v(x.v) {}\n CCTK_REAL8_VEC(vector4double v_) : v(v_) {}\n operator vector4double() const { return v; }\n};\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_INT8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (vec_splats(a))\n#if 0\n#define vec8_set(a, b, c, d) \\\n (vec_insert( \\\n d, \\\n vec_insert(c, vec_insert(b, vec_insert(a, CCTK_REAL8_VEC(), 0), 1), 2), \\\n 3))\n#endif\n#define vec8_set(a_, b_, c_, d_) \\\n ({ \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8 const b__ = (b_); \\\n CCTK_REAL8 const c__ = (c_); \\\n CCTK_REAL8 const d__ = (d_); \\\n CCTK_REAL8 const a = a__; \\\n CCTK_REAL8 const b = b__; \\\n CCTK_REAL8 const c = c__; \\\n CCTK_REAL8 const d = d__; \\\n CCTK_REAL8_VEC x; \\\n ((CCTK_REAL8 *)&x)[0] = a; \\\n ((CCTK_REAL8 *)&x)[1] = b; \\\n ((CCTK_REAL8 *)&x)[2] = c; \\\n ((CCTK_REAL8 *)&x)[3] = d; \\\n x; \\\n })\n\n#define vec8_b2r(b) ((b) ? +1.0 : -1.0)\n#define vec8_setb(a, b, c, d) \\\n (vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d)))\n\n#define vec8_elt0(x) (vec_extract(x, 0))\n#define vec8_elt1(x) (vec_extract(x, 1))\n#define vec8_elt2(x) (vec_extract(x, 2))\n#define vec8_elt3(x) (vec_extract(x, 3))\n#define vec8_elt(x, d) (vec_extract(x, d))\n#define vec8_elts(x, a, b, c, d) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n a = ((CCTK_REAL8 *)&x)[0]; \\\n b = ((CCTK_REAL8 *)&x)[1]; \\\n c = ((CCTK_REAL8 *)&x)[2]; \\\n d = ((CCTK_REAL8 *)&x)[3]; \\\n })\n\n#define vec8_r2b(x) ((x) >= 0.0)\n#define vec8_eltb(x, d) (vec8_r2b(vec8_elt(x, d)))\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (vec_lda(0, (CCTK_REAL8 *)&(p)))\n#define vec8_loadu(p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2, vp; \\\n /* code taken from IBM's compiler documentation */ \\\n v1 = vec_ld(0, &p); /* load the left part of the vector */ \\\n v2 = vec_ld(31, &p); /* load the right part of the vector */ \\\n vp = vec_lvsl(0, &p); /* generate control value */ \\\n vec_perm(v1, v2, vp); /* generate the aligned vector */ \\\n })\n#define vec8_loadu_off(off_, p_) \\\n ({ \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p__ = (p_); \\\n int off = off__; \\\n CCTK_REAL8 &p = *(CCTK_REAL8 *)&p__; \\\n vector4double v1, v2; \\\n off &= CCTK_REAL8_VEC_SIZE - 1; \\\n v1 = vec_lda(0, &p - off); \\\n v2 = vec_lda(0, &p - off + CCTK_REAL8_VEC_SIZE); \\\n off == 1 ? vec_sldw(v1, v2, 1) : off == 2 \\\n ? vec_sldw(v1, v2, 2) \\\n : off == 3 ? vec_sldw(v1, v2, 3) \\\n : (vec8_assert(0), v1); \\\n })\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n#define vec8_loadu_maybe(off, p) vec8_loadu(p)\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu(p)\n#else\n#define vec8_loadu_maybe(off_, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n int const off__ = (off_); \\\n CCTK_REAL8 const &p = p__; \\\n int const off = off__; \\\n off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p); \\\n })\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n#define vec8_loadu_maybe3(off1, off2, off3, p) vec8_loadu_maybe(off1, p)\n#else\n#define vec8_loadu_maybe3(off1, off2, off3, p_) \\\n ({ \\\n CCTK_REAL8 const &p__ = (p_); \\\n CCTK_REAL8 const &p = p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or (off3) % CCTK_REAL8_VEC_SIZE != 0) \\\n ? vec8_loadu(p) \\\n : vec8_loadu_maybe(off1, p); \\\n })\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p, x) (vec_sta(x, 0, &(p)))\n#define vec8_storeu(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3; \\\n /* code taken from IBM's compiler documentation */ \\\n /* generate insert masks */ \\\n vp = vec_lvsr(0, &p); \\\n m1 = k8lfalse; \\\n m2 = k8ltrue; \\\n m3 = vec_perm(m1, m2, vp); \\\n v3 = vec_perm(x, x, vp); \\\n _Pragma(\"tm_atomic\") { \\\n /* get existing data */ \\\n v1 = vec_ld(0, &p); \\\n v2 = vec_ld(31, &p); \\\n /* permute and insert */ \\\n v1 = vec_sel(v1, v3, m3); \\\n v2 = vec_sel(v3, v2, m3); \\\n /* store data back */ \\\n vec_st(v1, 0, &p); \\\n vec_st(v2, 31, &p); \\\n } \\\n })\n#define vec8_store_nta(p, x) \\\n (vec_sta(x, 0, &(p))) // this doesn't avoid the cache\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) acosd4(x)\n#define k8acosh(x) acoshd4(x)\n#define k8asin(x) asind4(x)\n#define k8asinh(x) asinhd4(x)\n#define k8atan(x) atand4(x)\n#define k8atan2(x, y) atan2d4(x, y)\n#define k8atanh(x) atanhd4(x)\n#define k8cos(x) cosd4(x)\n#define k8cosh(x) coshd4(x)\n#define k8exp(x) expd4(x)\n// #define k8fmod(x,y) fmodd4(x,y)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) logd4(x)\n#define k8pow(x, a) powd4(x, vec_set1(a))\n#define k8sin(x) sind4(x)\n#define k8sinh(x) sinhd4(x)\n#define k8tan(x) tand4(x)\n#define k8tanh(x) tanhd4(x)\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\n#define k8lfalse \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0x0); \\\n })\n#define k8ltrue \\\n ({ \\\n CCTK_REAL8_VEC dummy; \\\n vec_logical(dummy, dummy, 0xf); \\\n })\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#else // #ifdef __clang__\n\n// Use the type vector4double directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n// See <http://pic.dhe.ibm.com/infocenter/compbg/v121v141/index.jsp>\n\n#include <assert.h>\n\n#define vec8_assert(x) ((void)0)\n// #define vec8_assert(x) assert(x)\n\n#include <qpxmath.h>\n\n#define vec8_architecture \"QPX\"\n\n// Vector type corresponding to CCTK_REAL\ntypedef vector4double CCTK_REAL8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_REAL8 CCTK_BOOLEAN8;\ntypedef CCTK_REAL8_VEC CCTK_INTEGER8_VEC;\ntypedef CCTK_REAL8_VEC CCTK_BOOLEAN8_VEC;\n\n// canonical true is +1.0, canonical false is -1.0\n// >=0 is true, -0 is true, nan is false\ninline CCTK_BOOLEAN8_VEC k8lfalse_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0x0);\n#pragma clang diagnostic pop\n}\ninline CCTK_BOOLEAN8_VEC k8ltrue_() {\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wuninitialized\"\n CCTK_BOOLEAN8_VEC dummy;\n return vec_logical(dummy, dummy, 0xf);\n#pragma clang diagnostic pop\n}\n#define k8lfalse k8lfalse_()\n#define k8ltrue k8ltrue_()\n\n// Create vectors, extract vector elements\n\ninline CCTK_REAL8_VEC vec8_set1(CCTK_REAL8 a) { return vec_splats(a); }\ninline CCTK_REAL8_VEC vec8_set(CCTK_REAL8 a, CCTK_REAL8 b, CCTK_REAL8 c,\n CCTK_REAL8 d) {\n return (CCTK_REAL8_VEC){a, b, c, d};\n}\n\ninline CCTK_REAL8 vec8_b2r(bool b) { return b ? +1.0 : -1.0; }\ninline CCTK_BOOLEAN8_VEC vec8_setb(bool a, bool b, bool c, bool d) {\n return vec8_set(vec8_b2r(a), vec8_b2r(b), vec8_b2r(c), vec8_b2r(d));\n}\n\ninline CCTK_REAL8 vec8_elt0(CCTK_REAL8_VEC x) { return vec_extract(x, 0); }\ninline CCTK_REAL8 vec8_elt1(CCTK_REAL8_VEC x) { return vec_extract(x, 1); }\ninline CCTK_REAL8 vec8_elt2(CCTK_REAL8_VEC x) { return vec_extract(x, 2); }\ninline CCTK_REAL8 vec8_elt3(CCTK_REAL8_VEC x) { return vec_extract(x, 3); }\ninline CCTK_REAL8 vec8_elt(CCTK_REAL8_VEC x, int d) {\n return vec_extract(x, d);\n}\n/*\ninline void vec8_elts(CCTK_REAL8_VEC x, CCTK_REAL8 &a, CCTK_REAL8 &b,\n CCTK_REAL8 &c, CCTK_REAL8 &d) {\n a = x[0];\n b = x[1];\n c = x[2];\n d = x[3];\n}\n*/\n\ninline bool vec8_r2b(CCTK_REAL8 x) { return x >= 0.0; }\ninline bool vec8_eltb(CCTK_BOOLEAN8_VEC x, int d) {\n return vec8_r2b(vec8_elt(x, d));\n}\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\ninline CCTK_REAL8_VEC vec8_load(const CCTK_REAL8 &p) {\n return vec_lda(0, (CCTK_REAL8 *)&p);\n}\ninline CCTK_REAL8_VEC vec8_loadu(const CCTK_REAL8 &p) {\n vector4double v1, v2, vp; // code taken from IBM's compiler documentation\n v1 = vec_ld(0, (CCTK_REAL8 *)&p); // load the left part of the vector\n v2 = vec_ld(31, (CCTK_REAL8 *)&p); // load the right part of the vector\n vp = vec_lvsl(0, (CCTK_REAL8 *)&p); // generate control value\n return vec_perm(v1, v2, vp); // generate the aligned vector\n}\ninline CCTK_REAL8_VEC vec8_loadu_off(ptrdiff_t off, const CCTK_REAL8 &p) {\n vector4double v1, v2;\n off &= CCTK_REAL8_VEC_SIZE - 1;\n v1 = vec_lda(0, (CCTK_REAL8 *)&p - off);\n v2 = vec_lda(0, (CCTK_REAL8 *)&p - off + CCTK_REAL8_VEC_SIZE);\n return off == 1 ? vec_sldw(v1, v2, 1) : off == 2\n ? vec_sldw(v1, v2, 2)\n : off == 3 ? vec_sldw(v1, v2, 3)\n : (vec8_assert(0), v1);\n}\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu(p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe(ptrdiff_t off, const CCTK_REAL8 &p) {\n return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_loadu_off(off, p);\n}\n#if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return vec8_loadu_maybe(off1, p);\n}\n#else\ninline CCTK_REAL8_VEC vec8_loadu_maybe3(ptrdiff_t off1, ptrdiff_t off2,\n ptrdiff_t off3, const CCTK_REAL8 &p) {\n return off2 % CCTK_REAL8_VEC_SIZE != 0 or off3 % CCTK_REAL8_VEC_SIZE != 0\n ? vec8_loadu(p)\n : vec8_loadu_maybe(off1, p);\n}\n#endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\ninline void vec8_store(CCTK_REAL8 &p, CCTK_REAL8_VEC x) { vec_sta(x, 0, &p); }\ninline void vec8_storeu(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n CCTK_REAL8_VEC v1, v2, v3, vp, m1, m2, m3;\n // code taken from IBM's compiler documentation\n // generate insert masks\n vp = vec_lvsr(0, &p);\n m1 = k8lfalse;\n m2 = k8ltrue;\n m3 = vec_perm(m1, m2, vp);\n v3 = vec_perm(x, x, vp);\n#pragma tm_atomic\n {\n // get existing data\n v1 = vec_ld(0, &p);\n v2 = vec_ld(31, &p);\n // permute and insert\n v1 = vec_sel(v1, v3, m3);\n v2 = vec_sel(v3, v2, m3);\n // store data back\n vec_st(v1, 0, &p);\n vec_st(v2, 31, &p);\n }\n}\ninline void vec8_store_nta(CCTK_REAL8 &p, CCTK_REAL8_VEC x) {\n // this doesn't avoid the cache\n return vec_sta(x, 0, &p);\n}\n\n#ifdef _OPENMP\n#if VECTORISE_ALIGNED_ARRAYS\n// Arrays are aligned; wrap-around is not an issue\n#define vec8_store_omp\n#else\n// Need to protect partial stores, as they may wrap around to the\n// beginning of the next line in the array\n#define vec8_store_omp _Pragma(\"tm_atomic\")\n#endif\n#else\n#define vec8_store_omp\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin_, imax_) \\\n bool v8stp_all; \\\n CCTK_BOOLEAN8_VEC v8stp_mask; \\\n bool v8stp_mask0, v8stp_mask1, v8stp_mask2, v8stp_mask3; \\\n ({ \\\n ptrdiff_t const imin__ = (imin_); \\\n ptrdiff_t const imax__ = (imax_); \\\n ptrdiff_t const imin = imin__; \\\n ptrdiff_t const imax = imax__; \\\n \\\n v8stp_all = i >= imin and i + CCTK_REAL8_VEC_SIZE - 1 < imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n CCTK_INTEGER8_VEC vp_lo, vp_hi; \\\n CCTK_BOOLEAN8_VEC mask_lo, mask_hi; \\\n /* this is correct but slow */ \\\n /* \\\n mask_lo = vec8_setb(i+0>=imin, i+1>=imin, i+2>=imin, i+3>=imin); \\\n mask_hi = vec8_setb(i+0<imax, i+1<imax, i+2<imax, i+3<imax); \\\n */ \\\n /* Note: vec_lvsl(i,p) = &p[i] / 8 % 4 \\\n Note: vec_lvsr(i,p) = -&p[i] / 8 % 4 \\\n /8: 8 bytes per double \\\n %4: 4 doubles per vector \\\n */ \\\n /* We assume p[i] is aligned */ \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i - imin >= -(CCTK_REAL8_VEC_SIZE - 1)); \\\n vp_lo = vec_lvsl(8 * (i - imin), (CCTK_REAL *)0); \\\n mask_lo = \\\n (i - imin >= 0 ? k8ltrue : vec_perm(k8lfalse, k8ltrue, vp_lo)); \\\n /* Ensure at least one vector element is inside the active region */ \\\n vec8_assert(i < imax); \\\n vp_hi = vec_lvsl(8 * (i - imax), (CCTK_REAL *)0); \\\n mask_hi = (i - imax < -(CCTK_REAL8_VEC_SIZE - 1) \\\n ? k8ltrue \\\n : vec_perm(k8ltrue, k8lfalse, vp_hi)); \\\n v8stp_mask = k8land(mask_lo, mask_hi); \\\n v8stp_mask0 = vec8_eltb(v8stp_mask, 0); \\\n v8stp_mask1 = vec8_eltb(v8stp_mask, 1); \\\n v8stp_mask2 = vec8_eltb(v8stp_mask, 2); \\\n v8stp_mask3 = vec8_eltb(v8stp_mask, 3); \\\n } \\\n })\n#define vec8_store_nta_partial(p_, x_) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store(p, x); \\\n } else { \\\n /* \\\n vec8_store_omp \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n */ \\\n if (VECTORISE_ALIGNED_ARRAYS) { \\\n vec8_store(p, k8ifthen(v8stp_mask, x, vec8_load(p))); \\\n } else { \\\n if (v8stp_mask0) \\\n (&p)[0] = vec8_elt0(x); \\\n if (v8stp_mask1) \\\n (&p)[1] = vec8_elt1(x); \\\n if (v8stp_mask2) \\\n (&p)[2] = vec8_elt2(x); \\\n if (v8stp_mask3) \\\n (&p)[3] = vec8_elt3(x); \\\n } \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n#define vec8_store_nta_partial_lo(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one and but all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(-8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8ltrue, k8lfalse, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_hi(p_, x_, n) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 &p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp, mask; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(n > 0 and n < CCTK_REAL8_VEC_SIZE - 1); \\\n vp = vec_lvsl(8 * n, (CCTK_REAL *)0); \\\n mask = vec_perm(k8lfalse, k8ltrue, vp); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n#define vec8_store_nta_partial_mid(p_, x_, nlo, nhi) \\\n ({ \\\n CCTK_REAL8 &p__ = (p_); \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8 p = p__; \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC vp_lo, mask_lo; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nlo > 0 and nlo < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_lo = vec_lvsl(-8 * nlo, (CCTK_REAL *)0); \\\n mask_lo = vec_perm(k8lfalse, k8ltrue, vp_lo); \\\n CCTK_REAL8_VEC vp_hi, mask_hi; \\\n /* Ensure at least one but not all vector elements are active */ \\\n vec8_assert(nhi > 0 and nhi < CCTK_REAL8_VEC_SIZE - 1); \\\n vp_hi = vec_lvsl(8 * nhi, (CCTK_REAL *)0); \\\n mask_hi = vec_perm(k8lfalse, k8ltrue, vp_hi); \\\n CCTK_REAL8_VEC mask; \\\n mask = vec_and(mask_lo, mask_hi); \\\n vec8_store_omp vec8_store(p, k8ifthen(mask, x, vec8_load(p))); \\\n })\n\n// Functions and operators\n\n// Operators\n#define k8neg(x) (vec_neg(x))\n\n#define k8add(x, y) (vec_add(x, y))\n#define k8sub(x, y) (vec_sub(x, y))\n#define k8mul(x, y) (vec_mul(x, y))\n#define k8div(x, y) (vec_swdiv_nochk(x, y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x, y, z) (vec_madd(x, y, z))\n#define k8msub(x, y, z) (vec_msub(x, y, z))\n#define k8nmadd(x, y, z) (vec_nmadd(x, y, z))\n#define k8nmsub(x, y, z) (vec_nmsub(x, y, z))\n\n// Cheap functions\n#define k8copysign(x, y) (vec_cpsgn(y, x))\n#define k8fabs(x) (vec_abs(x))\n#define k8fmax(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmplt(x, y), y, x); \\\n })\n#define k8fmin(x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC y__ = (y_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC y = y__; \\\n k8ifthen(k8cmpgt(x, y), y, x); \\\n })\n#define k8fnabs(x) (vec_nabs(x))\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL8_VEC x__ = (x_); \\\n CCTK_REAL8_VEC x = x__; \\\n CCTK_REAL8_VEC one, zero, iszero; \\\n one = k8ltrue; \\\n zero = k8sub(one, one); \\\n iszero = k8cmpeq(x, zero); \\\n k8ifthen(iszero, zero, k8copysign(one, x)); \\\n })\n#define k8sqrt(x) (vec_swsqrt_nochk(x))\n\n// Expensive functions\n\n#define K8REPL(f, x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const x = x__; \\\n vec8_set(f(vec8_elt0(x)), f(vec8_elt1(x)), f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f, x_, a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8 const a__ = (a_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8 const a = a__; \\\n vec8_set(f(vec8_elt0(x), a), f(vec8_elt1(x), a), f(vec8_elt2(x), a), \\\n f(vec8_elt3(x), a)); \\\n })\n#define K8REPL2(f, x_, y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__ = (x_); \\\n CCTK_REAL8_VEC const y__ = (y_); \\\n CCTK_REAL8_VEC const x = x__; \\\n CCTK_REAL8_VEC const y = y__; \\\n vec8_set(f(vec8_elt0(x), vec8_elt0(y)), f(vec8_elt1(x), vec8_elt1(y)), \\\n f(vec8_elt2(x), vec8_elt2(y)), f(vec8_elt3(x), vec8_elt3(y))); \\\n })\n\n#define k8acos(x) xacos(x)\n#define k8acosh(x) xacosh(x)\n#define k8asin(x) xasin(x)\n#define k8asinh(x) xasinh(x)\n#define k8atan(x) xatan(x)\n#define k8atan2(x, y) xatan2(x, y)\n#define k8atanh(x) xatanh(x)\n#define k8cos(x) xcos(x)\n#define k8cosh(x) xcosh(x)\n#define k8exp(x) xexp(x)\n#define k8fmod(x, y) K8REPL2(fmod, x, y)\n#define k8log(x) xlog(x)\n#define k8pow(x, a) xpow(x, vec_set1(a))\n#define k8sin(x) xsin(x)\n#define k8sinh(x) xsinh(x)\n#define k8tan(x) xtan(x)\n#define k8tanh(x) xtanh(x)\n\n#define k8lnot(x) (vec_not(x))\n#define k8land(x, y) (vec_and(x, y))\n#define k8lor(x, y) (vec_or(x, y))\n#define k8lxor(x, y) (vec_xor(x, y))\n#define k8ifthen(x, y, z) (vec_sel(z, y, x))\n\n#define k8cmpeq(x, y) (vec_cmpeq(x, y))\n#define k8cmpne(x, y) (k8lnot(k8cmpeq(x, y)))\n#define k8cmpgt(x, y) (vec_cmpgt(x, y))\n#define k8cmpge(x, y) (k8lnot(k8cmplt(x, y)))\n#define k8cmplt(x, y) (vec_cmplt(x, y))\n#define k8cmple(x, y) (k8lnot(k8cmpgt(x, y)))\n\n#endif\n\n```\n\nvectors-4-AVX.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256 directly, without introducing a wrapper class\n\n\n\n#include <cstdlib>\n#include <cstring>\n\n\n\n#include <immintrin.h>\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"AVX\" vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m256 CCTK_REAL4_VEC;\ntypedef __m256i CCTK_INTEGER4_VEC;\ntypedef __m256i CCTK_BOOLEAN4_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 8\n\nvec_static_assert(sizeof(CCTK_REAL4_VEC) ==\n sizeof(CCTK_REAL4) * CCTK_REAL4_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT4 CCTK_INTEGER4;\ntypedef CCTK_INT4 CCTK_BOOLEAN4;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm256_castsi256_ps(x)\n#define R2I(x) _mm256_castps_si256(x)\n\n\n\nunion k4const_t {\n CCTK_INTEGER4 i[CCTK_REAL4_VEC_SIZE];\n CCTK_INTEGER4_VEC vi;\n};\n\n#define k4sign (vec4_set1i( (CCTK_INTEGER4)(1UL << 31UL)))\n#define k4notsign (vec4_set1i(~ (CCTK_INTEGER4)(1UL << 31UL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set1(CCTK_REAL4 const a)\n{\n return _mm256_set1_ps(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4_VEC vec4_set1i(CCTK_INT4 const a)\n{\n return _mm256_set1_epi32(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_set(CCTK_REAL4 const a,\n CCTK_REAL4 const b,\n CCTK_REAL4 const c,\n CCTK_REAL4 const d,\n CCTK_REAL4 const e,\n CCTK_REAL4 const f,\n CCTK_REAL4 const g,\n CCTK_REAL4 const h)\n{\n return _mm256_set_ps(h,g,f,e,d,c,b,a); // note reversed arguments\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4 vec4_elt(CCTK_REAL4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER4 vec4_elti(CCTK_INTEGER4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4 vec4_eltb(CCTK_BOOLEAN4_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN4 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_load(CCTK_REAL4 const& p)\n{\n return _mm256_load_ps(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu(CCTK_REAL4 const& p)\n{\n return _mm256_loadu_ps(&p);\n}\n#if VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL4 const& p)\n{\n return off % CCTK_REAL4_VEC_SIZE == 0 ? vec4_load(p) : vec4_loadu(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return vec4_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC vec4_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL4 const& p)\n{\n return\n off2 % CCTK_REAL4_VEC_SIZE != 0 or\n off3 % CCTK_REAL4_VEC_SIZE != 0 ?\n vec4_loadu(p) :\n vec4_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_store_ps(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_storeu(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_storeu_ps(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return vec4_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta(CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n return _mm256_stream_ps(&p, x);\n}\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n bool v4stp_all; \\\n __m256i v4stp_mask; \\\n vec4_store_partial_prepare_(v4stp_all, v4stp_mask, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_partial_prepare_(bool& all, __m256i& mask,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n all = i>=imin and i+CCTK_REAL4_VEC_SIZE-1<imax;\n \n if (not CCTK_BUILTIN_EXPECT(all, true)) {\n /* __m256i const v4stp_mask = */\n /* _mm256_andnot_ps(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), */\n /* vec_index), */\n /* _mm256_add_epi64(_mm256_set1_epi64x(i-imax), */\n /* vec_index)); */\n __m128i const termlo0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(3, 2, 1, 0));\n __m128i const termup0123 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(3, 2, 1, 0));\n __m128i const term0123 = _mm_andnot_si128(termlo0123, termup0123);\n __m128i const termlo4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imin), _mm_set_epi32(7, 6, 5, 4));\n __m128i const termup4567 =\n _mm_add_epi32(_mm_set1_epi32(i-imax), _mm_set_epi32(7, 6, 5, 4));\n __m128i const term4567 = _mm_andnot_si128(termlo4567, termup4567);\n mask =\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0123), term4567, 1);\n }\n}\n\n#define vec4_store_nta_partial(p, x) \\\n vec4_store_nta_partial_(v4stp_all, v4stp_mask, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_(bool const all, __m256i const mask,\n CCTK_REAL4& p, CCTK_REAL4_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(all, true)) {\n vec4_store_nta(p, x);\n } else {\n _mm256_maskstore_ps(&p, mask, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic k4const_t const k4store_lo[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, 0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, 0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, 0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, 0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, 0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\nstatic k4const_t const k4store_hi[9] =\n {\n {{ 0, 0, 0, 0, 0, 0, 0, 0, }},\n {{ 0, 0, 0, 0, 0, 0, 0, ~0, }},\n {{ 0, 0, 0, 0, 0, 0, ~0, ~0, }},\n {{ 0, 0, 0, 0, 0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, 0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, 0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, 0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ 0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n {{ ~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_ps\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_hi[n].vi), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps(&p, I2R(k4store_lo[nlo].vi & k4store_hi[nhi].vi), x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_lo(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_lo[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_hi(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const n)\n{\n _mm256_maskstore_ps(&p, k4store_hi[n].vi, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec4_store_nta_partial_mid(CCTK_REAL4& p,\n CCTK_REAL4_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n _mm256_maskstore_ps\n (&p,\n R2I(_mm256_and_ps(I2R(k4store_lo[nlo].vi), I2R(k4store_hi[nhi].vi))),\n x);\n}\n#endif\n\n\n\n// Functions and operators\n\n// Operators\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4neg(CCTK_REAL4_VEC const x)\n{\n return _mm256_xor_ps(x, I2R(k4sign));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4add(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_add_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sub(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_sub_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4mul(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_mul_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4div(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_div_ps(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_macc_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_msub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmsub_ps(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_nmacc_ps(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4madd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4add(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4msub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmadd(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(k4neg(z), k4mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4nmsub(CCTK_REAL4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return k4sub(z, k4mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4copysign(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_or_ps(_mm256_and_ps(I2R(k4notsign), x),\n _mm256_and_ps(I2R(k4sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_and_ps(I2R(k4notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmax(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_max_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmin(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_min_ps(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fnabs(CCTK_REAL4_VEC const x)\n{\n return _mm256_or_ps(x, I2R(k4sign));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4signbit(CCTK_REAL4_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sqrt(CCTK_REAL4_VEC const x)\n{\n return _mm256_sqrt_ps(x);\n}\n\n\n\n// Expensive functions\n\n#define K4REPL(f,x) \\\n vec4_set(f(vec4_elt(x,0)), \\\n f(vec4_elt(x,1)), \\\n f(vec4_elt(x,2)), \\\n f(vec4_elt(x,3)), \\\n f(vec4_elt(x,4)), \\\n f(vec4_elt(x,5)), \\\n f(vec4_elt(x,6)), \\\n f(vec4_elt(x,7)));\n#define K4REPL2S(f,x,a) \\\n vec4_set(f(vec4_elt(x,0),a), \\\n f(vec4_elt(x,1),a), \\\n f(vec4_elt(x,2),a), \\\n f(vec4_elt(x,3),a), \\\n f(vec4_elt(x,4),a), \\\n f(vec4_elt(x,5),a), \\\n f(vec4_elt(x,6),a), \\\n f(vec4_elt(x,7),a));\n#define K4REPL2(f,x,y) \\\n vec4_set(f(vec4_elt(x,0),vec4_elt(y,0)), \\\n f(vec4_elt(x,1),vec4_elt(y,1)), \\\n f(vec4_elt(x,2),vec4_elt(y,2)), \\\n f(vec4_elt(x,3),vec4_elt(y,3)), \\\n f(vec4_elt(x,4),vec4_elt(y,4)), \\\n f(vec4_elt(x,5),vec4_elt(y,5)), \\\n f(vec4_elt(x,6),vec4_elt(y,6)), \\\n f(vec4_elt(x,7),vec4_elt(y,7)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return _mm256_acos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_acosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return _mm256_asin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_asinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return _mm256_atan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return _mm256_atan2_ps(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_atanh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return _mm256_cos_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return _mm256_cosh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return _mm256_exp_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n#if __ICC > 1400\n return _mm256_fmod_ps(x,y);\n#else\n return K4REPL2(fmodf,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return _mm256_log_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return _mm256_pow_ps(x, _mm256_set1_ps(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return _mm256_sin_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return _mm256_sinh_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return _mm256_tan_ps(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return _mm256_tanh_ps(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4acosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(acoshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4asinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(asinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atan2(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(atan2f,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4atanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(atanhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cos(CCTK_REAL4_VEC const x)\n{\n return K4REPL(cosf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4cosh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(coshf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4exp(CCTK_REAL4_VEC const x)\n{\n return K4REPL(expf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4fmod(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return K4REPL2(fmodf,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4log(CCTK_REAL4_VEC const x)\n{\n return K4REPL(logf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4pow(CCTK_REAL4_VEC const x, CCTK_REAL4 const a)\n{\n return K4REPL2S(powf,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sin(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sinh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(sinhf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tan(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanf,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4tanh(CCTK_REAL4_VEC const x)\n{\n return K4REPL(tanhf,x);\n}\n\n#endif\n\n\n\n#define k4lfalse (vec4_set1i( 0))\n#define k4ltrue (vec4_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lnot(CCTK_BOOLEAN4_VEC const x)\n{\n return R2I(_mm256_xor_ps(I2R(k4ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4land(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_and_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_or_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4lxor(CCTK_BOOLEAN4_VEC const x, CCTK_BOOLEAN4_VEC const y)\n{\n return R2I(_mm256_xor_ps(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4ifthen(CCTK_BOOLEAN4_VEC const x,\n CCTK_REAL4_VEC const y,\n CCTK_REAL4_VEC const z)\n{\n return _mm256_blendv_ps(z, y, I2R(x));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpeq(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_EQ_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpne(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_NEQ_UQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpgt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmpge(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_GE_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmplt(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LT_OQ));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN4_VEC k4cmple(CCTK_REAL4_VEC const x, CCTK_REAL4_VEC const y)\n{\n return R2I(_mm256_cmp_ps(x, y, _CMP_LE_OQ));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL4_VEC k4sgn(CCTK_REAL4_VEC const x)\n{\n CCTK_BOOLEAN4_VEC const iszero = k4cmpeq(x, vec4_set1(0.0));\n CCTK_REAL4_VEC const sign = _mm256_and_ps(I2R(k4sign), x);\n CCTK_REAL4_VEC const signedone = _mm256_or_ps(sign, vec4_set1(1.0));\n return k4ifthen(iszero, vec4_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nvectors.cc:\n```\n#include \"vectors.h\"\n\n#include <cctk.h>\n#include <cctk_Arguments.h>\n#include <cctk_Parameters.h>\n\nextern \"C\"\nint Vectors_Startup(void)\n{\n CCTK_VInfo(CCTK_THORNSTRING,\n \"Using vector size %d for architecture %s\",\n CCTK_REAL_VEC_SIZE, vec_architecture);\n return 0;\n}\n\n```\n\nvectors-8-SSE2.h:\n```\n// -*-C++-*-\n// Vectorise using Intel's or AMD's SSE2\n\n// Use the type __m128d directly, without introducing a wrapper class\n\n#include <cassert>\n#include <cmath>\n\n\n\n#include <emmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n\n// Intel compilers don't support SSE 4a. Here is how we can implement\n// these instructions in assembler instead:\n\n// inline void __attribute__((__always_inline__))\n// _mm_stream_sd (double *p, __m128d x)\n// {\n// asm (\"movntsd %[x],%[p]\" : \"=m\" (*p) : [p] \"m\" (*p), [x] \"x\" (x));\n// }\n\n#endif\n#ifdef __AVX__\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <x86intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec8_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec8_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec8_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec8_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"SSE2\" vec8_architecture_SSE4_1 vec8_architecture_SSE4a vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n// Note: some boolean masks (e.g. ~0) correspond to nan when\n// interpreted as floating point number. gcc 4.8 is clever enough to\n// optimize away such constants with fast-math. We therefore need to\n// handle this constant as integer number.\ntypedef __m128d CCTK_REAL8_VEC;\ntypedef __m128i CCTK_INTEGER8_VEC;\ntypedef __m128i CCTK_BOOLEAN8_VEC;\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 2\n\nvec_static_assert(sizeof(CCTK_REAL8_VEC) ==\n sizeof(CCTK_REAL8) * CCTK_REAL8_VEC_SIZE);\n\n// Integer and boolean types corresponding to this real type\ntypedef CCTK_INT8 CCTK_INTEGER8;\ntypedef CCTK_INT8 CCTK_BOOLEAN8;\n\n\n\n// These macros are undefined at the end of this file -- use them only\n// within functions, not within macros that are exported\n#define I2R(x) _mm_castsi128_pd(x)\n#define R2I(x) _mm_castpd_si128(x)\n\n\n\nunion k8const_t {\n CCTK_INTEGER8 i[CCTK_REAL8_VEC_SIZE];\n CCTK_INTEGER8_VEC vi;\n};\n\n#define k8sign (vec8_set1i( (CCTK_INTEGER8)(1ULL << 63ULL)))\n#define k8notsign (vec8_set1i(~ (CCTK_INTEGER8)(1ULL << 63ULL)))\n\n\n\n// Create vectors, extract vector elements\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set1(CCTK_REAL8 const a)\n{\n return _mm_set1_pd(a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8_VEC vec8_set1i(CCTK_INT8 const a)\n{\n#if defined(__INTEL_COMPILER)\n // Intel 11.1 does not support _mm_set1_epi64x\n return R2I(_mm_set1_pd(*(CCTK_REAL8 const*)&a));\n#else\n return _mm_set1_epi64x(a);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_set(CCTK_REAL8 const a, CCTK_REAL8 const b)\n{\n return _mm_set_pd(b,a); // note reversed arguments\n}\n\n// original order is 01\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_swap10(CCTK_REAL8_VEC const x)\n{\n return _mm_shuffle_pd(x,x, _MM_SHUFFLE2(0,1));\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8 vec8_elt(CCTK_REAL8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_REAL8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_INTEGER8 vec8_elti(CCTK_INTEGER8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_INTEGER8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8 vec8_eltb(CCTK_BOOLEAN8_VEC const x, std::ptrdiff_t const d)\n{\n CCTK_BOOLEAN8 e;\n std::memcpy(&e, &((char const*)&x)[d*sizeof e], sizeof e);\n return e;\n}\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load(CCTK_REAL8 const& p)\n{\n return _mm_load_pd(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu(CCTK_REAL8 const& p)\n{\n return _mm_loadu_pd(&p);\n}\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_load_off1(CCTK_REAL8 const& p)\n{\n return _mm_shuffle_pd(vec8_load((&p)[-1]),\n vec8_load((&p)[+1]), _MM_SHUFFLE2(0,1));\n}\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu(p);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe(std::ptrdiff_t const off, CCTK_REAL8 const& p)\n{\n // Note: This function is mis-translated by some versions of the\n // Intel compiler. The symptom is a segfault during the Vectors\n // selftest in the vec_loadu_maybe test.\n // return off % CCTK_REAL8_VEC_SIZE == 0 ? vec8_load(p) : vec8_load_off1(p);\n if (off % CCTK_REAL8_VEC_SIZE == 0) return vec8_load(p);\n return vec8_load_off1(p);\n}\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return vec8_loadu_maybe(off1, p);\n}\n# else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC vec8_loadu_maybe3(std::ptrdiff_t const off1,\n std::ptrdiff_t const off2,\n std::ptrdiff_t const off3,\n CCTK_REAL8 const& p)\n{\n return\n off2 % CCTK_REAL8_VEC_SIZE != 0 or\n off3 % CCTK_REAL8_VEC_SIZE != 0 ?\n vec8_loadu(p) :\n vec8_loadu_maybe(off1, p);\n}\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_store_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n _mm_storeu_pd(&p, x);\n}\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n vec8_store(p, x);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta(CCTK_REAL8& p, CCTK_REAL8_VEC const x)\n{\n // TODO: requires _mm_sfence() afterwards? requires _mm_lfence() in\n // readers afterwards? maybe better just an _mm_mfence() afterwards?\n _mm_stream_pd(&p, x);\n}\n#endif\n\n// TODO: Use _mm_maskstore_pd if AVX is available?\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i, imin,imax) \\\n bool v8stp_lo, v8stp_hi; \\\n vec8_store_partial_prepare_(v8stp_lo, v8stp_hi, i, imin, imax);\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_partial_prepare_(bool& lo, bool& hi,\n std::ptrdiff_t const i,\n std::ptrdiff_t const imin,\n std::ptrdiff_t const imax)\n{\n lo = i >= imin;\n hi = i+CCTK_REAL8_VEC_SIZE-1 < imax;\n}\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare_fixed(i, imin,imax) \\\n vec8_store_partial_prepare(i, imin,imax)\n\n#define vec8_store_nta_partial(p, x) \\\n vec8_store_nta_partial_(v8stp_lo, v8stp_hi, p, x)\n#if VECTORISE_STREAMING_STORES && defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_stream_sd(&p, x);\n } else if (hi) {\n _mm_stream_sd(&p+1, vec8_swap10(x));\n }\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_store_nta(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n#endif\n\n#define vec8_storeu_partial(p, x) \\\n vec8_storeu_partial_(v8stp_lo, v8stp_hi, p, x)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_storeu_partial_(bool const lo, bool const hi,\n CCTK_REAL8& p,\n CCTK_REAL8_VEC const x)\n{\n if (CCTK_BUILTIN_EXPECT(lo and hi, true)) {\n vec8_storeu(p, x);\n } else if (lo) {\n _mm_storel_pd(&p, x);\n } else if (hi) {\n _mm_storeh_pd(&p+1, x);\n }\n}\n\n// Store a lower or higher partial vector (aligned and non-temporal)\n#if ! VECTORISE_STREAMING_STORES\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n}\n#else\n# if defined(__SSE4A__)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p, x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_stream_sd(&p+1, vec8_swap10(x));\n}\n# else\n// TODO: use clflush once a whole cache line has been written (cache\n// lines are usually larger than the CPU vector size)\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storel_pd(&p, x);\n // _mm_clflush(&p);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n _mm_storeh_pd(&p+1, x);\n // _mm_clflush(&p+1);\n}\n# endif\n#endif\n#if 0\n// This is slower; we would need a non-temporal read\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_lo(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadh_pd(x, &p+1));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_hi(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const n)\n{\n vec8_store_nta(p, _mm_loadl_pd(x, &p));\n}\n#endif\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nvoid vec8_store_nta_partial_mid(CCTK_REAL8& p,\n CCTK_REAL8_VEC const x,\n ptrdiff_t const nlo,\n ptrdiff_t const nhi)\n{\n assert(0);\n}\n\n\n\n// Functions and operators\n\n// Operators\n\n// #define k8inot(x) (_mm_xor_si128(k8all_mask,x))\n// \n// #define k8iand(x,y) (_mm_and_si128(x,y))\n// #define k8ior(x,y) (_mm_or_si128(x,y))\n// #define k8ixor(x,y) (_mm_xor_si128(x,y))\n// \n// #define k8ineg(x) (_mm_xor_pd(k8sign_mask,x))\n// \n// #define k8iadd(x,y) (_mm_add_epi64(x,y))\n// #define k8isub(x,y) (_mm_sub_epi64(x,y))\n// \n// #define k8not(x) (_mm_xor_pd(k8all_mask,x))\n// \n// #define k8and(x,y) (_mm_and_pd(x,y))\n// #define k8or(x,y) (_mm_or_pd(x,y))\n// #define k8xor(x,y) (_mm_xor_pd(x,y))\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8neg(CCTK_REAL8_VEC const x)\n{\n return _mm_xor_pd(I2R(k8sign), x);\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8add(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_add_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sub(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_sub_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8mul(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_mul_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8div(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_div_pd(x, y);\n}\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_macc_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_msub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmsub_pd(x, y, z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return _mm_nmacc_pd(x, y, z);\n}\n#else\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8madd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8add(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8msub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8mul(x, y), z);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmadd(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(k8neg(z), k8mul(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8nmsub(CCTK_REAL8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n return k8sub(z, k8mul(x, y));\n}\n#endif\n\n// Cheap functions\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8copysign(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_or_pd(_mm_and_pd(I2R(k8notsign), x),\n _mm_and_pd(I2R(k8sign ), y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fabs(CCTK_REAL8_VEC const x)\n{\n return _mm_and_pd(I2R(k8notsign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmax(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_max_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmin(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_min_pd(x, y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fnabs(CCTK_REAL8_VEC const x)\n{\n return _mm_or_pd(I2R(k8sign), x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8signbit(CCTK_REAL8_VEC const x)\n{\n return R2I(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sqrt(CCTK_REAL8_VEC const x)\n{\n return _mm_sqrt_pd(x);\n}\n\n\n\n// Expensive functions\n\n#define K8REPL(f,x) \\\n vec8_set(f(vec8_elt(x,0)), \\\n f(vec8_elt(x,1)));\n#define K8REPL2S(f,x,a) \\\n vec8_set(f(vec8_elt(x,0),a), \\\n f(vec8_elt(x,1),a));\n#define K8REPL2(f,x,y) \\\n vec8_set(f(vec8_elt(x,0),vec8_elt(y,0)), \\\n f(vec8_elt(x,1),vec8_elt(y,1)));\n\n#if defined __ICC\n// The Intel compiler provides intrinsics for these\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return _mm_acos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return _mm_acosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return _mm_asin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return _mm_asinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return _mm_atan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return _mm_atan2_pd(x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return _mm_atanh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return _mm_cos_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return _mm_cosh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return _mm_exp_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n#if __ICC > 1400\n return _mm_fmod_pd(x,y);\n#else\n return K8REPL2(fmod,x,y);\n#endif\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return _mm_log_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return _mm_pow_pd(x, _mm_set1_pd(a));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return _mm_sin_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return _mm_sinh_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return _mm_tan_pd(x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return _mm_tanh_pd(x);\n}\n\n#else\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8acosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(acosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8asinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(asinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atan2(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(atan2,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8atanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(atanh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cos(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cos,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8cosh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(cosh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8exp(CCTK_REAL8_VEC const x)\n{\n return K8REPL(exp,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8fmod(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return K8REPL2(fmod,x,y);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8log(CCTK_REAL8_VEC const x)\n{\n return K8REPL(log,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8pow(CCTK_REAL8_VEC const x, CCTK_REAL8 const a)\n{\n return K8REPL2S(pow,x,a);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sin(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sin,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sinh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(sinh,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tan(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tan,x);\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8tanh(CCTK_REAL8_VEC const x)\n{\n return K8REPL(tanh,x);\n}\n\n#endif\n\n\n\n#define k8lfalse (vec8_set1i( 0))\n#define k8ltrue (vec8_set1i(~0))\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lnot(CCTK_BOOLEAN8_VEC const x)\n{\n return R2I(_mm_xor_pd(I2R(k8ltrue), I2R(x)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8land(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_and_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_or_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8lxor(CCTK_BOOLEAN8_VEC const x, CCTK_BOOLEAN8_VEC const y)\n{\n return R2I(_mm_xor_pd(I2R(x), I2R(y)));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8ifthen(CCTK_BOOLEAN8_VEC const x,\n CCTK_REAL8_VEC const y,\n CCTK_REAL8_VEC const z)\n{\n#ifdef __SSE4_1__\n return _mm_blendv_pd(z,y,I2R(x));\n#elif 0\n // This is slow (but this is what Intel/PGI produce by themselves)\n int const m = _mm_movemask_pd(x);\n switch (m) {\n case 0: return y;\n case 1: return _mm_move_sd(y,z);\n case 2: return _mm_move_sd(z,y);\n }\n return z;\n#elif 0\n return vec8_set(std::signbit(vec8_elt(x,0)) ? vec8_elt(y,0) : vec8_elt(z,0),\n std::signbit(vec8_elt(x,1)) ? vec8_elt(y,1) : vec8_elt(z,1));\n#elif 0\n // We don't need to shift -- the condition (mask) will be either all\n // zeros or all ones\n k8const_t const k8ione = {{ 1, 1, }};\n // there is no _mm_srai_epi64(x, 63); we therefore calculate srli(x)-1\n __m128i const x_int = *(__m128i const*)&x;\n __m128i const imask_int = _mm_sub_epi64(_mm_srli_epi64(x_int, 63), k8ione.vi);\n CCTK_REAL8_VEC const imask = *(CCTK_REAL8_VEC const*)&imask_int;\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(imask, z), _mm_andnot_pd(imask, y));\n#else\n // This assumes that all logical operations always return either\n // lfalse or ltrue, and nothing \"in between\"\n // (z & ~mask) | (y & mask) where imask = ~mask\n return _mm_or_pd(_mm_and_pd(I2R(x), y), _mm_andnot_pd(I2R(x), z));\n#endif\n}\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpeq(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpeq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpne(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpneq_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpgt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpgt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmpge(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmpge_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmplt(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmplt_pd(x, y));\n}\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_BOOLEAN8_VEC k8cmple(CCTK_REAL8_VEC const x, CCTK_REAL8_VEC const y)\n{\n return R2I(_mm_cmple_pd(x, y));\n}\n\n\n\nstatic inline CCTK_ATTRIBUTE_ALWAYS_INLINE\nCCTK_REAL8_VEC k8sgn(CCTK_REAL8_VEC const x)\n{\n CCTK_BOOLEAN8_VEC const iszero = k8cmpeq(x, vec8_set1(0.0));\n CCTK_REAL8_VEC const sign = _mm_and_pd(I2R(k8sign), x);\n CCTK_REAL8_VEC const signedone = _mm_or_pd(sign, vec8_set1(1.0));\n return k8ifthen(iszero, vec8_set1(0.0), signedone);\n}\n\n\n\n#undef I2R\n#undef R2I\n\n```\n\nmacros/vectors-8-AVX.h:\n```\n// Vectorise using Intel's or AMD's AVX\n\n// Use the type __m256d directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#if VECTORISE_EMULATE_AVX\n# include \"avxintrin_emu.h\"\n#else\n# include <immintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __FMA4__\n# define vec8_architecture_FMA4 \"+FMA4\"\n#else\n# define vec8_architecture_FMA4 \"\"\n#endif\n#define vec8_architecture \"AVX\" vec8_architecture_FMA4 \" (64-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL8_VEC __m256d\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL8_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\nunion k8const_t {\n unsigned long long i[4];\n double f[4];\n __m256i vi;\n __m256d vf;\n};\n\n#define K8_ZERO 0x0000000000000000ULL\n#define K8_NOTZERO 0xffffffffffffffffULL\n#define K8_IMIN 0x8000000000000000ULL\n#define K8_IMAX 0x7fffffffffffffffULL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec8_set1(a) (_mm256_set1_pd(a))\n#define vec8_set(a,b,c,d) (_mm256_set_pd(d,c,b,a)) // note reversed arguments\n\n#define vec8_elt0(x) (((CCTK_REAL8 const*)&(x))[0])\n#define vec8_elt1(x) (((CCTK_REAL8 const*)&(x))[1])\n#define vec8_elt2(x) (((CCTK_REAL8 const*)&(x))[2])\n#define vec8_elt3(x) (((CCTK_REAL8 const*)&(x))[3])\n#define vec8_elt(x,d) (((CCTK_REAL8 const*)&(x))[d])\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec8_load(p) (_mm256_load_pd(&(p)))\n#define vec8_loadu(p) (_mm256_loadu_pd(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec8_load_off1(p) vec_loadu(p)\n#else\n# error \"VECTORISE_ALWAYS_USE_ALIGNED_LOADS not yet supported\"\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec8_loadu_maybe(off,p) (vec8_loadu(p))\n# define vec8_loadu_maybe3(off1,off2,off3,p) (vec8_loadu(p))\n#else\n# define vec8_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n (off) % CCTK_REAL8_VEC_SIZE == 0 ? \\\n vec8_load(p) : \\\n vec8_load_off1(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec8_loadu_maybe3(off1,off2,off3,p) \\\n vec8_loadu_maybe(off1,p)\n# else\n# define vec8_loadu_maybe3(off1,off2,off3,p_) \\\n ({ \\\n CCTK_REAL8 const& p__=(p_); \\\n CCTK_REAL8 const& p=p__; \\\n ((off2) % CCTK_REAL8_VEC_SIZE != 0 or \\\n (off3) % CCTK_REAL8_VEC_SIZE != 0) ? \\\n vec8_loadu(p) : \\\n vec8_loadu_maybe(off1,p); \\\n })\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec8_store(p,x) (_mm256_store_pd(&(p),x))\n#define vec8_storeu(p,x) (_mm256_storeu_pd(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec8_store_nta(p,x) (vec8_store(p,x))\n#else\n# define vec8_store_nta(p,x) (_mm256_stream_pd(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec8_store_partial_prepare(i,imin_,imax_) \\\n bool v8stp_all; \\\n __m256i v8stp_mask; \\\n ({ \\\n ptrdiff_t const imin__=(imin_); \\\n ptrdiff_t const imin=imin__; \\\n ptrdiff_t const imax__=(imax_); \\\n ptrdiff_t const imax=imax__; \\\n \\\n v8stp_all = i>=imin and i+CCTK_REAL_VEC_SIZE-1<imax; \\\n \\\n if (not CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n /* \\\n __m256i const v8stp_mask = \\\n _mm256_andnot_pd(_mm256_add_epi64(_mm256_set1_epi64x(i-imin), \\\n vec_index), \\\n _mm256_add_epi64(_mm256_set1_epi64x(i-imax), \\\n vec_index)); \\\n */ \\\n __m128i const termlo0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(1, 0)); \\\n __m128i const termup0 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(1, 0)); \\\n __m128i const term0 = _mm_andnot_si128(termlo0, termup0); \\\n __m128i const termlo1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imin), _mm_set_epi64x(3, 2)); \\\n __m128i const termup1 = \\\n _mm_add_epi64(_mm_set1_epi64x(i-imax), _mm_set_epi64x(3, 2)); \\\n __m128i const term1 = _mm_andnot_si128(termlo1, termup1); \\\n v8stp_mask = \\\n _mm256_insertf128_si256(_mm256_castsi128_si256(term0), term1, 1); \\\n } \\\n })\n\n#define vec8_store_nta_partial(p,x) \\\n ({ \\\n if (CCTK_BUILTIN_EXPECT(v8stp_all, true)) { \\\n vec8_store_nta(p,x); \\\n } else { \\\n _mm256_maskstore_pd(&p,v8stp_mask,x); \\\n } \\\n })\n\n// Store a lower or higher partial vector (aligned and non-temporal);\n// the non-temporal hint is probably ignored\n// Masks indicating which vector element should be stored:\nstatic const k8const_t k8store_lo[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_ZERO , K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_ZERO , }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\nstatic const k8const_t k8store_hi[5] =\n {\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_ZERO , }},\n {{ K8_ZERO , K8_ZERO , K8_ZERO , K8_NOTZERO, }},\n {{ K8_ZERO , K8_ZERO , K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_ZERO , K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }},\n };\n#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && __GNUC__==4 && __GNUC_MINOR__<=4\n// gcc 4.4 uses a wrong prototype for _mm256_maskstore_pd\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_lo[n].vi),x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),_mm256_castsi256_pd(k8store_hi[n].vi),x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castsi256_pd(k8store_lo[nlo].vi & k8store_hi[nhi].vi), \\\n x))\n#else\n# define vec8_store_nta_partial_lo(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_lo[n].vi,x))\n# define vec8_store_nta_partial_hi(p,x,n) \\\n (_mm256_maskstore_pd(&(p),k8store_hi[n].vi,x))\n# define vec8_store_nta_partial_mid(p,x,nlo,nhi) \\\n (_mm256_maskstore_pd \\\n (&(p), \\\n _mm256_castpd_si256(_mm256_and_pd(k8store_lo[nlo].vf, \\\n k8store_hi[nhi].vf)), \\\n x))\n#endif\n\n\n\n// Functions and operators\n\nstatic const k8const_t k8sign_mask = {{ K8_IMIN, K8_IMIN, K8_IMIN, K8_IMIN, }};\n\n// Operators\n#define k8neg(x) (_mm256_xor_pd(x,k8sign_mask.vf))\n\n#define k8add(x,y) (_mm256_add_pd(x,y))\n#define k8sub(x,y) (_mm256_sub_pd(x,y))\n#define k8mul(x,y) (_mm256_mul_pd(x,y))\n#define k8div(x,y) (_mm256_div_pd(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k8madd(x,y,z) (_mm256_macc_pd(x,y,z))\n# define k8msub(x,y,z) (_mm256_msub_pd(x,y,z))\n# define k8nmadd(x,y,z) (_mm256_nmsub_pd(x,y,z))\n# define k8nmsub(x,y,z) (_mm256_nmacc_pd(x,y,z))\n#else\n# define k8madd(x,y,z) (k8add(k8mul(x,y),z))\n# define k8msub(x,y,z) (k8sub(k8mul(x,y),z))\n# define k8nmadd(x,y,z) (k8sub(k8neg(z),k8mul(x,y)))\n# define k8nmsub(x,y,z) (k8sub(z,k8mul(x,y)))\n#endif\n\n// Cheap functions\n#define k8copysign(x,y) \\\n (_mm256_or_pd(_mm256_andnot_pd(k8sign_mask.vf,x), \\\n _mm256_and_pd(k8sign_mask.vf,y)))\n#define k8fabs(x) (_mm256_andnot_pd(k8sign_mask.vf,x))\n#define k8fmax(x,y) (_mm256_max_pd(x,y))\n#define k8fmin(x,y) (_mm256_min_pd(x,y))\n#define k8fnabs(x) (_mm256_or_pd(x,k8sign_mask.vf))\nstatic const k8const_t k8zero = { f: { 0.0, 0.0, 0.0, 0.0, }};\nstatic const k8const_t k8one = { f: { 1.0, 1.0, 1.0, 1.0, }};\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC x__=(x_); \\\n CCTK_REAL_VEC x=x__; \\\n CCTK_REAL_VEC iszero = _mm256_cmp_pd(x, k8zero.vf, _CMP_EQ_OQ); \\\n CCTK_REAL_VEC sign = _mm256_and_pd(k8sign_mask.vf, x); \\\n CCTK_REAL_VEC signedone = _mm256_or_pd(sign, k8one.vf); \\\n k8ifthen(iszero, k8zero.vf, signedone); \\\n })\n#define k8sqrt(x) (_mm256_sqrt_pd(x))\n\n// Expensive functions\n#define K8REPL(f,x_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const x=x__; \\\n vec8_set(f(vec8_elt0(x)), \\\n f(vec8_elt1(x)), \\\n f(vec8_elt2(x)), \\\n f(vec8_elt3(x))); \\\n })\n#define K8REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8 const a__=(a_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8 const a=a__; \\\n vec8_set(f(vec8_elt0(x),a), \\\n f(vec8_elt1(x),a), \\\n f(vec8_elt2(x),a), \\\n f(vec8_elt3(x),a)); \\\n })\n#define K8REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL8_VEC const x__=(x_); \\\n CCTK_REAL8_VEC const y__=(y_); \\\n CCTK_REAL8_VEC const x=x__; \\\n CCTK_REAL8_VEC const y=y__; \\\n vec8_set(f(vec8_elt0(x),vec8_elt0(y)), \\\n f(vec8_elt1(x),vec8_elt1(y)), \\\n f(vec8_elt2(x),vec8_elt2(y)), \\\n f(vec8_elt3(x),vec8_elt3(y))); \\\n })\n\n#define k8acos(x) K8REPL(acos,x)\n#define k8acosh(x) K8REPL(acosh,x)\n#define k8asin(x) K8REPL(asin,x)\n#define k8asinh(x) K8REPL(asinh,x)\n#define k8atan(x) K8REPL(atan,x)\n#define k8atan2(x,y) K8REPL2(atan2,x,y)\n#define k8atanh(x) K8REPL(atanh,x)\n#define k8cos(x) K8REPL(cos,x)\n#define k8cosh(x) K8REPL(cosh,x)\n#define k8exp(x) K8REPL(exp,x)\n#define k8log(x) K8REPL(log,x)\n#define k8pow(x,a) K8REPL2S(pow,x,a)\n#define k8sin(x) K8REPL(sin,x)\n#define k8sinh(x) K8REPL(sinh,x)\n#define k8tan(x) K8REPL(tan,x)\n#define k8tanh(x) K8REPL(tanh,x)\n\nstatic const k8const_t k8lfalse_ =\n {{ K8_ZERO, K8_ZERO, K8_ZERO, K8_ZERO, }};\nstatic const k8const_t k8ltrue_ =\n {{ K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, K8_NOTZERO, }};\n#define k8lfalse (k8lfalse_.vf)\n#define k8ltrue (k8ltrue_.vf)\n#define k8lnot(x) (_mm256_xor_pd(k8ltrue,x))\n#define k8land(x,y) (_mm256_and_pd(x,y))\n#define k8lor(x,y) (_mm256_or_pd(x,y))\n#define k8lxor(x,y) (_mm256_xor_pd(x,y))\n#define k8ifthen(x,y,z) (_mm256_blendv_pd(z,y,x))\n\n#define k8cmpeq(x,y) (_mm256_cmp_pd(x,y,_CMP_EQ_OQ))\n#define k8cmpne(x,y) (_mm256_cmp_pd(x,y,_CMP_NEQ_OQ))\n#define k8cmpgt(x,y) (_mm256_cmp_pd(x,y,_CMP_GT_OQ))\n#define k8cmpge(x,y) (_mm256_cmp_pd(x,y,_CMP_GE_OQ))\n#define k8cmplt(x,y) (_mm256_cmp_pd(x,y,_CMP_LT_OQ))\n#define k8cmple(x,y) (_mm256_cmp_pd(x,y,_CMP_LE_OQ))\n\n```\n\nmacros/vectors-4-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec4_architecture \"scalar (no vectorisation, 32-bit precision)\"\n\n// Use CCTK_REAL4\n#define CCTK_REAL4_VEC CCTK_REAL4\n\n// Number of vector elements in a vector\n#define CCTK_REAL4_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec4_set1(a) (a)\n// Create a vector from N scalars\n#define vec4_set(a) (a)\n\n// Access vectors elements\n#define vec4_elt0(x) (x)\n#define vec4_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec4_load(p) (p)\n// Load an unaligned vector from memory\n#define vec4_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec4_loadu_maybe(off,p) (p)\n#define vec4_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec4_store(p,x) ((p)=(x))\n#define vec4_storeu(p,x) ((p)=(x))\n\n// Unaligned store\n#define vec4_store_nta(p,x) ((p)=(x))\n\n#define vec4_store_partial_prepare(i,imin,imax) (0)\n#define vec4_store_nta_partial(p,x) (vec4_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec4_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec4_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec4_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k4neg(x) (-(x))\n\n#define k4add(x,y) ((x)+(y))\n#define k4sub(x,y) ((x)-(y))\n#define k4mul(x,y) ((x)*(y))\n#define k4div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k4madd(x,y,z) (+(x)*(y)+(z))\n#define k4msub(x,y,z) (+(x)*(y)-(z))\n#define k4nmadd(x,y,z) (-(x)*(y)-(z))\n#define k4nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k4acos(x) (acosf(x))\n#define k4acosh(x) (acoshf(x))\n#define k4asin(x) (asinf(x))\n#define k4asinh(x) (asinhf(x))\n#define k4atan(x) (atanf(x))\n#define k4atan2(x,y) (atan2f(x,y))\n#define k4atanh(x) (atanhf(x))\n#define k4copysign(x,y) (copysign(x,y))\n#define k4cos(x) (cosf(x))\n#define k4cosh(x) (coshf(x))\n#define k4exp(x) (expf(x))\n#define k4fabs(x) (fabsf(x))\n#define k4fmax(x,y) (fmaxf(x,y))\n#define k4fmin(x,y) (fminf(x,y))\n#define k4fnabs(x) (-fabsf(x))\n#define k4log(x) (logf(x))\n#define k4pow(x,a) (powf(x,a))\n#define k4sin(x) (sinf(x))\n#define k4sinh(x) (sinhf(x))\n#define k4sqrt(x) (sqrtf(x))\n#define k4tan(x) (tanf(x))\n#define k4tanh(x) (tanhf(x))\n\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k4signbit(x) (std::signbit(x))\n\n#define k4l2r(x_) ({ CCTK_INT4 x__=(x_); CCTK_INT4 x=x__; *(CCTK_REAL4*)&x; })\n#define k4r2l(x_) ({ CCTK_REAL4 x__=(x_); CCTK_REAL4 x=x__; *(CCTK_INT4*)&x; })\n#define k4lfalse k4l2r(0)\n#define k4ltrue k4l2r(1)\n#define k4lnot(x) k4l2r(!k4r2l(x))\n#define k4land(x,y) k4l2r(k4r2l(x) && k4r2l(y))\n#define k4lor(x,y) k4l2r(k4r2l(x) || k4r2l(y))\n#define k4lxor(x,y) k4l2r(!k4r2l(x) != !k4r2l(y))\n\n#define k4ifthen(x,y,z) (k4r2l(x)?(y):(z))\n\n#define k4cmpeq(x,y) k4l2r((x)==(y))\n#define k4cmpne(x,y) k4l2r((x)!=(y))\n#define k4cmpgt(x,y) k4l2r((x)>(y))\n#define k4cmpge(x,y) k4l2r((x)>=(y))\n#define k4cmplt(x,y) k4l2r((x)<(y))\n#define k4cmple(x,y) k4l2r((x)<=(y))\n\n```\n\nmacros/vectors-4-SSE.h:\n```\n// Vectorise using Intel's or AMD's SSE\n\n// Use the type __m128 directly, without introducing a wrapper class\n// Use macros instead of inline functions\n\n\n\n#include <assert.h>\n#include <math.h>\n\n#include <xmmintrin.h>\n#ifdef __SSE4_1__\n// Intel's SSE 4.1\n# include <smmintrin.h>\n#endif\n#ifdef __SSE4A__\n// AMD's SSE 4a\n# include <ammintrin.h>\n#endif\n#ifdef __FMA4__\n# include <fma4intrin.h>\n#endif\n\n\n\n#ifdef __SSE4_1__\n# define vec4_architecture_SSE4_1 \"+SSE4.1\"\n#else\n# define vec4_architecture_SSE4_1 \"\"\n#endif\n#ifdef __SSE4A__\n# define vec4_architecture_SSE4a \"+SSE4A\"\n#else\n# define vec4_architecture_SSE4a \"\"\n#endif\n#ifdef __FMA4__\n# define vec4_architecture_FMA4 \"+FMA4\"\n#else\n# define vec4_architecture_FMA4 \"\"\n#endif\n#define vec4_architecture \"SSE\" vec4_architecture_SSE4_1 vec4_architecture_SSE4a vec4_architecture_FMA4 \" (32-bit precision)\"\n\n\n\n// Vector type corresponding to CCTK_REAL\n#define CCTK_REAL4_VEC __m128\n\n// Number of vector elements in a CCTK_REAL_VEC\n#define CCTK_REAL4_VEC_SIZE 4\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER4 CCTK_REAL4\n#define CCTK_BOOLEAN4 CCTK_REAL4\n#define CCTK_INTEGER4_VEC CCTK_REAL4_VEC\n#define CCTK_BOOLEAN4_VEC CCTK_REAL4_VEC\n\n\n\nunion k4const_t {\n unsigned i[4];\n float f[4];\n __m128i vi;\n __m128 vf;\n};\n\n#define K4_ZERO 0x00000000UL\n#define K4_IMIN 0x80000000UL\n#define K4_IMAX 0x7fffffffUL\n\n\n\n// Create vectors, extract vector elements\n\n#define vec4_set1(a) (_mm_set1_ps(a))\n#define vec4_set(a,b,c,d) (_mm_set_ps(d,c,b,a)) // note reversed arguments\n\n// original order is 0123\n#define vec4_swap1032(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(2,3,0,1)); \\\n })\n#define vec4_swap2301(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(1,0,3,2)); \\\n })\n#define vec4_swap3210(x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n _mm_shuffle_ps(x,x, _MM_SHUFFLE(0,1,2,3)); \\\n })\n\n#if defined(__PGI)\n// _mm_cvtss_f32 does not exist on PGI compilers\n# define vec4_elt0(x) \\\n ({ \\\n CCTK_REAL4 a; \\\n asm (\"\" : \"=x\" (a) : \"0\" (x)); \\\n a; \\\n })\n#else\n# define vec4_elt0(x) (_mm_cvtss_f32(x)) // this is a no-op\n#endif\n#define vec4_elt1(x) vec4_elt0(vec4_swap1032(x))\n#define vec4_elt2(x) vec4_elt0(vec4_swap2301(x))\n#define vec4_elt3(x) vec4_elt0(vec4_swap3210(x))\n#if defined(__PGI)\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n if (d==0) a=vec4_elt0(x); \\\n else if (d==1) a=vec4_elt1(x); \\\n else if (d==2) a=vec4_elt2(x); \\\n else if (d==3) a=vec4_elt3(x); \\\n a; \\\n })\n#else\n# define vec4_elt(x_,d) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 a; \\\n switch (d) { \\\n case 0: a=vec4_elt0(x); break; \\\n case 1: a=vec4_elt1(x); break; \\\n case 2: a=vec4_elt2(x); break; \\\n case 3: a=vec4_elt3(x); break; \\\n } \\\n a; \\\n })\n#endif\n\n\n\n// Load and store vectors\n\n// Load a vector from memory (aligned and unaligned); this loads from\n// a reference to a scalar\n#define vec4_load(p) (_mm_load_ps(&(p)))\n#define vec4_loadu(p) (_mm_loadu_ps(&(p)))\n#if ! VECTORISE_ALWAYS_USE_ALIGNED_LOADS\n# define vec4_load_off1(p) vec_loadu(p)\n# define vec4_load_off2(p) vec_loadu(p)\n# define vec4_load_off3(p) vec_loadu(p)\n#else\n# define vec4_load_off1(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const hi2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo,hi2, _MM_SHUFFLE(2,1,3,0)); \\\n })\n# define vec4_load_off2(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-2]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+2]); \\\n _mm_shuffle_ps(lo,hi, _MM_SHUFFLE(1,0,3,2)); \\\n })\n# define vec4_load_off3(p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n CCTK_REAL4_VEC const lo=vec4_load((&p)[-1]); \\\n CCTK_REAL4_VEC const hi=vec4_load((&p)[+3]); \\\n assert(0); \\\n CCTK_REAL4_VEC const lo2=_mm_shuffle_ps(lo,hi, _MM_SHUFFLE(0,1,2,3)); \\\n _mm_shuffle_ps(lo2,hi, _MM_SHUFFLE(3,0,2,1)); \\\n })\n#endif\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset off and the vector size\n#if VECTORISE_ALWAYS_USE_UNALIGNED_LOADS\n// Implementation: Always use unaligned load\n# define vec4_loadu_maybe(off,p) vec4_loadu(p)\n# define vec4_loadu_maybe3(off1,off2,off3,p) vec4_loadu(p)\n#else\n# define vec4_loadu_maybe(off,p_) \\\n ({ \\\n CCTK_REAL4 const& p__=(p_); \\\n CCTK_REAL4 const& p=p__; \\\n (off) % CCTK_REAL4_VEC_SIZE == 0 ? \\\n vec4_load(p) : \\\n vec4_loadu(p); \\\n })\n# if VECTORISE_ALIGNED_ARRAYS\n// Assume all array x sizes are multiples of the vector size\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe(off1,p)\n# else\n# define vec4_loadu_maybe3(off1,off2,off3,p) \\\n vec4_loadu_maybe((off1)|(off2)|(off3),p)\n# endif\n#endif\n\n// Store a vector to memory (aligned and non-temporal); this stores to\n// a reference to a scalar\n#define vec4_store(p,x) (_mm_store_ps(&(p),x))\n#define vec4_storeu(p,x) (_mm_storeu_ps(&(p),x))\n#if ! VECTORISE_STREAMING_STORES\n# define vec4_store_nta(p,x) vec4_store(p,x)\n#else\n# define vec4_store_nta(p,x) (_mm_stream_ps(&(p),x))\n#endif\n\n// Store a partial vector (aligned and non-temporal)\n#define vec4_store_partial_prepare(i,imin,imax) \\\n int v4stp_lo_skip = (imin)-(i); \\\n int v4stp_hi_skip = (i)+CCTK_REAL_VEC_SIZE-(imax); \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip < 0, true)) v4stp_lo_skip = 0; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_hi_skip < 0, true)) v4stp_hi_skip = 0;\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial(p_,x_) \\\n ({ \\\n CCTK_REAL4& p__=(p_); \\\n CCTK_REAL4& p=p__; \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n if (CCTK_BUILTIN_EXPECT(v4stp_lo_skip==0 and v4stp_hi_skip==0, true)) { \\\n vec4_store_nta(p,x); \\\n } else { \\\n /* these cases fall through */ \\\n switch (v4stp_lo_skip) { \\\n case 0: \\\n (&p)[0] = vec4_elt0(x); \\\n case 1: \\\n if (v4stp_hi_skip>=3) break; \\\n (&p)[1] = vec4_elt1(x); \\\n case 2: \\\n if (v4stp_hi_skip>=2) break; \\\n (&p)[2] = vec4_elt2(x); \\\n case 3: \\\n if (v4stp_hi_skip>=1) break; \\\n (&p)[3] = vec4_elt3(x); \\\n } \\\n } \\\n })\n\n// Ignoring VECTORISE_STREAMING_STORES for partial stores\n#define vec4_store_nta_partial_lo(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[2] = vec4_elt2(x); \\\n case 2: (&p)[1] = vec4_elt1(x); \\\n case 1: (&p)[0] = vec4_elt0(x); \\\n } \\\n })\n#define vec4_store_nta_partial_hi(p_,x_,n) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (n) { \\\n case 3: (&p)[1]=vec4_elt1(x); \\\n case 2: (&p)[2]=vec4_elt2(x); \\\n case 1: (&p)[3]=vec4_elt3(x); \\\n } \\\n })\n#define vec4_store_nta_partial_mid(p_,x_,nlo,nhi) \\\n ({ \\\n CCTK_REAL4 & p__=(p_); \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 & p=p__; \\\n CCTK_REAL4_VEC const x=x__; \\\n /* these cases fall through */ \\\n switch (nhi) { \\\n case 3: if (nlo<2) break; (&p)[1] = vec4_elt1(x); \\\n case 2: if (nlo<3) break; (&p)[2] = vec4_elt2(x); \\\n } \\\n })\n\n\n\n// Functions and operators\n\nstatic const k4const_t k4sign_mask = {{ K4_IMIN, K4_IMIN, K4_IMIN, K4_IMIN, }};\n\n// Operators\n#define k4neg(x) (_mm_xor_ps(k4sign_mask.vf,x))\n// #define k4inv(x)\n// TODO: provide k4inv via rcp and Newton-Raphson\n// This is described in AMD's publication 47414.\n// This should apply for AVX as well.\n\n#define k4add(x,y) (_mm_add_ps(x,y))\n#define k4sub(x,y) (_mm_sub_ps(x,y))\n#define k4mul(x,y) (_mm_mul_ps(x,y))\n// TODO: use k4inv and k4mul instead\n#define k4div(x,y) (_mm_div_ps(x,y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#ifdef __FMA4__\n# define k4madd(x,y,z) (_mm_macc_ps(x,y,z))\n# define k4msub(x,y,z) (_mm_msub_ps(x,y,z))\n# define k4nmadd(x,y,z) (_mm_nmsub_ps(x,y,z))\n# define k4nmsub(x,y,z) (_mm_nmacc_ps(x,y,z))\n#else\n# define k4madd(x,y,z) (k4add(k4mul(x,y),z))\n# define k4msub(x,y,z) (k4sub(k4mul(x,y),z))\n# define k4nmadd(x,y,z) (k4sub(k4neg(z),k4mul(x,y)))\n# define k4nmsub(x,y,z) (k4sub(z,k4mul(x,y)))\n#endif\n\n// Cheap functions\n#define k4copysign(x,y) \\\n (_mm_or_ps(_mm_andnot_ps(k4sign_mask.vf,x), \\\n _mm_and_ps(k4sign_mask.vf,y)))\n#define k4fabs(x) (_mm_andnot_ps(k4sign_mask.vf,x))\n#define k4fmax(x,y) (_mm_max_ps(x,y))\n#define k4fmin(x,y) (_mm_min_ps(x,y))\n#define k4fnabs(x) (_mm_or_ps(k4sign_mask.vf,x))\n#define k4sgn(x_) \\\n ({ \\\n CCTK_REAL_VEC const x__=(x_); \\\n CCTK_REAL_VEC const x=x__; \\\n CCTK_REAL_VEC const iszero = _mm_cmpeq_ps(vec4_set1(0.0f), x); \\\n CCTK_REAL_VEC const sign = _mm_and_ps(k4sign_mask.vf, x); \\\n CCTK_REAL_VEC const signedone = _mm_or_ps(vec4_set1(1.0f), sign); \\\n k4ifthen(iszero, vec4_set1(0.0f), signedone); \\\n })\n// TODO: maybe use rsqrt and Newton-Raphson\n#define k4sqrt(x) (_mm_sqrt_ps(x))\n\n// Expensive functions\n#define K4REPL(f,x_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const x=x__; \\\n vec4_set(f(vec4_elt0(x)), \\\n f(vec4_elt1(x)), \\\n f(vec4_elt2(x)), \\\n f(vec4_elt3(x))); \\\n })\n#define K4REPL2S(f,x_,a_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4 const a__=(a_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4 const a=a__; \\\n vec4_set(f(vec4_elt0(x),a), \\\n f(vec4_elt1(x),a), \\\n f(vec4_elt2(x),a), \\\n f(vec4_elt3(x),a)); \\\n })\n#define K4REPL2(f,x_,y_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n vec4_set(f(vec4_elt0(x),vec4_elt0(y)), \\\n f(vec4_elt1(x),vec4_elt1(y)), \\\n f(vec4_elt2(x),vec4_elt2(y)), \\\n f(vec4_elt3(x),vec4_elt3(y))); \\\n })\n\n#define k4acos(x) K4REPL(acosf,x)\n#define k4acosh(x) K4REPL(acoshf,x)\n#define k4asin(x) K4REPL(asinf,x)\n#define k4asinh(x) K4REPL(asinhf,x)\n#define k4atan(x) K4REPL(atanf,x)\n#define k4atan2(x,y) K4REPL2(atan2f,x,y)\n#define k4atanh(x) K4REPL(atanhf,x)\n#define k4cos(x) K4REPL(cosf,x)\n#define k4cosh(x) K4REPL(coshf,x)\n#define k4exp(x) K4REPL(expf,x)\n#define k4log(x) K4REPL(logf,x)\n#define k4pow(x,a) K4REPL2S(powf,x,a)\n#define k4sin(x) K4REPL(sinf,x)\n#define k4sinh(x) K4REPL(sinhf,x)\n#define k4tan(x) K4REPL(tanf,x)\n#define k4tanh(x) K4REPL(tanhf,x)\n\nstatic const k4const_t k4lfalse_ = {{ 0U, 0U, 0U, 0U, }};\nstatic const k4const_t k4ltrue_ = {{ ~0U, ~0U, ~0U, ~0U, }};\n#define k4lfalse (k4lfalse_.vf)\n#define k4ltrue (k4ltrue_.vf)\n#define k4lnot(x) (_mm_xor_ps(k4ltrue,x))\n#define k4land(x,y) (_mm_and_ps(x,y))\n#define k4lor(x,y) (_mm_or_ps(x,y))\n#define k4lxor(x,y) (_mm_xor_ps(x,y))\n\n#ifdef __SSE4_1__\n# define k4ifthen(x,y,z) (_mm_blendv_ps(z,y,x))\n#elif 0\n# ifdef __cplusplus\n# define k4signbit(x) ({ using namespace std; signbit(x); })\n# else\n# define k4signbit(x) (signbitf(x))\n# endif\n# define k4ifthen(x,y,z) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n vec4_set(k4signbit(vec4_elt0(x)) ? vec4_elt0(y) : vec4_elt0(z), \\\n k4signbit(vec4_elt1(x)) ? vec4_elt1(y) : vec4_elt1(z), \\\n k4signbit(vec4_elt2(x)) ? vec4_elt2(y) : vec4_elt2(z), \\\n k4signbit(vec4_elt3(x)) ? vec4_elt3(y) : vec4_elt3(z)); \\\n })\n#elif 0\n// We don't need to shift -- the condition (mask) will be either all\n// zeros or all ones\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n CCTK_REAL4_VEC const mask = \\\n (__m128)_mm_srai_epi32((__m128i)x, 31); \\\n /* (z & ~mask) | (y & mask) */ \\\n _mm_or_ps(_mm_andnot_ps(mask, z), _mm_and_ps(mask, y)); \\\n })\n#else\n# define k4ifthen(x_,y_,z_) \\\n ({ \\\n CCTK_REAL4_VEC const x__=(x_); \\\n CCTK_REAL4_VEC const y__=(y_); \\\n CCTK_REAL4_VEC const z__=(z_); \\\n CCTK_REAL4_VEC const x=x__; \\\n CCTK_REAL4_VEC const y=y__; \\\n CCTK_REAL4_VEC const z=z__; \\\n /* (z & ~mask) | (y & mask) where imask = ~mask */ \\\n _mm_or_ps(_mm_and_ps(x, y), _mm_andnot_ps(x, z)); \\\n })\n#endif\n\n#define k4cmpeq(x,y) (_mm_cmpeq_ps(x,y))\n#define k4cmpne(x,y) (_mm_cmpneq_ps(x,y))\n#define k4cmpgt(x,y) (_mm_cmpgt_ps(x,y))\n#define k4cmpge(x,y) (_mm_cmpge_ps(x,y))\n#define k4cmplt(x,y) (_mm_cmplt_ps(x,y))\n#define k4cmple(x,y) (_mm_cmple_ps(x,y))\n\n```\n\nmacros/vectors-8-default.h:\n```\n// Fallback vectorisation implementation: Do not vectorise\n\n// We use macros here, so that we are not surprised by compilers which\n// don't like to inline functions. This should also make debug builds\n// (which may not inline) more efficient.\n\n\n\n#include <assert.h>\n#include <math.h>\n\n\n\n#define vec8_architecture \"scalar (no vectorisation, 64-bit precision)\"\n\n// Use CCTK_REAL8\n#define CCTK_REAL8_VEC CCTK_REAL8\n\n// Number of vector elements in a vector\n#define CCTK_REAL8_VEC_SIZE 1\n\n// Integer and boolean types corresponding to this real type\n#define CCTK_INTEGER8 CCTK_REAL8\n#define CCTK_BOOLEAN8 CCTK_REAL8\n#define CCTK_INTEGER8_VEC CCTK_REAL8_VEC\n#define CCTK_BOOLEAN8_VEC CCTK_REAL8_VEC\n\n\n\n// Create a vector replicating a scalar\n#define vec8_set1(a) (a)\n// Create a vector from N scalars\n#define vec8_set(a) (a)\n\n// Access vectors elements\n#define vec8_elt0(x) (x)\n#define vec8_elt(x,d) (x)\n\n\n\n// Load an aligned vector from memory\n#define vec8_load(p) (p)\n// Load an unaligned vector from memory\n#define vec8_loadu(p) (p)\n\n// Load a vector from memory that may or may not be aligned, as\n// decided by the offset and the vector size. These functions are\n// useful e.g. for loading neightbouring grid points while evaluating\n// finite differencing stencils.\n#define vec8_loadu_maybe(off,p) (p)\n#define vec8_loadu_maybe3(off1,off2,off3,p) (p)\n\n// Aligned store\n#define vec8_store(p,x) ((p)=(x))\n// Unaligned store\n#define vec8_store_nta(p,x) ((p)=(x))\n\n#define vec8_store_partial_prepare(i,imin,imax) ((void)0)\n#define vec8_store_nta_partial(p,x) (vec8_store_nta(p,x))\n// Store the n lower elements of a vector to memory\n#define vec8_store_nta_partial_lo(p,x,n) (assert(0))\n// Store the n higher elements of a vector into memory. This stores\n// the vector elements into memory locations as if element 0 were\n// stored at p.\n#define vec8_store_nta_partial_hi(p,x,n) (assert(0))\n#define vec8_store_nta_partial_mid(p,x,nlo,nhi) (assert(0))\n\n\n\n// Operators\n#define k8neg(x) (-(x))\n\n#define k8add(x,y) ((x)+(y))\n#define k8sub(x,y) ((x)-(y))\n#define k8mul(x,y) ((x)*(y))\n#define k8div(x,y) ((x)/(y))\n\n// Fused multiply-add, defined as [+-]x*y[+-]z\n#define k8madd(x,y,z) (+(x)*(y)+(z))\n#define k8msub(x,y,z) (+(x)*(y)-(z))\n#define k8nmadd(x,y,z) (-(x)*(y)-(z))\n#define k8nmsub(x,y,z) (-(x)*(y)+(z))\n\n// Functions\n#define k8acos(x) (acos(x))\n#define k8acosh(x) (acosh(x))\n#define k8asin(x) (asin(x))\n#define k8asinh(x) (asinh(x))\n#define k8atan(x) (atan(x))\n#define k8atan2(x,y) (atan2(x,y))\n#define k8atanh(x) (atanh(x))\n#define k8copysign(x,y) (copysign(x,y))\n#define k8cos(x) (cos(x))\n#define k8cosh(x) (cosh(x))\n#define k8exp(x) (exp(x))\n#define k8fabs(x) (fabs(x))\n#define k8fmax(x,y) (fmax(x,y))\n#define k8fmin(x,y) (fmin(x,y))\n#define k8fnabs(x) (-fabs(x))\n#define k8log(x) (log(x))\n#define k8pow(x,a) (pow(x,a))\n#define k8sin(x) (sin(x))\n#define k8sinh(x) (sinh(x))\n#define k8sqrt(x) (sqrt(x))\n#define k8tan(x) (tan(x))\n#define k8tanh(x) (tanh(x))\n\n#define k8sgn(x_) \\\n ({ \\\n CCTK_REAL x__=(x_); \\\n CCTK_REAL x=x__; \\\n x==(CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : std::copysign((CCTK_REAL)1.0, x); \\\n })\n#define k8signbit(x) (std::signbit(x))\n\n#define k8l2r(x_) ({ CCTK_INT8 x__=(x_); CCTK_INT8 x=x__; *(CCTK_REAL8*)&x; })\n#define k8r2l(x_) ({ CCTK_REAL8 x__=(x_); CCTK_REAL8 x=x__; *(CCTK_INT8*)&x; })\n#define k8lfalse k8l2r(0)\n#define k8ltrue k8l2r(1)\n#define k8lnot(x) k8l2r(!k8r2l(x))\n#define k8land(x,y) k8l2r(k8r2l(x) && k8r2l(y))\n#define k8lor(x,y) k8l2r(k8r2l(x) || k8r2l(y))\n#define k8lxor(x,y) k8l2r(!k8r2l(x) != !k8r2l(y))\n\n#define k8ifthen(x,y,z) (k8r2l(x)?(y):(z))\n\n#define k8cmpeq(x,y) k8l2r((x)==(y))\n#define k8cmpne(x,y) k8l2r((x)!=(y))\n#define k8cmpgt(x,y) k8l2r((x)>(y))\n#define k8cmpge(x,y) k8l2r((x)>=(y))\n#define k8cmplt(x,y) k8l2r((x)<(y))\n#define k8cmple(x,y) k8l2r((x)<=(y))\n\n```\n\nindirect/vectors-intel.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__SSE__) // SSE (Intel)\n\n#include <xmmintrin.h>\n\ntemplate<>\nstruct vec_T<float> {\n typedef float scalar_t;\n typedef __m128 impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_ps(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n : v(_mm_set_ps(a3,a2,a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f32(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(1,0,3,2)));\n case 2: return elt0(_mm_unpackhi_ps(v,v));\n case 3: return elt0(_mm_shuffle_ps(v,v,_MM_SHUFFLE(3,2,1,0)));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_ps(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_ps(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_ps(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_ps(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_ps(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_ps(v,_mm_set1_pi32(0x7fffffffU));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_ps(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_ps(x.v);\n}\n\n#endif\n\n\n\n#if defined(__SSE2__) // SSE2 (Intel)\n\n#include <emmintrin.h>\n\ntemplate<>\nstruct vec_T<double> {\n typedef double scalar_t;\n typedef __m128d impl_t;\n impl_t v;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(_mm_set1_pd(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n : v(_mm_set_pd(a1,a0)) // reverse order!\n {\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \nprivate:\n static inline scalar_t elt0 (impl_t const& v)\n {\n return _mm_cvtss_f64(v); // this is a no-op\n }\npublic:\n inline scalar_t operator[] (size_t const d)\n {\n switch (d) {\n case 0: return elt0(v);\n case 1: return elt0(_mm_unpackhi_pd(v,v));\n }\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return _mm_load_pd(&a);\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return _mm_loadu_pd(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n _mm_store_pd(&p,v);\n }\n inline void storeu (scalar_t& p) const\n {\n _mm_storeu_pd(&p,v);\n }\n inline void store_nta (scalar_t& p) const\n {\n _mm_stream_pd(&p,v);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return _mm_and_pd(v,_mm_set1_epi64(0x7fffffffffffffffULL));\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_max_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return _mm_min_pd(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return _mm_sqrt_pd(x.v);\n}\n\n#endif\n\n```\n\nindirect/vectors-default.hh:\n```\nusing namespace std;\n\n\n\n// A class template that provides a vectorised type for the underlying\n// scalar type T. This implementation does \"nothing\", i.e. just\n// provides a \"vector\" class with a vector size of 1, forwarding all\n// operations to the scalar type.\n//\n// This implementation uses small integers in several places, e.g. in\n// the [] operator. This is efficient only if these integers are\n// compile time constants, so that the compiler can remove the\n// corresponding if and switch statements.\ntemplate<typename T>\nstruct vec_t {\n \n // Names for the underlying scalar type, and for the vector type\n // used to implement this class. For example, with SSE2, it would be\n // scalar_t=double, and impl_t=__m128d.\n typedef T scalar_t;\n typedef T impl_t;\n \n // The payload -- the actual vector content\n impl_t v;\n \n // Vector size (number of elements)\n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n // Constructors\n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(a)\n {\n }\n \n // Convert to the implementation vector type\n inline operator impl_t ()\n {\n return v;\n }\n \n // Access individual vector elements\n inline scalar_t operator[] (size_t const d) const\n {\n return v;\n }\n \n // Load vectors from memory. For convenience when using this class,\n // these accept references to the scalar type instead of pointers to\n // the vector type. These routines are static members of the class,\n // so that they can be used as VEC::load(p); if they were\n // stand-alone functions, one would have to write load<SCALAR>(p)\n // instead.\n //\n // Aligned load\n static inline vec_t load (scalar_t const& p)\n {\n return p;\n }\n // Unaligned load\n static inline vec_t loadu (scalar_t const& p)\n {\n return p;\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size. These functions are\n // useful e.g. for loading neightbouring grid points while\n // evaluating finite differencing stencils.\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return p;\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return p;\n }\n};\n\n// Store vectors to memory. These routines are stand-alone functions,\n// so that they can be used as vec_store(p,x); if they were class\n// members, one would have to write x.store(p) instead, or possibly\n// VEC::store(p,x).\n//\n// Aligned store\ntemplate<typename T>\ninline void vec_store (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Unaligned store\ntemplate<typename T>\ninline void vec_storeu (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Non-temporal store, i.e. a store that bypasses the cache\ntemplate<typename T>\ninline void vec_store_nta (typename vec_t<T>::scalar_t& p, vec_t<T> const& x)\n{\n p=x.v;\n}\n// Store the cnt lower elements of a vector, bypassing the cache if\n// possible\ntemplate<typename T>\ninline void vec_store_nta_partial_lo (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n// Store the cnt higher elements of a vector, bypassing the cache if\n// possible. This stores the vector elements into memory locations as\n// if element 0 were stored at p.\ntemplate<typename T>\ninline void vec_store_nta_partial_hi (typename vec_t<T>::scalar_t& p,\n vec_t<T> const& x,\n size_t const cnt)\n{\n assert(0);\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x)\n{\n return +x.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x)\n{\n return -x.v;\n}\n\ntemplate<typename T>\ninline vec_t<T> operator+ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v + y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator- (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v - y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator* (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v * y.v;\n}\ntemplate<typename T>\ninline vec_t<T> operator/ (vec_t<T> const& x, vec_t<T> const& y)\n{\n return x.v / y.v;\n}\n\ntemplate<typename T>\ninline vec_t<T>& operator+= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v += y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator-= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v -= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator*= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v *= y.v;\n return x;\n}\ntemplate<typename T>\ninline vec_t<T>& operator/= (vec_t<T>& x, vec_t<T> const& y)\n{\n x.v /= y.v;\n return x;\n}\n\ntemplate<typename T>\ninline vec_t<T> exp (vec_t<T> const& x)\n{\n return exp(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> fabs (vec_t<T> const& x)\n{\n return fabs(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> log (vec_t<T> const& x)\n{\n return log(x.v);\n}\ntemplate<typename T>\ninline vec_t<T> sqrt (vec_t<T> const& x)\n{\n return sqrt(x.v);\n}\n\ntemplate<typename T>\ninline vec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmax(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return fmin(x.v, y.v);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return pow(x.v, a);\n}\ntemplate<typename T>\ninline vec_t<T> pow (vec_t<T> const& x, int const& i)\n{\n return pow(x.v, i);\n}\n\n```\n\nindirect/vectors-power.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\n\n\n#if defined(__ALTIVEC__) // Altivec (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<float> {\n typedef float scalar_t;\n typedef vector float impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1,\n scalar_t const& a2, scalar_t const& a3)\n {\n v[0]=a0; v[1]=a1; v[2]=a2; v[3]=a3;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[2]=v[2];\n case 2: (&p)[1]=v[1];\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 4: store_nta(p); break;\n case 3: (&p)[1]=v[1];\n case 2: (&p)[2]=v[2];\n case 1: (&p)[3]=v[3];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]), exp(x.v[2]), exp(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]), log(x.v[2]), log(x.v[3]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a), pow(x.v[2],a), pow(x.v[3],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]), sqrt(x.v[2]), sqrt(x.v[3]));\n}\n\n#endif\n\n\n\n#if defined(__ALTIVEC__) && defined(_ARCH_PWR7) // Altivec VSX (Power)\n\n#include <altivec.h>\n\ntemplate<>\nstruct vec_t<double> {\n typedef double scalar_t;\n typedef vector double impl_t;\n \n static inline size_t size()\n {\n return sizeof(impl_t)/sizeof(scalar_t);\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n : v(vec_splats(a))\n {\n }\n inline vec_t (scalar_t const& a0, scalar_t const& a1)\n {\n v[0]=a0; v[1]=a1;\n }\n \n inline vec_t (impl_t const& w)\n : v(w)\n {\n }\n inline operator impl_t ()\n {\n return v;\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n return *(impl_t const*)&a;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return vec_load(&a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n if (off % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n if (off0 % size() == 0 and off1 % size() == 0 and off2 % size() == 0) {\n return load(p);\n } else {\n return loadu(p);\n }\n }\n inline void store (scalar_t& p) const\n {\n *(impl_t*)p = v;\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n // TODO: Use stvxl instruction?\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[0]=v[0];\n }\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n switch (cnt) {\n case 2: store_nta(p); break;\n case 1: (&p)[1]=v[1];\n }\n }\n \n inline vec_t operator+ () const\n {\n return +v;\n }\n inline vec_t operator- () const\n {\n return -v;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n return v+x.v;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n return v-x.v;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n return v*x.v;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n return v/x.v;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n return *this=*this+x;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n return *this=*this-x;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n return *this=/this+x;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n return vec_t(exp(x.v[0]), exp(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n return vec_abs(x.v);\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_max(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n return vec_min(x.v, y.v);\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n return vec_t(log(x.v[0]), log(x.v[1]));\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n return vec_t(pow(x.v[0],a), pow(x.v[1],a));\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n return vec_t(sqrt(x.v[0]), sqrt(x.v[1]));\n}\n\n#endif\n\n```\n\nindirect/vectors-pseudo.hh:\n```\n#include <cmath>\n#include <cstdlib>\nusing namespace std;\n\ntemplate<typename T>\nstruct vec_t {\n size_t const D = 2;\n typedef T scalar_t;\n typedef T impl_t;\n impl_t v[D];\n \n static inline size_t size()\n {\n return D;\n }\n \n inline vec_t ()\n {\n }\n inline vec_t (scalar_t const& a)\n {\n for (size_t d=0; d<D; ++d) v[d]=a;\n }\n \n inline operator impl_t ()\n {\n return v;\n }\n \n inline scalar_t operator[] (size_t const d) const\n {\n return v[d];\n }\n \n static inline vec_t load (scalar_t const& a)\n {\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=(&a)[d];\n return r;\n }\n static inline vec_t loadu (scalar_t const& a)\n {\n return load(a);\n }\n // Load a vector from memory that may or may not be aligned, as\n // decided by the offset and the vector size\n static inline vec_t loadu_maybe (int const off, scalar_t const& p)\n {\n return load(a);\n }\n static inline vec_t loadu_maybe3 (int const off0, int const off1,\n int const off2,\n scalar_t const& p)\n {\n return load(a);\n }\n inline void store (scalar_t& p) const\n {\n for (size_t d=0; d<D; ++d) (&p)[d]=v[d];\n }\n inline void storeu (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta (scalar_t& p) const\n {\n store(p);\n }\n inline void store_nta_partial_lo (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=0; d<cnt; ++d) (&p)[d]=v[d];\n }\n inline void store_nta_partial_hi (scalar_t& p, size_t const cnt) const\n {\n for (size_t d=D-cnt; d<D; ++d) (&p)[d]=v[d];\n }\n \n inline vec_t operator+ () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=+v[d];\n return r;\n }\n inline vec_t operator- () const\n {\n vec_t r=*this;\n for (size_t d=0; d<D; ++d) r.v[d]=-v[d];\n return r;\n }\n inline vec_t operator+ (vec_t const& x) const\n {\n vec_t r=*this;\n return r+=x;\n }\n inline vec_t operator- (vec_t const& x) const\n {\n vec_t r=*this;\n return r-=x;\n }\n inline vec_t operator* (vec_t const& x) const\n {\n vec_t r=*this;\n return r*=x;\n }\n inline vec_t operator/ (vec_t const& x) const\n {\n vec_t r=*this;\n return r/=x;\n }\n inline vec_t& operator+= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]+=x.v[d];\n return *this;\n }\n inline vec_t& operator-= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]-=x.v[d];\n return *this;\n }\n inline vec_t& operator*= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]*=x.v[d];\n return *this;\n }\n inline vec_t& operator/= (vec_t const& x)\n {\n for (size_t d=0; d<D; ++d) v[d]/=x.v[d];\n return *this;\n }\n};\n\ntemplate<typename T>\nvec_t<T> exp (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=exp(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fabs (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fabs(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmax (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmax(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> fmin (vec_t<T> const& x, vec_t<T> const& y)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=fmin(x.v[d],y.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> ifthen (bool const b, vec_t<T> const& x, vec_t<T> const& y)\n{\n return b ? x : y;\n}\nvec_t<T> log (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=log(x.v[d]);\n return r;\n}\ntemplate<typename T>\nvec_t<T> pow (vec_t<T> const& x, typename vec_t<T>::scalar_t const& a)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=pow(x.v[d],a);\n return r;\n}\nvec_t<T> sqrt (vec_t<T> const& x)\n{\n vec_t r;\n for (size_t d=0; d<D; ++d) r.v[d]=sqrt(x.v[d]);\n return r;\n}\n\n```\n\nindirect/vectors.hh:\n```\n#ifndef VECTORS_HH\n#define VECTORS_HH\n\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n\n // Default vector implementation, does not vectorise\n#include \"vectors-default.hh\"\n \n#if 0\n // Intel SSE vector instructions\n#include \"vectors-intel.hh\"\n \n // Power (Altivec) vector instructions\n#include \"vectors-power.hh\"\n#endif\n\n#endif // #ifndef VECTORS_HH\n\n```\n\n"},"doc_tex_content":{"kind":"string","value":"=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n"},"doc_tex_filenames":{"kind":"string","value":"documentation.tex"},"readme_content":{"kind":"string","value":"Cactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n"},"readme_filename":{"kind":"string","value":"README"},"combined_doc_context":{"kind":"string","value":"## README (README):\n```\nCactus Code Thorn Vectors\nAuthor(s) : Erik Schnetter <schnetter@cct.lsu.edu>\nMaintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>\nLicence : LGPLv2.1 or later\n--------------------------------------------------------------------------\n\n1. Purpose\n\nProvide C macro definitions and a C++ class template that help\nvectorisation.\n\n\n\n2. Build-time choices\n\nSeveral choices can be made via configuration options, which can be\nset to \"yes\" or \"no\":\n\nVECTORISE (default \"no\"): Vectorise. Otherwise, scalar code is\ngenerated, and the other options have no effect.\n\n\n\nVECTORISE_ALIGNED_ARRAYS (default \"no\", experimental): Assume that all\narrays have an extent in the x direction that is a multiple of the\nvector size. This allows aligned load operations e.g. for finite\ndifferencing operators in the y and z directions. (Setting this\nproduces faster code, but may lead to segfaults if the assumption is\nnot true.)\n\nVECTORISE_ALWAYS_USE_UNALIGNED_LOADS (default \"no\", experimental):\nReplace all aligned load operations with unaligned load operations.\nThis may simplify some code where alignment is unknown at compile\ntime. This should never lead to better code, since the default is to\nuse aligned load operations iff the alignment is known to permit this\nat build time. This options is probably useless.\n\nVECTORISE_ALWAYS_USE_ALIGNED_LOADS (default \"no\", experimental):\nReplace all unaligned load operations by (multiple) aligned load\noperations and corresponding vector-gather operations. This may be\nbeneficial if unaligned load operations are slow, and if vector-gather\noperations are fast.\n\nVECTORISE_INLINE (default \"no\"): Inline functions into the loop body\nas much as possible. This can cause some compilers to run out of\nmemory for complex codes. (Enabling this may increase code size, which\ncan degrade performance if the instruction cache is small, but may\nlead to increased performance due to omission of function-call\noverhead.)\n\nVECTORISE_STREAMING_STORES (default \"yes\"): Use streaming stores, i.e.\nuse store operations that bypass the cache. (Disabling this produces\nslower code.)\n\nVECTORISE_EMULATE_AVX (default \"no\", experimental): Emulate AVX\ninstructions with SSE2 instructions. This produces slower code, but\ncan be used to test AVX code on systems that don't support AVX.\n\n\n\n3. Tests\n\nCorrectness testing is run at startup (in CCTK_PARAMCHECK) provided the\nVectors thorn is in the list of ActiveThorns. This aims to test all vector\noperations by comparing the results with the same operations done using a\nscalar implementation. The number of passed tests is always reported. If any\ntest fails, the run is aborted immediately.\n\n\n\n4. Related software\n\n[1] Vc: portable, zero-overhead SIMD library for C++,\n<http://compeng.uni-frankfurt.de/index.php?id=88>\n\n[2] SLEEF - SIMD Library for Evaluating Elementary Functions,\n<http://shibatch.sourceforge.net>\n\n```\n\n## Documentation (.tex files):\nFiles: documentation.tex\n\n```tex\n=== documentation.tex ===\n% *======================================================================*\n% Cactus Thorn template for ThornGuide documentation\n% Author: Ian Kelley\n% Date: Sun Jun 02, 2002\n% $Header$\n%\n% Thorn documentation in the latex file doc/documentation.tex\n% will be included in ThornGuides built with the Cactus make system.\n% The scripts employed by the make system automatically include\n% pages about variables, parameters and scheduling parsed from the\n% relevant thorn CCL files.\n%\n% This template contains guidelines which help to assure that your\n% documentation will be correctly added to ThornGuides. More\n% information is available in the Cactus UsersGuide.\n%\n% Guidelines:\n% - Do not change anything before the line\n% % START CACTUS THORNGUIDE\",\n% except for filling in the title, author, date, etc. fields.\n% - Each of these fields should only be on ONE line.\n% - Author names should be separated with a \\\\ or a comma.\n% - You can define your own macros, but they must appear after\n% the START CACTUS THORNGUIDE line, and must not redefine standard\n% latex commands.\n% - To avoid name clashes with other thorns, 'labels', 'citations',\n% 'references', and 'image' names should conform to the following\n% convention:\n% ARRANGEMENT_THORN_LABEL\n% For example, an image wave.eps in the arrangement CactusWave and\n% thorn WaveToyC should be renamed to CactusWave_WaveToyC_wave.eps\n% - Graphics should only be included using the graphicx package.\n% More specifically, with the \"\\includegraphics\" command. Do\n% not specify any graphic file extensions in your .tex file. This\n% will allow us to create a PDF version of the ThornGuide\n% via pdflatex.\n% - References should be included with the latex \"\\bibitem\" command.\n% - Use \\begin{abstract}...\\end{abstract} instead of \\abstract{...}\n% - Do not use \\appendix, instead include any appendices you need as\n% standard sections.\n% - For the benefit of our Perl scripts, and for future extensions,\n% please use simple latex.\n%\n% *======================================================================*\n%\n% Example of including a graphic image:\n% \\begin{figure}[ht]\n% \t\\begin{center}\n% \t \\includegraphics[width=6cm]{MyArrangement_MyThorn_MyFigure}\n% \t\\end{center}\n% \t\\caption{Illustration of this and that}\n% \t\\label{MyArrangement_MyThorn_MyLabel}\n% \\end{figure}\n%\n% Example of using a label:\n% \\label{MyArrangement_MyThorn_MyLabel}\n%\n% Example of a citation:\n% \\cite{MyArrangement_MyThorn_Author99}\n%\n% Example of including a reference\n% \\bibitem{MyArrangement_MyThorn_Author99}\n% {J. Author, {\\em The Title of the Book, Journal, or periodical}, 1 (1999),\n% 1--16. {\\tt http://www.nowhere.com/}}\n%\n% *======================================================================*\n\n% If you are using CVS use this line to give version information\n% $Header$\n\n\\documentclass{article}\n\n% Use the Cactus ThornGuide style file\n% (Automatically used from Cactus distribution, if you have a\n% thorn without the Cactus Flesh download this from the Cactus\n% homepage at www.cactuscode.org)\n\\usepackage{../../../../doc/latex/cactus}\n\n\\begin{document}\n\n% The author of the documentation\n\\author{Erik Schnetter \\textless schnetter@cct.lsu.edu\\textgreater}\n\n% The title of the document (not necessarily the name of the Thorn)\n\\title{Vectors}\n\n% the date your document was last changed, if your document is in CVS,\n% please use:\n% \\date{$ $Date: 2004-01-07 14:12:39 -0600 (Wed, 07 Jan 2004) $ $}\n\\date{November 24 2010}\n\n\\maketitle\n\n% Do not delete next line\n% START CACTUS THORNGUIDE\n\n% Add all definitions used in this documentation here\n% \\def\\mydef etc\n\n% Add an abstract for this thorn's documentation\n\\begin{abstract}\n\n\\end{abstract}\n\n% The following sections are suggestive only.\n% Remove them or add your own.\n\n\\section{Introduction}\n\n\\section{Physical System}\n\n\\section{Numerical Implementation}\n\n\\section{Using This Thorn}\n\n\\subsection{Obtaining This Thorn}\n\n\\subsection{Basic Usage}\n\n\\subsection{Special Behaviour}\n\n\\subsection{Interaction With Other Thorns}\n\n\\subsection{Examples}\n\n\\subsection{Support and Feedback}\n\n\\section{History}\n\n\\subsection{Thorn Source Code}\n\n\\subsection{Thorn Documentation}\n\n\\subsection{Acknowledgements}\n\n\n\\begin{thebibliography}{9}\n\n\\end{thebibliography}\n\n% Do not delete next line\n% END CACTUS THORNGUIDE\n\n\\end{document}\n\n```\n\n"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":1085,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NjUxMTc1MSwic3ViIjoiL2RhdGFzZXRzL3hpbnNodW8vRVRfMWsiLCJleHAiOjE3NzY1MTUzNTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.bowkIX1ozIZnRuFQVtGvEtFBhO2eAqdzYhKCszzoD3YWfvHQtxopCD4UTXJKwWcxvQOVBqmQCYuyXABqkyEmAg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":1085,"numBytesParquet":146493094}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
thorn_name stringclasses 66
values | url stringclasses 12
values | configuration stringclasses 40
values | interface stringclasses 66
values | param stringclasses 66
values | schedule stringclasses 66
values | src_filename stringlengths 5 52 | src_code stringlengths 0 349k | context_filenames stringlengths 8 3.24k | context stringlengths 118 2M | doc_tex_content stringclasses 40
values | doc_tex_filenames stringclasses 5
values | readme_content stringclasses 58
values | readme_filename stringclasses 2
values | combined_doc_context stringclasses 58
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
CactusExamples/Poisson | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn Poisson
REQUIRES Boundary Carpet CartGrid3D TATelliptic
| # Interface definition for thorn Poisson
IMPLEMENTS: Poisson
INHERITS: boundary grid
USES INCLUDE HEADER: carpet.h
USES INCLUDE HEADER: TATelliptic.h
CCTK_INT FUNCTION Boundary_SelectGroupForBC \
(CCTK_POINTER_TO_CONST IN cctkGH, \
CCTK_INT IN faces, \
CCTK_INT IN boundary_... | # Parameter definitions for thorn Poisson
STRING solver "Name of TATelliptic solver that should be used"
{
.* :: "must be an activated TATelliptic solver"
} "TATJacobi"
STRING options "Options for the solver"
{
.* :: "no restriction"
} ""
REAL radius "Radius of uniformly charged sphere"
{
0:* :: ""
} 1.0
RE... | # Schedule definitions for thorn Poisson
STORAGE: potential residual
SCHEDULE Poisson_prepare AT initial
{
LANG: C
} "Set up initial guess for initial data"
SCHEDULE Poisson_solve AT postinitial
{
LANG: C
# OPTIONS: global
} "Calculate uniform charge initial data"
SCHEDULE GROUP Poisson_boundaries
{
} "Apply ... | uniform_charge.c | #include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <util_ErrorCodes.h>
#include <util_Table.h>
#include <carpet.h>
#include <TATelliptic.h>
static int calc_residual (const cGH * const cctkGH,
... | make.code.defn
| make.code.defn:
```
# Main make.code.defn file for thorn Poisson
# Source files in this directory
SRCS = uniform_charge.c
# Subdirectories containing source files
SUBDIRS =
```
| === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Poisson
Author(s) : Erik Schnetter <schnetter@gmail.com>
Maintainer(s): Erik Schnetter <schnetter@gmail.com>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Solve the Poisson equation with the TATelliptic framework.
| README | ## README (README):
```
Cactus Code Thorn Poisson
Author(s) : Erik Schnetter <schnetter@gmail.com>
Maintainer(s): Erik Schnetter <schnetter@gmail.com>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Solve the Poisson equation with the TATelliptic framework.
... |
CactusExamples/Poisson | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn Poisson
REQUIRES Boundary Carpet CartGrid3D TATelliptic
| # Interface definition for thorn Poisson
IMPLEMENTS: Poisson
INHERITS: boundary grid
USES INCLUDE HEADER: carpet.h
USES INCLUDE HEADER: TATelliptic.h
CCTK_INT FUNCTION Boundary_SelectGroupForBC \
(CCTK_POINTER_TO_CONST IN cctkGH, \
CCTK_INT IN faces, \
CCTK_INT IN boundary_... | # Parameter definitions for thorn Poisson
STRING solver "Name of TATelliptic solver that should be used"
{
.* :: "must be an activated TATelliptic solver"
} "TATJacobi"
STRING options "Options for the solver"
{
.* :: "no restriction"
} ""
REAL radius "Radius of uniformly charged sphere"
{
0:* :: ""
} 1.0
RE... | # Schedule definitions for thorn Poisson
STORAGE: potential residual
SCHEDULE Poisson_prepare AT initial
{
LANG: C
} "Set up initial guess for initial data"
SCHEDULE Poisson_solve AT postinitial
{
LANG: C
# OPTIONS: global
} "Calculate uniform charge initial data"
SCHEDULE GROUP Poisson_boundaries
{
} "Apply ... | make.code.defn | # Main make.code.defn file for thorn Poisson
# Source files in this directory
SRCS = uniform_charge.c
# Subdirectories containing source files
SUBDIRS =
| uniform_charge.c
| uniform_charge.c:
```
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <util_ErrorCodes.h>
#include <util_Table.h>
#include <carpet.h>
#include <TATelliptic.h>
static int calc_residual (const cGH * con... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Poisson
Author(s) : Erik Schnetter <schnetter@gmail.com>
Maintainer(s): Erik Schnetter <schnetter@gmail.com>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Solve the Poisson equation with the TATelliptic framework.
| README | ## README (README):
```
Cactus Code Thorn Poisson
Author(s) : Erik Schnetter <schnetter@gmail.com>
Maintainer(s): Erik Schnetter <schnetter@gmail.com>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Solve the Poisson equation with the TATelliptic framework.
... |
CactusExamples/SampleBoundary | https://bitbucket.org/cactuscode/cactusexamples.git | # Interface definition for thorn SampleBoundary
# $Header$
implements: LinExtrapBnd
CCTK_INT FUNCTION Boundary_RegisterPhysicalBC(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN CCTK_FPOINTER function_pointer(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN num_vars, \
... | # Parameter definitions for thorn SampleBoundary
# $Header$
| # Schedule definitions for thorn SampleBoundary
# $Header$
schedule SampleBoundary_RegisterBCs at CCTK_BASEGRID
{
lang: C
} "Register boundary conditions that this thorn provides"
| Register.c | /*@@
@file Register.c
@date 6 May 2003
@author David Rideout
@desc
Register implemented boundary conditions.
@enddesc
@version $Header$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "SampleBnd.h"
static const char *rcsid = "$Header$";
CCTK_FILEVERSION(... | SampleBnd.h
LinearExtrapBnd.c
make.code.defn
LinearExtrapBnd.F
| SampleBnd.h:
```
/*@@
@file SampleBnd.h
@date 6 May 2003
@author David Rideout
@desc
Prototypes for boundary routines
@enddesc
@@*/
#ifndef _SAMPLEBND_H_
#define _SAMPLEBND_H_
#ifdef __cplusplus
extern "C"
{
#endif
/* data type for pointer to function which implements a ... | === documentation.tex ===
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used from Cactus distribution, if you have a
% thorn without the Cactus Flesh download this from the Cactus
% homepage at www.cactuscode.org)
\usepackage{../../../../doc/latex/cactus}
\begin{document}
\title{... | documentation.tex | Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register a
physical boundary cond... | README | ## README (README):
```
Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register ... | |
CactusExamples/SampleBoundary | https://bitbucket.org/cactuscode/cactusexamples.git | # Interface definition for thorn SampleBoundary
# $Header$
implements: LinExtrapBnd
CCTK_INT FUNCTION Boundary_RegisterPhysicalBC(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN CCTK_FPOINTER function_pointer(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN num_vars, \
... | # Parameter definitions for thorn SampleBoundary
# $Header$
| # Schedule definitions for thorn SampleBoundary
# $Header$
schedule SampleBoundary_RegisterBCs at CCTK_BASEGRID
{
lang: C
} "Register boundary conditions that this thorn provides"
| SampleBnd.h | /*@@
@file SampleBnd.h
@date 6 May 2003
@author David Rideout
@desc
Prototypes for boundary routines
@enddesc
@@*/
#ifndef _SAMPLEBND_H_
#define _SAMPLEBND_H_
#ifdef __cplusplus
extern "C"
{
#endif
/* data type for pointer to function which implements a physical boundary... | Register.c
LinearExtrapBnd.c
make.code.defn
LinearExtrapBnd.F
| Register.c:
```
/*@@
@file Register.c
@date 6 May 2003
@author David Rideout
@desc
Register implemented boundary conditions.
@enddesc
@version $Header$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "SampleBnd.h"
static const char *rcsid = "$Header$";
C... | === documentation.tex ===
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used from Cactus distribution, if you have a
% thorn without the Cactus Flesh download this from the Cactus
% homepage at www.cactuscode.org)
\usepackage{../../../../doc/latex/cactus}
\begin{document}
\title{... | documentation.tex | Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register a
physical boundary cond... | README | ## README (README):
```
Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register ... | |
CactusExamples/SampleBoundary | https://bitbucket.org/cactuscode/cactusexamples.git | # Interface definition for thorn SampleBoundary
# $Header$
implements: LinExtrapBnd
CCTK_INT FUNCTION Boundary_RegisterPhysicalBC(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN CCTK_FPOINTER function_pointer(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN num_vars, \
... | # Parameter definitions for thorn SampleBoundary
# $Header$
| # Schedule definitions for thorn SampleBoundary
# $Header$
schedule SampleBoundary_RegisterBCs at CCTK_BASEGRID
{
lang: C
} "Register boundary conditions that this thorn provides"
| LinearExtrapBnd.c | /*@@
@file LinearExtrapBnd.c
@date 24 Jan 2003
@author David Rideout
@desc
Function which is registered as handling Carsten Gundlach's
"linear_extrap_one_bndry" boundary condition
@enddesc
@history
@hdate
@hauthor
@hdesc
@endhistory
... | Register.c
SampleBnd.h
make.code.defn
LinearExtrapBnd.F
| Register.c:
```
/*@@
@file Register.c
@date 6 May 2003
@author David Rideout
@desc
Register implemented boundary conditions.
@enddesc
@version $Header$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "SampleBnd.h"
static const char *rcsid = "$Header$";
C... | === documentation.tex ===
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used from Cactus distribution, if you have a
% thorn without the Cactus Flesh download this from the Cactus
% homepage at www.cactuscode.org)
\usepackage{../../../../doc/latex/cactus}
\begin{document}
\title{... | documentation.tex | Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register a
physical boundary cond... | README | ## README (README):
```
Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register ... | |
CactusExamples/SampleBoundary | https://bitbucket.org/cactuscode/cactusexamples.git | # Interface definition for thorn SampleBoundary
# $Header$
implements: LinExtrapBnd
CCTK_INT FUNCTION Boundary_RegisterPhysicalBC(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN CCTK_FPOINTER function_pointer(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN num_vars, \
... | # Parameter definitions for thorn SampleBoundary
# $Header$
| # Schedule definitions for thorn SampleBoundary
# $Header$
schedule SampleBoundary_RegisterBCs at CCTK_BASEGRID
{
lang: C
} "Register boundary conditions that this thorn provides"
| make.code.defn | # Main make.code.defn file for thorn SampleBoundary
# $Header$
# Source files in this directory
SRCS = Register.c LinearExtrapBnd.c LinearExtrapBnd.F
# Subdirectories containing source files
SUBDIRS =
| Register.c
SampleBnd.h
LinearExtrapBnd.c
LinearExtrapBnd.F
| Register.c:
```
/*@@
@file Register.c
@date 6 May 2003
@author David Rideout
@desc
Register implemented boundary conditions.
@enddesc
@version $Header$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "SampleBnd.h"
static const char *rcsid = "$Header$";
C... | === documentation.tex ===
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used from Cactus distribution, if you have a
% thorn without the Cactus Flesh download this from the Cactus
% homepage at www.cactuscode.org)
\usepackage{../../../../doc/latex/cactus}
\begin{document}
\title{... | documentation.tex | Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register a
physical boundary cond... | README | ## README (README):
```
Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register ... | |
CactusExamples/SampleBoundary | https://bitbucket.org/cactuscode/cactusexamples.git | # Interface definition for thorn SampleBoundary
# $Header$
implements: LinExtrapBnd
CCTK_INT FUNCTION Boundary_RegisterPhysicalBC(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN CCTK_FPOINTER function_pointer(CCTK_POINTER_TO_CONST IN GH, \
CCTK_INT IN num_vars, \
... | # Parameter definitions for thorn SampleBoundary
# $Header$
| # Schedule definitions for thorn SampleBoundary
# $Header$
schedule SampleBoundary_RegisterBCs at CCTK_BASEGRID
{
lang: C
} "Register boundary conditions that this thorn provides"
| LinearExtrapBnd.F | c This subroutine linearly extrapolates one Cactus variable
c on one boundary of the Cactus grid box.
C $Header$
#include "cctk.h"
subroutine Linear_extrap_one_bndry(doBC, lsh, var)
implicit none
integer doBC(6)
integer lsh(3)
CCTK_REAL var(lsh(1),lsh(2),lsh(3))
integer nx,ny,n... | Register.c
SampleBnd.h
LinearExtrapBnd.c
make.code.defn
| Register.c:
```
/*@@
@file Register.c
@date 6 May 2003
@author David Rideout
@desc
Register implemented boundary conditions.
@enddesc
@version $Header$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "SampleBnd.h"
static const char *rcsid = "$Header$";
C... | === documentation.tex ===
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used from Cactus distribution, if you have a
% thorn without the Cactus Flesh download this from the Cactus
% homepage at www.cactuscode.org)
\usepackage{../../../../doc/latex/cactus}
\begin{document}
\title{... | documentation.tex | Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register a
physical boundary cond... | README | ## README (README):
```
Cactus Code Thorn SampleBoundary
Author(s) : Carsten Gundlach
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn provides a simple example of how to create and register ... | |
CactusExamples/WaveMoL | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn BSSN_MoL
# $Header$
REQUIRES CartGrid3D Boundary
| # Interface definition for thorn WaveMoL
# $Header$
implements: wavemol
USES INCLUDE: Symmetry.h
CCTK_INT FUNCTION MoLRegisterEvolvedGroup(CCTK_INT IN EvolvedIndex, \
CCTK_INT IN RHSIndex)
CCTK_INT FUNCTION MoLRegisterConstrained(CCTK_INT IN ConstrainedIndex)
REQUIRES FUNCT... | # Parameter definitions for thorn WaveMoL
# $Header$
shares: MethodOfLines
USES CCTK_INT MoL_Num_Evolved_Vars
USES CCTK_INT MoL_Num_Constrained_Vars
USES CCTK_INT MoL_Num_SaveAndRestore_Vars
restricted:
CCTK_INT WaveMoL_MaxNumEvolvedVars "The maximum number of evolved variables used by WaveMoL" ACCUMULATOR-BASE=Met... | # Schedule definitions for thorn WaveMoL
# $Header$
STORAGE: scalarevolvemol_scalar[3], scalarevolvemol_vector[3]
STORAGE: scalarrhsmol_scalar, scalarrhsmol_vector
STORAGE: energy
schedule WaveMoL_Startup at STARTUP
{
LANG: C
} "Register Banner"
schedule WaveMoL_InitSymBound at BASEGRID
{
LANG: C
OPTIONS: META... | WaveMoLRegister.c | /*@@
@file WaveMoLRegister.c
@date Fri Nov 9 13:47:07 2001
@author Ian Hawke
@desc
Routine to register the variables with the MoL thorn.
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Header$";
CCTK_FILEVERSION... | WaveMoL.c
make.code.defn
InitSymBound.c
Startup.c
| WaveMoL.c:
```
/*@@
@file WaveMoL.c
@date Fri Nov 9 13:33:25 2001
@author Ian Hawke
@desc
The equivalent of WaveToy.c
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
/*
#ifndef DEBUG_MOL
#define DEBUG_MOL
#endif
*/
static const char *rc... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic test.
| README | ## README (README):
```
Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic tes... |
CactusExamples/WaveMoL | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn BSSN_MoL
# $Header$
REQUIRES CartGrid3D Boundary
| # Interface definition for thorn WaveMoL
# $Header$
implements: wavemol
USES INCLUDE: Symmetry.h
CCTK_INT FUNCTION MoLRegisterEvolvedGroup(CCTK_INT IN EvolvedIndex, \
CCTK_INT IN RHSIndex)
CCTK_INT FUNCTION MoLRegisterConstrained(CCTK_INT IN ConstrainedIndex)
REQUIRES FUNCT... | # Parameter definitions for thorn WaveMoL
# $Header$
shares: MethodOfLines
USES CCTK_INT MoL_Num_Evolved_Vars
USES CCTK_INT MoL_Num_Constrained_Vars
USES CCTK_INT MoL_Num_SaveAndRestore_Vars
restricted:
CCTK_INT WaveMoL_MaxNumEvolvedVars "The maximum number of evolved variables used by WaveMoL" ACCUMULATOR-BASE=Met... | # Schedule definitions for thorn WaveMoL
# $Header$
STORAGE: scalarevolvemol_scalar[3], scalarevolvemol_vector[3]
STORAGE: scalarrhsmol_scalar, scalarrhsmol_vector
STORAGE: energy
schedule WaveMoL_Startup at STARTUP
{
LANG: C
} "Register Banner"
schedule WaveMoL_InitSymBound at BASEGRID
{
LANG: C
OPTIONS: META... | WaveMoL.c | /*@@
@file WaveMoL.c
@date Fri Nov 9 13:33:25 2001
@author Ian Hawke
@desc
The equivalent of WaveToy.c
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
/*
#ifndef DEBUG_MOL
#define DEBUG_MOL
#endif
*/
static const char *rcsid = "$Header$... | WaveMoLRegister.c
make.code.defn
InitSymBound.c
Startup.c
| WaveMoLRegister.c:
```
/*@@
@file WaveMoLRegister.c
@date Fri Nov 9 13:47:07 2001
@author Ian Hawke
@desc
Routine to register the variables with the MoL thorn.
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Head... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic test.
| README | ## README (README):
```
Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic tes... |
CactusExamples/WaveMoL | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn BSSN_MoL
# $Header$
REQUIRES CartGrid3D Boundary
| # Interface definition for thorn WaveMoL
# $Header$
implements: wavemol
USES INCLUDE: Symmetry.h
CCTK_INT FUNCTION MoLRegisterEvolvedGroup(CCTK_INT IN EvolvedIndex, \
CCTK_INT IN RHSIndex)
CCTK_INT FUNCTION MoLRegisterConstrained(CCTK_INT IN ConstrainedIndex)
REQUIRES FUNCT... | # Parameter definitions for thorn WaveMoL
# $Header$
shares: MethodOfLines
USES CCTK_INT MoL_Num_Evolved_Vars
USES CCTK_INT MoL_Num_Constrained_Vars
USES CCTK_INT MoL_Num_SaveAndRestore_Vars
restricted:
CCTK_INT WaveMoL_MaxNumEvolvedVars "The maximum number of evolved variables used by WaveMoL" ACCUMULATOR-BASE=Met... | # Schedule definitions for thorn WaveMoL
# $Header$
STORAGE: scalarevolvemol_scalar[3], scalarevolvemol_vector[3]
STORAGE: scalarrhsmol_scalar, scalarrhsmol_vector
STORAGE: energy
schedule WaveMoL_Startup at STARTUP
{
LANG: C
} "Register Banner"
schedule WaveMoL_InitSymBound at BASEGRID
{
LANG: C
OPTIONS: META... | make.code.defn | # Main make.code.defn file for thorn WaveMoL
# $Header$
# Source files in this directory
SRCS = WaveMoL.c InitSymBound.c Startup.c WaveMoLRegister.c
# Subdirectories containing source files
SUBDIRS =
| WaveMoLRegister.c
WaveMoL.c
InitSymBound.c
Startup.c
| WaveMoLRegister.c:
```
/*@@
@file WaveMoLRegister.c
@date Fri Nov 9 13:47:07 2001
@author Ian Hawke
@desc
Routine to register the variables with the MoL thorn.
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Head... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic test.
| README | ## README (README):
```
Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic tes... |
CactusExamples/WaveMoL | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn BSSN_MoL
# $Header$
REQUIRES CartGrid3D Boundary
| # Interface definition for thorn WaveMoL
# $Header$
implements: wavemol
USES INCLUDE: Symmetry.h
CCTK_INT FUNCTION MoLRegisterEvolvedGroup(CCTK_INT IN EvolvedIndex, \
CCTK_INT IN RHSIndex)
CCTK_INT FUNCTION MoLRegisterConstrained(CCTK_INT IN ConstrainedIndex)
REQUIRES FUNCT... | # Parameter definitions for thorn WaveMoL
# $Header$
shares: MethodOfLines
USES CCTK_INT MoL_Num_Evolved_Vars
USES CCTK_INT MoL_Num_Constrained_Vars
USES CCTK_INT MoL_Num_SaveAndRestore_Vars
restricted:
CCTK_INT WaveMoL_MaxNumEvolvedVars "The maximum number of evolved variables used by WaveMoL" ACCUMULATOR-BASE=Met... | # Schedule definitions for thorn WaveMoL
# $Header$
STORAGE: scalarevolvemol_scalar[3], scalarevolvemol_vector[3]
STORAGE: scalarrhsmol_scalar, scalarrhsmol_vector
STORAGE: energy
schedule WaveMoL_Startup at STARTUP
{
LANG: C
} "Register Banner"
schedule WaveMoL_InitSymBound at BASEGRID
{
LANG: C
OPTIONS: META... | InitSymBound.c | /*@@
@file InitSymBound.c
@date Fri Nov 9 13:29:53 2001
@author Ian Hawke
@desc
Sets the symmetries for Wave Toy - again copies the standard.
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "Symmetry.h"
static const char *rcsid = "$Header$";
CCTK_FILEVERSION(... | WaveMoLRegister.c
WaveMoL.c
make.code.defn
Startup.c
| WaveMoLRegister.c:
```
/*@@
@file WaveMoLRegister.c
@date Fri Nov 9 13:47:07 2001
@author Ian Hawke
@desc
Routine to register the variables with the MoL thorn.
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Head... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic test.
| README | ## README (README):
```
Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic tes... |
CactusExamples/WaveMoL | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn BSSN_MoL
# $Header$
REQUIRES CartGrid3D Boundary
| # Interface definition for thorn WaveMoL
# $Header$
implements: wavemol
USES INCLUDE: Symmetry.h
CCTK_INT FUNCTION MoLRegisterEvolvedGroup(CCTK_INT IN EvolvedIndex, \
CCTK_INT IN RHSIndex)
CCTK_INT FUNCTION MoLRegisterConstrained(CCTK_INT IN ConstrainedIndex)
REQUIRES FUNCT... | # Parameter definitions for thorn WaveMoL
# $Header$
shares: MethodOfLines
USES CCTK_INT MoL_Num_Evolved_Vars
USES CCTK_INT MoL_Num_Constrained_Vars
USES CCTK_INT MoL_Num_SaveAndRestore_Vars
restricted:
CCTK_INT WaveMoL_MaxNumEvolvedVars "The maximum number of evolved variables used by WaveMoL" ACCUMULATOR-BASE=Met... | # Schedule definitions for thorn WaveMoL
# $Header$
STORAGE: scalarevolvemol_scalar[3], scalarevolvemol_vector[3]
STORAGE: scalarrhsmol_scalar, scalarrhsmol_vector
STORAGE: energy
schedule WaveMoL_Startup at STARTUP
{
LANG: C
} "Register Banner"
schedule WaveMoL_InitSymBound at BASEGRID
{
LANG: C
OPTIONS: META... | Startup.c | /*@@
@file Startup.c
@date Fri Nov 9 13:27:48 2001
@author Ian Hawke
@desc
Register banner - a straight copy of WaveToy.
@enddesc
@@*/
#include "cctk.h"
static const char *rcsid = "$Header$";
CCTK_FILEVERSION(CactusExamples_WaveMoL_Startup_c)
int WaveMoL_Startup(void);
/*@@
... | WaveMoLRegister.c
WaveMoL.c
make.code.defn
InitSymBound.c
| WaveMoLRegister.c:
```
/*@@
@file WaveMoLRegister.c
@date Fri Nov 9 13:47:07 2001
@author Ian Hawke
@desc
Routine to register the variables with the MoL thorn.
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Head... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic test.
| README | ## README (README):
```
Cactus Code Thorn WaveMoL
Author(s) : Ian Hawke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This implements the wave equation in FOSH form for use with the Method
of Lines thorn. Intended as a basic tes... |
CactusExamples/WaveToy1DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy1DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy1DF77
# $Header$
implements: wavetoy1d
inherits: boundary
private:
cctk_real evolve1d dim=1 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=1 type=GF
{
timederiv
} "For initial data"
cctk_real dummy dim=1 type=GF
{
phi_temp
} "Just for cr... | # Parameter definitions for thorn WaveToy1DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real center "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real sigma "Width of Gaussian wave"
{
*:* :: "Anything"
} 0.02
# Boundary
ke... | # Schedule definitions for thorn WaveToy1DF77
# $Header$
STORAGE: evolve1d[3],coords1d
schedule WaveToy1DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy1DF77 banner"
schedule WaveToy1DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy1DF77 coordinates"
schedule WaveToy1DF77_Coord as Spat... | Evolve.F77 | /*@@
@file Evolve.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Evolution routines for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy1DF77_Evolve
@date June 13 2000
@author Ga... | Startup.F77
Initial.F77
Coord.F77
make.code.defn
Boundary.F77
| Startup.F77:
```
/*@@
@file Startup.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Register banner for WaveToy1DF77
@enddesc
@version $Header$
@@*/
#include "cctk.h"
integer function WaveToy1DF77_Startup()
implicit none
integer ierr
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finit... |
CactusExamples/WaveToy1DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy1DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy1DF77
# $Header$
implements: wavetoy1d
inherits: boundary
private:
cctk_real evolve1d dim=1 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=1 type=GF
{
timederiv
} "For initial data"
cctk_real dummy dim=1 type=GF
{
phi_temp
} "Just for cr... | # Parameter definitions for thorn WaveToy1DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real center "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real sigma "Width of Gaussian wave"
{
*:* :: "Anything"
} 0.02
# Boundary
ke... | # Schedule definitions for thorn WaveToy1DF77
# $Header$
STORAGE: evolve1d[3],coords1d
schedule WaveToy1DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy1DF77 banner"
schedule WaveToy1DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy1DF77 coordinates"
schedule WaveToy1DF77_Coord as Spat... | Startup.F77 | /*@@
@file Startup.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Register banner for WaveToy1DF77
@enddesc
@version $Header$
@@*/
#include "cctk.h"
integer function WaveToy1DF77_Startup()
implicit none
integer ierr
call CCTK_Registe... | Evolve.F77
Initial.F77
Coord.F77
make.code.defn
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Evolution routines for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy1DF77_Evolve
@date June 13 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finit... |
CactusExamples/WaveToy1DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy1DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy1DF77
# $Header$
implements: wavetoy1d
inherits: boundary
private:
cctk_real evolve1d dim=1 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=1 type=GF
{
timederiv
} "For initial data"
cctk_real dummy dim=1 type=GF
{
phi_temp
} "Just for cr... | # Parameter definitions for thorn WaveToy1DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real center "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real sigma "Width of Gaussian wave"
{
*:* :: "Anything"
} 0.02
# Boundary
ke... | # Schedule definitions for thorn WaveToy1DF77
# $Header$
STORAGE: evolve1d[3],coords1d
schedule WaveToy1DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy1DF77 banner"
schedule WaveToy1DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy1DF77 coordinates"
schedule WaveToy1DF77_Coord as Spat... | Initial.F77 | /*@@
@file Initial.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Initial data for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy1DF77_Initial
@date June ... | Evolve.F77
Startup.F77
Coord.F77
make.code.defn
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Evolution routines for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy1DF77_Evolve
@date June 13 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finit... |
CactusExamples/WaveToy1DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy1DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy1DF77
# $Header$
implements: wavetoy1d
inherits: boundary
private:
cctk_real evolve1d dim=1 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=1 type=GF
{
timederiv
} "For initial data"
cctk_real dummy dim=1 type=GF
{
phi_temp
} "Just for cr... | # Parameter definitions for thorn WaveToy1DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real center "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real sigma "Width of Gaussian wave"
{
*:* :: "Anything"
} 0.02
# Boundary
ke... | # Schedule definitions for thorn WaveToy1DF77
# $Header$
STORAGE: evolve1d[3],coords1d
schedule WaveToy1DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy1DF77 banner"
schedule WaveToy1DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy1DF77 coordinates"
schedule WaveToy1DF77_Coord as Spat... | Coord.F77 | /*@@
@file Coord.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Coordinates for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include "cctk_Functions.h"
/*@@
@routine WaveToy1DF77_Reg... | Evolve.F77
Startup.F77
Initial.F77
make.code.defn
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Evolution routines for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy1DF77_Evolve
@date June 13 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finit... |
CactusExamples/WaveToy1DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy1DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy1DF77
# $Header$
implements: wavetoy1d
inherits: boundary
private:
cctk_real evolve1d dim=1 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=1 type=GF
{
timederiv
} "For initial data"
cctk_real dummy dim=1 type=GF
{
phi_temp
} "Just for cr... | # Parameter definitions for thorn WaveToy1DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real center "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real sigma "Width of Gaussian wave"
{
*:* :: "Anything"
} 0.02
# Boundary
ke... | # Schedule definitions for thorn WaveToy1DF77
# $Header$
STORAGE: evolve1d[3],coords1d
schedule WaveToy1DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy1DF77 banner"
schedule WaveToy1DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy1DF77 coordinates"
schedule WaveToy1DF77_Coord as Spat... | make.code.defn | # Main make.code.defn file for thorn WaveToy1DF77
# $Header$
# Source files in this directory
SRCS = Evolve.F77\
Startup.F77\
Initial.F77\
Coord.F77\
Boundary.F77
# Subdirectories containing source files
SUBDIRS =
| Evolve.F77
Startup.F77
Initial.F77
Coord.F77
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Evolution routines for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy1DF77_Evolve
@date June 13 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finit... |
CactusExamples/WaveToy1DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy1DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy1DF77
# $Header$
implements: wavetoy1d
inherits: boundary
private:
cctk_real evolve1d dim=1 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=1 type=GF
{
timederiv
} "For initial data"
cctk_real dummy dim=1 type=GF
{
phi_temp
} "Just for cr... | # Parameter definitions for thorn WaveToy1DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real center "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real sigma "Width of Gaussian wave"
{
*:* :: "Anything"
} 0.02
# Boundary
ke... | # Schedule definitions for thorn WaveToy1DF77
# $Header$
STORAGE: evolve1d[3],coords1d
schedule WaveToy1DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy1DF77 banner"
schedule WaveToy1DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy1DF77 coordinates"
schedule WaveToy1DF77_Coord as Spat... | Boundary.F77 | /*@@
@file Boundary.F77
@date July 15th 2000
@author Gabrielle Allen
@desc
Apply boundary conditions for 1D Wave Equation
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Functions.h"
#include "cctk_Parameters.h"
subroutine WaveToy1DF77_Boundary(CCTK_... | Evolve.F77
Startup.F77
Initial.F77
Coord.F77
make.code.defn
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Evolution routines for the 1d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy1DF77_Evolve
@date June 13 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy1DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 1D using
centered explicit finit... |
CactusExamples/WaveToy2DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy2DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy2DF77
# $Header$
implements: wavetoy2d
inherits: boundary
private:
cctk_real evolve2d dim=2 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=2 type=GF
{
timederiv
} "For initial data"
cctk_real coords2d dim=2 type=GF
{
x,
y
} "The 2D x a... | # Parameter definitions for thorn WaveToy2DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real xcenter "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real ycenter "y-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5... | # Schedule definitions for thorn WaveToy2DF77
# $Header$
STORAGE: evolve2d[3],coords2d
schedule WaveToy2DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy2DF77 banner"
schedule WaveToy2DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy2DF77 coordinates"
schedule WaveToy2DF77_Coord as Spat... | Evolve.F77 | /*@@
@file Evolve.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Evolution routines for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy2DF77_Evolve
@date July 2 2000
@author Gabr... | Startup.F77
Initial.F77
Coord.F77
make.code.defn
Boundary.F77
| Startup.F77:
```
/*@@
@file Startup.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Register banner for WaveToy2DF77
@enddesc
@version $Header$
@@*/
#include "cctk.h"
integer function WaveToy2DF77_Startup()
implicit none
integer ierr
c... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finit... |
CactusExamples/WaveToy2DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy2DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy2DF77
# $Header$
implements: wavetoy2d
inherits: boundary
private:
cctk_real evolve2d dim=2 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=2 type=GF
{
timederiv
} "For initial data"
cctk_real coords2d dim=2 type=GF
{
x,
y
} "The 2D x a... | # Parameter definitions for thorn WaveToy2DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real xcenter "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real ycenter "y-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5... | # Schedule definitions for thorn WaveToy2DF77
# $Header$
STORAGE: evolve2d[3],coords2d
schedule WaveToy2DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy2DF77 banner"
schedule WaveToy2DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy2DF77 coordinates"
schedule WaveToy2DF77_Coord as Spat... | Startup.F77 | /*@@
@file Startup.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Register banner for WaveToy2DF77
@enddesc
@version $Header$
@@*/
#include "cctk.h"
integer function WaveToy2DF77_Startup()
implicit none
integer ierr
call CCTK_Register... | Evolve.F77
Initial.F77
Coord.F77
make.code.defn
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Evolution routines for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy2DF77_Evolve
@date July 2 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finit... |
CactusExamples/WaveToy2DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy2DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy2DF77
# $Header$
implements: wavetoy2d
inherits: boundary
private:
cctk_real evolve2d dim=2 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=2 type=GF
{
timederiv
} "For initial data"
cctk_real coords2d dim=2 type=GF
{
x,
y
} "The 2D x a... | # Parameter definitions for thorn WaveToy2DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real xcenter "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real ycenter "y-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5... | # Schedule definitions for thorn WaveToy2DF77
# $Header$
STORAGE: evolve2d[3],coords2d
schedule WaveToy2DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy2DF77 banner"
schedule WaveToy2DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy2DF77 coordinates"
schedule WaveToy2DF77_Coord as Spat... | Initial.F77 | /*@@
@file Initial.F77
@date June 13 2000
@author Gabrielle Allen
@desc
Initial data for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy2DF77_Initial
@date June ... | Evolve.F77
Startup.F77
Coord.F77
make.code.defn
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Evolution routines for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy2DF77_Evolve
@date July 2 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finit... |
CactusExamples/WaveToy2DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy2DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy2DF77
# $Header$
implements: wavetoy2d
inherits: boundary
private:
cctk_real evolve2d dim=2 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=2 type=GF
{
timederiv
} "For initial data"
cctk_real coords2d dim=2 type=GF
{
x,
y
} "The 2D x a... | # Parameter definitions for thorn WaveToy2DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real xcenter "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real ycenter "y-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5... | # Schedule definitions for thorn WaveToy2DF77
# $Header$
STORAGE: evolve2d[3],coords2d
schedule WaveToy2DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy2DF77 banner"
schedule WaveToy2DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy2DF77 coordinates"
schedule WaveToy2DF77_Coord as Spat... | Coord.F77 | /*@@
@file Coord.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Coordinates for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include "cctk_Functions.h"
/*@@
@routine WaveToy2DF77_Regi... | Evolve.F77
Startup.F77
Initial.F77
make.code.defn
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Evolution routines for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy2DF77_Evolve
@date July 2 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finit... |
CactusExamples/WaveToy2DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy2DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy2DF77
# $Header$
implements: wavetoy2d
inherits: boundary
private:
cctk_real evolve2d dim=2 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=2 type=GF
{
timederiv
} "For initial data"
cctk_real coords2d dim=2 type=GF
{
x,
y
} "The 2D x a... | # Parameter definitions for thorn WaveToy2DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real xcenter "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real ycenter "y-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5... | # Schedule definitions for thorn WaveToy2DF77
# $Header$
STORAGE: evolve2d[3],coords2d
schedule WaveToy2DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy2DF77 banner"
schedule WaveToy2DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy2DF77 coordinates"
schedule WaveToy2DF77_Coord as Spat... | make.code.defn | # Main make.code.defn file for thorn WaveToy2DF77
# $Header$
# Source files in this directory
SRCS = Evolve.F77\
Startup.F77\
Initial.F77\
Coord.F77\
Boundary.F77
# Subdirectories containing source files
SUBDIRS =
| Evolve.F77
Startup.F77
Initial.F77
Coord.F77
Boundary.F77
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Evolution routines for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy2DF77_Evolve
@date July 2 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finit... |
CactusExamples/WaveToy2DF77 | https://bitbucket.org/cactuscode/cactusexamples.git | # Configuration definition for thorn WaveToy2DF77
# $Header$
REQUIRES Boundary
| # Interface definition for thorn WaveToy2DF77
# $Header$
implements: wavetoy2d
inherits: boundary
private:
cctk_real evolve2d dim=2 type=GF Timelevels=3
{
phi
} "The evolved scalar field"
cctk_real initial dim=2 type=GF
{
timederiv
} "For initial data"
cctk_real coords2d dim=2 type=GF
{
x,
y
} "The 2D x a... | # Parameter definitions for thorn WaveToy2DF77
# $Header$
private:
# Initial data
real amplitude "Amplitude of initial Gaussian wave"
{
0:* :: ""
} 1.0
real xcenter "x-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5
real ycenter "y-position of center of Gaussian wave"
{
*:* :: "Anywhere"
} 0.5... | # Schedule definitions for thorn WaveToy2DF77
# $Header$
STORAGE: evolve2d[3],coords2d
schedule WaveToy2DF77_Startup at STARTUP
{
LANG: Fortran
} "Register WaveToy2DF77 banner"
schedule WaveToy2DF77_RegisterCoords at WRAGH
{
LANG: Fortran
} "Register WaveToy2DF77 coordinates"
schedule WaveToy2DF77_Coord as Spat... | Boundary.F77 | #include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Functions.h"
#include "cctk_Parameters.h"
subroutine WaveToy2DF77_Boundary(CCTK_ARGUMENTS)
implicit none
DECLARE_CCTK_ARGUMENTS
DECLARE_CCTK_PARAMETERS
DECLARE_CCTK_FUNCTIONS
integer ierr
integer sw(2)
CCTK_... | Evolve.F77
Startup.F77
Initial.F77
Coord.F77
make.code.defn
| Evolve.F77:
```
/*@@
@file Evolve.F77
@date July 2 2000
@author Gabrielle Allen
@desc
Evolution routines for the 2d wave equation solver
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
/*@@
@routine WaveToy2DF77_Evolve
@date July 2 2000
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finite differencing. Included... | README | ## README (README):
```
Cactus Code Thorn WaveToy2DF77
Author(s) : Gabrielle Allen
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn illustrates the solution of the scalar wave equation in 2D using
centered explicit finit... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | SymInterp.c | /* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely copied from the th... | Cartoon2D.h
interpolate.c
Cartoon2DBC.c
SetGrid.c
make.code.defn
CheckParameters.c
ApplyCartoon.c
Cartoon2D_tensors.h
RegisterSym.c
| Cartoon2D.h:
```
/* $Header$ */
#include "cctk.h"
/* Function prototypes */
#ifdef __cplusplus
extern "C" {
#endif
int BndCartoon2DVI(const cGH *GH, int tensortype, int prolongtype, int vi);
CCTK_INT
Cartoon2D_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
CCTK_INT const N... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | Cartoon2D.h | /* $Header$ */
#include "cctk.h"
/* Function prototypes */
#ifdef __cplusplus
extern "C" {
#endif
int BndCartoon2DVI(const cGH *GH, int tensortype, int prolongtype, int vi);
CCTK_INT
Cartoon2D_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
CCTK_INT const N_dims,
... | SymInterp.c
interpolate.c
Cartoon2DBC.c
SetGrid.c
make.code.defn
CheckParameters.c
ApplyCartoon.c
Cartoon2D_tensors.h
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | interpolate.c | /* interpolate.c -- interpolation functions */
/* $Header$ */
/*
* interpolate_local - ... (local)
* interpolate_local_order1 - ... (order 1) (linear) (2-point)
* interpolate_local_order2 - ... (order 2) (3-point)
* interpolate_local_order3 - ... (order 3) (4-point)
* interpolate_local_order4 - ... (order 4) (5-p... | SymInterp.c
Cartoon2D.h
Cartoon2DBC.c
SetGrid.c
make.code.defn
CheckParameters.c
ApplyCartoon.c
Cartoon2D_tensors.h
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | Cartoon2DBC.c | /*@@
@file Cartoon2DBC.c
@date Thu Nov 4 13:35:00 MET 1999
@author Sai Iyer
@desc
Apply Cartoon2D boundary conditions
An implementation of Steve Brandt's idea for doing
axisymmetry with 3d stencils.
Cactus 4 version of Bernd Bruegmann's ... | SymInterp.c
Cartoon2D.h
interpolate.c
SetGrid.c
make.code.defn
CheckParameters.c
ApplyCartoon.c
Cartoon2D_tensors.h
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | SetGrid.c | /*@@
@file SetGrid.c
@date April 2002
@author Denis Pollney
@desc
Reset the grid sizes before they are set by CartGrid3D, so
that they have sensible cartoon-compatible values.
@enddesc
@version $Id$
@@*/
#include <stdio.h>
#include <string.h>
#include "cct... | SymInterp.c
Cartoon2D.h
interpolate.c
Cartoon2DBC.c
make.code.defn
CheckParameters.c
ApplyCartoon.c
Cartoon2D_tensors.h
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | make.code.defn | # Main make.code.defn file for thorn Cartoon2D
# $Header$
# Source files in this directory
SRCS = ApplyCartoon.c CheckParameters.c Cartoon2DBC.c interpolate.c RegisterSym.c SymInterp.c SetGrid.c
# Subdirectories containing source files
SUBDIRS =
| SymInterp.c
Cartoon2D.h
interpolate.c
Cartoon2DBC.c
SetGrid.c
CheckParameters.c
ApplyCartoon.c
Cartoon2D_tensors.h
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | CheckParameters.c | /*@@
@file CheckParameters.c
@date Wed Nov 3 10:17:46 MET 1999
@author Sai Iyer
@desc
Check Cartoon2D parameters
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
static const char *rcsid = "$Id$";
CCTK_FILEVERSION(Development_Cart... | SymInterp.c
Cartoon2D.h
interpolate.c
Cartoon2DBC.c
SetGrid.c
make.code.defn
ApplyCartoon.c
Cartoon2D_tensors.h
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | ApplyCartoon.c | /*@@
@file ApplyCartoon.c
@date 6 Jan 2003
@author David Rideout
@desc
Applies the Cartoon boundary condition to all variables
selected for a bc.
@enddesc
@version $Header$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include "util_Table.h"
#inclu... | SymInterp.c
Cartoon2D.h
interpolate.c
Cartoon2DBC.c
SetGrid.c
make.code.defn
CheckParameters.c
Cartoon2D_tensors.h
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | Cartoon2D_tensors.h | /* Number of tensor types defined */
#define N_TENSORTYPES 3
/* Tensor types */
#define TENSORTYPE_SCALAR 0
#define TENSORTYPE_U 1
#define TENSORTYPE_DDSYM 2
/* Prolongation methods */
#define PROLONG_LAGRANGE 1
#define PROLONG_ENO 2
#define PROLONG_NONE 3
| SymInterp.c
Cartoon2D.h
interpolate.c
Cartoon2DBC.c
SetGrid.c
make.code.defn
CheckParameters.c
ApplyCartoon.c
RegisterSym.c
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Cartoon2D | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Cartoon2D
# $Header$
REQUIRES SpaceMask
| # Interface definition for thorn Cartoon2D
# $Header$
implements: cartoon2d
INCLUDES HEADER: Cartoon2D_tensors.h in Cartoon2D_tensors.h
INCLUDES HEADER: Cartoon2D.h in Cartoon2D.h
USES INCLUDE: SpaceMask.h
# Function aliases:
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRe... | # Parameter definitions for thorn Cartoon2D
# $Header$
private:
BOOLEAN cartoon_active "Activate cartoon boundary condition"
{
} "no"
BOOLEAN verbose "Verbose information"
{
} "no"
BOOLEAN stencil "Use custom 2D stencil if available"
{
} "yes"
INT order "Cartoon's interpolation order"
{
1:5 :: "From linear to fi... | # Schedule definitions for thorn Cartoon2D
# $Header$
if (cartoon_active)
{
STORAGE: excision_variables
schedule Cartoon2D_CheckTensorTypes at CCTK_PARAMCHECK
{
LANG: C
OPTIONS: meta
} "Check tensor type definitions for consistency"
schedule Cartoon2D_InitExcisionVars at CCTK_BASEGRID
{
LANG:... | RegisterSym.c | /*@@
@file RegisterSym.c
@date February 2004
@author Erik Schnetter
@desc
Register the symmetry boundary faces.
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include "Cartoon2D.h"
void Cartoon2D_RegisterSymmetries (CCTK_ARGUMEN... | SymInterp.c
Cartoon2D.h
interpolate.c
Cartoon2DBC.c
SetGrid.c
make.code.defn
CheckParameters.c
ApplyCartoon.c
Cartoon2D_tensors.h
| SymInterp.c:
```
/* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "Cartoon2D.h"
/*
* NOTE:
*
* The contents of this file have been largely c... | === documentation.tex ===
% /*@@
% @file documentation.tex
% @date 16 April 2002
% @author Denis Pollney
% @desc
% Cartoon2D user/maintainer guide.
% @enddesc
% @version $Header$
% @@*/
\documentclass{article}
% Use the Cactus ThornGuide style file
% (Automatically used ... | documentation.tex | Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" axisymmetric evolution a... | README | ## README (README):
```
Cactus Code Thorn Cartoon2D
Author(s) : Sai Iyer
Denis Pollney
Thomas Radke
David Rideout
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Implements a "cartoon" ... |
CactusNumerical/Dissipation | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Dissipation
# $Header$
REQUIRES THORNS: SphericalSurface
| # Interface definition for thorn Dissipation
# $Header$
IMPLEMENTS: Dissipation
INHERITS: grid SphericalSurface SpaceMask
CCTK_INT FUNCTION MoLQueryEvolvedRHS (CCTK_INT IN EvolvedIndex)
REQUIRES FUNCTION MoLQueryEvolvedRHS
CCTK_INT FUNCTION \
SymmetryTableHandleForGrid (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUN... | # Parameter definitions for thorn Dissipation
# $Header$
restricted:
BOOLEAN verbose "produce log output" STEERABLE=always
{
} "no"
INT order "Dissipation order" STEERABLE=always
{
1 :: "first order accurate dissipation (using a second derivative)"
3 :: "third order accurate dissipation (using a fourth derivativ... | # Schedule definitions for thorn Dissipation
# $Header$
STORAGE: epsdisA_group
SCHEDULE dissipation_paramcheck AT paramcheck
{
LANG: C
} "Check dissipation parameters for consistency"
SCHEDULE dissipation_basegrid AT basegrid
{
LANG: C
} "Ensure that there are enough ghost zones"
SCHEDULE setup_epsdis AT cctk_p... | paramcheck.c | /* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void
dissipation_paramcheck (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
int want_horizon;
if (extra_dissipation_in_horizons)
{
want_horizon = 0;
for (i=0; i<100; ++i)
... | basegrid.c
apply_dissipation.F77
make.code.defn
dissipation.c
setup_epsdis.c
| basegrid.c:
```
/* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void dissipation_basegrid (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int d;
if (cctk_dim != 3) {
CCTK_WARN (0, "This thorn supports only dim=3");
}
for (d=0; d<cctk_... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-Oliger dissipation to th... | README | ## README (README):
```
CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-... |
CactusNumerical/Dissipation | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Dissipation
# $Header$
REQUIRES THORNS: SphericalSurface
| # Interface definition for thorn Dissipation
# $Header$
IMPLEMENTS: Dissipation
INHERITS: grid SphericalSurface SpaceMask
CCTK_INT FUNCTION MoLQueryEvolvedRHS (CCTK_INT IN EvolvedIndex)
REQUIRES FUNCTION MoLQueryEvolvedRHS
CCTK_INT FUNCTION \
SymmetryTableHandleForGrid (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUN... | # Parameter definitions for thorn Dissipation
# $Header$
restricted:
BOOLEAN verbose "produce log output" STEERABLE=always
{
} "no"
INT order "Dissipation order" STEERABLE=always
{
1 :: "first order accurate dissipation (using a second derivative)"
3 :: "third order accurate dissipation (using a fourth derivativ... | # Schedule definitions for thorn Dissipation
# $Header$
STORAGE: epsdisA_group
SCHEDULE dissipation_paramcheck AT paramcheck
{
LANG: C
} "Check dissipation parameters for consistency"
SCHEDULE dissipation_basegrid AT basegrid
{
LANG: C
} "Ensure that there are enough ghost zones"
SCHEDULE setup_epsdis AT cctk_p... | basegrid.c | /* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void dissipation_basegrid (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int d;
if (cctk_dim != 3) {
CCTK_WARN (0, "This thorn supports only dim=3");
}
for (d=0; d<cctk_dim; ++d) {
... | paramcheck.c
apply_dissipation.F77
make.code.defn
dissipation.c
setup_epsdis.c
| paramcheck.c:
```
/* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void
dissipation_paramcheck (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
int want_horizon;
if (extra_dissipation_in_horizons)
{
want_horizon = 0;
for (i=0... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-Oliger dissipation to th... | README | ## README (README):
```
CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-... |
CactusNumerical/Dissipation | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Dissipation
# $Header$
REQUIRES THORNS: SphericalSurface
| # Interface definition for thorn Dissipation
# $Header$
IMPLEMENTS: Dissipation
INHERITS: grid SphericalSurface SpaceMask
CCTK_INT FUNCTION MoLQueryEvolvedRHS (CCTK_INT IN EvolvedIndex)
REQUIRES FUNCTION MoLQueryEvolvedRHS
CCTK_INT FUNCTION \
SymmetryTableHandleForGrid (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUN... | # Parameter definitions for thorn Dissipation
# $Header$
restricted:
BOOLEAN verbose "produce log output" STEERABLE=always
{
} "no"
INT order "Dissipation order" STEERABLE=always
{
1 :: "first order accurate dissipation (using a second derivative)"
3 :: "third order accurate dissipation (using a fourth derivativ... | # Schedule definitions for thorn Dissipation
# $Header$
STORAGE: epsdisA_group
SCHEDULE dissipation_paramcheck AT paramcheck
{
LANG: C
} "Check dissipation parameters for consistency"
SCHEDULE dissipation_basegrid AT basegrid
{
LANG: C
} "Ensure that there are enough ghost zones"
SCHEDULE setup_epsdis AT cctk_p... | apply_dissipation.F77 | c $Header$
#include "cctk.h"
subroutine apply_dissipation (var, rhs, ni, nj, nk, dx, order, epsdis)
implicit none
integer ni, nj, nk
CCTK_REAL var(ni,nj,nk), rhs(ni,nj,nk)
CCTK_REAL dx(3), idx(3)
CCTK_INT order
CCTK_REAL epsdis(ni,nj,nk)
integer i... | paramcheck.c
basegrid.c
make.code.defn
dissipation.c
setup_epsdis.c
| paramcheck.c:
```
/* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void
dissipation_paramcheck (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
int want_horizon;
if (extra_dissipation_in_horizons)
{
want_horizon = 0;
for (i=0... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-Oliger dissipation to th... | README | ## README (README):
```
CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-... |
CactusNumerical/Dissipation | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Dissipation
# $Header$
REQUIRES THORNS: SphericalSurface
| # Interface definition for thorn Dissipation
# $Header$
IMPLEMENTS: Dissipation
INHERITS: grid SphericalSurface SpaceMask
CCTK_INT FUNCTION MoLQueryEvolvedRHS (CCTK_INT IN EvolvedIndex)
REQUIRES FUNCTION MoLQueryEvolvedRHS
CCTK_INT FUNCTION \
SymmetryTableHandleForGrid (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUN... | # Parameter definitions for thorn Dissipation
# $Header$
restricted:
BOOLEAN verbose "produce log output" STEERABLE=always
{
} "no"
INT order "Dissipation order" STEERABLE=always
{
1 :: "first order accurate dissipation (using a second derivative)"
3 :: "third order accurate dissipation (using a fourth derivativ... | # Schedule definitions for thorn Dissipation
# $Header$
STORAGE: epsdisA_group
SCHEDULE dissipation_paramcheck AT paramcheck
{
LANG: C
} "Check dissipation parameters for consistency"
SCHEDULE dissipation_basegrid AT basegrid
{
LANG: C
} "Ensure that there are enough ghost zones"
SCHEDULE setup_epsdis AT cctk_p... | make.code.defn | # Main make.code.defn file for thorn Dissipation
# $Header$
# Source files in this directory
SRCS = apply_dissipation.F77 basegrid.c dissipation.c paramcheck.c setup_epsdis.c
# Subdirectories containing source files
SUBDIRS =
| paramcheck.c
basegrid.c
apply_dissipation.F77
dissipation.c
setup_epsdis.c
| paramcheck.c:
```
/* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void
dissipation_paramcheck (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
int want_horizon;
if (extra_dissipation_in_horizons)
{
want_horizon = 0;
for (i=0... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-Oliger dissipation to th... | README | ## README (README):
```
CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-... |
CactusNumerical/Dissipation | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Dissipation
# $Header$
REQUIRES THORNS: SphericalSurface
| # Interface definition for thorn Dissipation
# $Header$
IMPLEMENTS: Dissipation
INHERITS: grid SphericalSurface SpaceMask
CCTK_INT FUNCTION MoLQueryEvolvedRHS (CCTK_INT IN EvolvedIndex)
REQUIRES FUNCTION MoLQueryEvolvedRHS
CCTK_INT FUNCTION \
SymmetryTableHandleForGrid (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUN... | # Parameter definitions for thorn Dissipation
# $Header$
restricted:
BOOLEAN verbose "produce log output" STEERABLE=always
{
} "no"
INT order "Dissipation order" STEERABLE=always
{
1 :: "first order accurate dissipation (using a second derivative)"
3 :: "third order accurate dissipation (using a fourth derivativ... | # Schedule definitions for thorn Dissipation
# $Header$
STORAGE: epsdisA_group
SCHEDULE dissipation_paramcheck AT paramcheck
{
LANG: C
} "Check dissipation parameters for consistency"
SCHEDULE dissipation_basegrid AT basegrid
{
LANG: C
} "Ensure that there are enough ghost zones"
SCHEDULE setup_epsdis AT cctk_p... | dissipation.c | /* $Header$ */
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void CCTK_FCALL
CCTK_FNAME(apply_dissipation) (CCTK_REAL const * const var,
CCTK_REAL * const rhs,
i... | paramcheck.c
basegrid.c
apply_dissipation.F77
make.code.defn
setup_epsdis.c
| paramcheck.c:
```
/* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void
dissipation_paramcheck (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
int want_horizon;
if (extra_dissipation_in_horizons)
{
want_horizon = 0;
for (i=0... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-Oliger dissipation to th... | README | ## README (README):
```
CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-... |
CactusNumerical/Dissipation | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Dissipation
# $Header$
REQUIRES THORNS: SphericalSurface
| # Interface definition for thorn Dissipation
# $Header$
IMPLEMENTS: Dissipation
INHERITS: grid SphericalSurface SpaceMask
CCTK_INT FUNCTION MoLQueryEvolvedRHS (CCTK_INT IN EvolvedIndex)
REQUIRES FUNCTION MoLQueryEvolvedRHS
CCTK_INT FUNCTION \
SymmetryTableHandleForGrid (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUN... | # Parameter definitions for thorn Dissipation
# $Header$
restricted:
BOOLEAN verbose "produce log output" STEERABLE=always
{
} "no"
INT order "Dissipation order" STEERABLE=always
{
1 :: "first order accurate dissipation (using a second derivative)"
3 :: "third order accurate dissipation (using a fourth derivativ... | # Schedule definitions for thorn Dissipation
# $Header$
STORAGE: epsdisA_group
SCHEDULE dissipation_paramcheck AT paramcheck
{
LANG: C
} "Check dissipation parameters for consistency"
SCHEDULE dissipation_basegrid AT basegrid
{
LANG: C
} "Ensure that there are enough ghost zones"
SCHEDULE setup_epsdis AT cctk_p... | setup_epsdis.c | /* $Header$ */
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include "cctk_Functions.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#define MAXDIM 3
#define REFLEVEL (ilogb(cctk_levfac[0]))
void
setu... | paramcheck.c
basegrid.c
apply_dissipation.F77
make.code.defn
dissipation.c
| paramcheck.c:
```
/* $Header$ */
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
void
dissipation_paramcheck (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
int want_horizon;
if (extra_dissipation_in_horizons)
{
want_horizon = 0;
for (i=0... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-Oliger dissipation to th... | README | ## README (README):
```
CVS info : $Header$
Cactus Code Thorn Dissipation
Thorn Author(s) : Erik Schnetter <schnetter@aei.mpg.de>
Thorn Maintainer(s) : Erik Schnetter <schnetter@aei.mpg.de>
--------------------------------------------------------------------------
Purpose of the thorn:
Add fourth order Kreiss-... |
CactusNumerical/InterpToArray | https://bitbucket.org/cactuscode/cactusnumerical.git | # Interface definition for thorn InterpToArray
IMPLEMENTS: InterpToArray
CCTK_INT FUNCTION \
InterpGridArrays \
(CCTK_POINTER_TO_CONST IN cctkGH, \
CCTK_INT IN N_dims, \
CCTK_INT... | # Parameter definitions for thorn InterpToArray
RESTRICTED:
# CCTK_InterpGridArrays parameters
STRING interpolator_name "Name of the interpolator" STEERABLE=always
{
".*" :: "must be a registered interpolator"
} "Lagrange polynomial interpolation"
STRING interpolator_options "Options for the interpolator" STEERAB... | # Schedule definitions for thorn InterpToArray
SCHEDULE InterpToArray AT analysis
{
LANG: C
OPTIONS: global
STORAGE: scalars arrays1d arrays2d arrays3d parrays1d parrays2d parrays3d
TRIGGERS: scalars arrays1d arrays2d arrays3d parrays1d parrays2d parrays3d
} "Interpolate to grid arrays"
| interp.c | #include <assert.h>
#include <stdlib.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include "util_Table.h"
void
InterpToArray (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int interpolator = -1;
if (!use_carpetinterp2) {
interpolator = CCTK... | make.code.defn
| make.code.defn:
```
# Main make.code.defn file for thorn InterpToArray
# Source files in this directory
SRCS = interp.c
# Subdirectories containing source files
SUBDIRS =
```
| === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn InterpToArray
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
Interpolate grid functions to grid arrays on a regular grid of
loca... | README | ## README (README):
```
Cactus Code Thorn InterpToArray
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
Interpolate grid functions to grid arrays o... | |
CactusNumerical/InterpToArray | https://bitbucket.org/cactuscode/cactusnumerical.git | # Interface definition for thorn InterpToArray
IMPLEMENTS: InterpToArray
CCTK_INT FUNCTION \
InterpGridArrays \
(CCTK_POINTER_TO_CONST IN cctkGH, \
CCTK_INT IN N_dims, \
CCTK_INT... | # Parameter definitions for thorn InterpToArray
RESTRICTED:
# CCTK_InterpGridArrays parameters
STRING interpolator_name "Name of the interpolator" STEERABLE=always
{
".*" :: "must be a registered interpolator"
} "Lagrange polynomial interpolation"
STRING interpolator_options "Options for the interpolator" STEERAB... | # Schedule definitions for thorn InterpToArray
SCHEDULE InterpToArray AT analysis
{
LANG: C
OPTIONS: global
STORAGE: scalars arrays1d arrays2d arrays3d parrays1d parrays2d parrays3d
TRIGGERS: scalars arrays1d arrays2d arrays3d parrays1d parrays2d parrays3d
} "Interpolate to grid arrays"
| make.code.defn | # Main make.code.defn file for thorn InterpToArray
# Source files in this directory
SRCS = interp.c
# Subdirectories containing source files
SUBDIRS =
| interp.c
| interp.c:
```
#include <assert.h>
#include <stdlib.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include "util_Table.h"
void
InterpToArray (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int interpolator = -1;
if (!use_carpetinterp2) {
inter... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn InterpToArray
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
Interpolate grid functions to grid arrays on a regular grid of
loca... | README | ## README (README):
```
Cactus Code Thorn InterpToArray
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
Interpolate grid functions to grid arrays o... | |
CactusNumerical/RotatingSymmetry180 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry180
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry180
IMPLEMENTS: RotatingSymmetry180
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry180
BOOLEAN verbose "Produce screen output while applying boundary conditions" STEERABLE=always
{
} "no"
KEYWORD hyperslabber "Hyperslabbing mechanism" STEERABLE=always
{
"TAT/Slab" :: ""
"GetHyperslab" :: ""
} "TAT/Slab"
BOOLEAN use_coordbase "Get symmet... | # Schedule definitions for thorn RotatingSymmetry180
SCHEDULE Rot180_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot180_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot180_ComputeLevelExtent IN BoundaryConditions ... | interpolate.c | #include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry180.h"
void
Rot180_CheckTensorTypes (CCTK_ARGUMENTS)
{
int gi;
/* Check tensor types of all groups */
for (gi=0;... | rotatingsymmetry180.c
make.code.defn
registersymmetry.c
rotatingsymmetry180.h
| rotatingsymmetry180.c:
```
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <util_ErrorCodes.h>
#include <util_Table.h>
#include <Slab.h>
#include "rotatingsymmetry180.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
/* bbox, lbnd and ubnd of combi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry boundary condition. This ... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry bo... |
CactusNumerical/RotatingSymmetry180 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry180
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry180
IMPLEMENTS: RotatingSymmetry180
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry180
BOOLEAN verbose "Produce screen output while applying boundary conditions" STEERABLE=always
{
} "no"
KEYWORD hyperslabber "Hyperslabbing mechanism" STEERABLE=always
{
"TAT/Slab" :: ""
"GetHyperslab" :: ""
} "TAT/Slab"
BOOLEAN use_coordbase "Get symmet... | # Schedule definitions for thorn RotatingSymmetry180
SCHEDULE Rot180_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot180_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot180_ComputeLevelExtent IN BoundaryConditions ... | rotatingsymmetry180.c | #include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <util_ErrorCodes.h>
#include <util_Table.h>
#include <Slab.h>
#include "rotatingsymmetry180.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
/* bbox, lbnd and ubnd of combined level box */
static int... | interpolate.c
make.code.defn
registersymmetry.c
rotatingsymmetry180.h
| interpolate.c:
```
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry180.h"
void
Rot180_CheckTensorTypes (CCTK_ARGUMENTS)
{
int gi;
/* Check tensor types of all gro... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry boundary condition. This ... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry bo... |
CactusNumerical/RotatingSymmetry180 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry180
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry180
IMPLEMENTS: RotatingSymmetry180
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry180
BOOLEAN verbose "Produce screen output while applying boundary conditions" STEERABLE=always
{
} "no"
KEYWORD hyperslabber "Hyperslabbing mechanism" STEERABLE=always
{
"TAT/Slab" :: ""
"GetHyperslab" :: ""
} "TAT/Slab"
BOOLEAN use_coordbase "Get symmet... | # Schedule definitions for thorn RotatingSymmetry180
SCHEDULE Rot180_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot180_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot180_ComputeLevelExtent IN BoundaryConditions ... | make.code.defn | # Main make.code.defn file for thorn RotatingSymmetry180
# Source files in this directory
SRCS = interpolate.c rotatingsymmetry180.c registersymmetry.c
# Subdirectories containing source files
SUBDIRS =
| interpolate.c
rotatingsymmetry180.c
registersymmetry.c
rotatingsymmetry180.h
| interpolate.c:
```
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry180.h"
void
Rot180_CheckTensorTypes (CCTK_ARGUMENTS)
{
int gi;
/* Check tensor types of all gro... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry boundary condition. This ... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry bo... |
CactusNumerical/RotatingSymmetry180 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry180
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry180
IMPLEMENTS: RotatingSymmetry180
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry180
BOOLEAN verbose "Produce screen output while applying boundary conditions" STEERABLE=always
{
} "no"
KEYWORD hyperslabber "Hyperslabbing mechanism" STEERABLE=always
{
"TAT/Slab" :: ""
"GetHyperslab" :: ""
} "TAT/Slab"
BOOLEAN use_coordbase "Get symmet... | # Schedule definitions for thorn RotatingSymmetry180
SCHEDULE Rot180_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot180_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot180_ComputeLevelExtent IN BoundaryConditions ... | registersymmetry.c | #include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include "rotatingsymmetry180.h"
void Rot180_RegisterSymmetry (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
CCTK_INT nboundaryzones[6];
CCTK_INT is_internal[6];
CCTK_INT is_staggered[6];
CCTK_INT shiftout... | interpolate.c
rotatingsymmetry180.c
make.code.defn
rotatingsymmetry180.h
| interpolate.c:
```
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry180.h"
void
Rot180_CheckTensorTypes (CCTK_ARGUMENTS)
{
int gi;
/* Check tensor types of all gro... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry boundary condition. This ... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry bo... |
CactusNumerical/RotatingSymmetry180 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry180
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry180
IMPLEMENTS: RotatingSymmetry180
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry180
BOOLEAN verbose "Produce screen output while applying boundary conditions" STEERABLE=always
{
} "no"
KEYWORD hyperslabber "Hyperslabbing mechanism" STEERABLE=always
{
"TAT/Slab" :: ""
"GetHyperslab" :: ""
} "TAT/Slab"
BOOLEAN use_coordbase "Get symmet... | # Schedule definitions for thorn RotatingSymmetry180
SCHEDULE Rot180_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot180_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot180_ComputeLevelExtent IN BoundaryConditions ... | rotatingsymmetry180.h | #ifndef ROTATINGSYMMETRY180_H
#define ROTATINGSYMMETRY180_H
#include "cctk.h"
#include "cctk_Arguments.h"
void Rot180_RegisterSymmetry (CCTK_ARGUMENTS);
int BndRot180VI (cGH const * restrict const cctkGH,
int const nvars,
CCTK_INT const * restrict const vis);
void Rot180_ApplyBC (C... | interpolate.c
rotatingsymmetry180.c
make.code.defn
registersymmetry.c
| interpolate.c:
```
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry180.h"
void
Rot180_CheckTensorTypes (CCTK_ARGUMENTS)
{
int gi;
/* Check tensor types of all gro... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry boundary condition. This ... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry180
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 180 degree rotational symmetry bo... |
CactusNumerical/RotatingSymmetry90 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry90
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry90
IMPLEMENTS: RotatingSymmetry90
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry90
BOOLEAN verbose "Produce screen output while applying boundary conditions"
{
} "no"
BOOLEAN poison_boundaries "Fill the symmetry boundary with a poison value before the symmetry is applied" STEERABLE=always
{
} "no"
CCTK_INT poison_value "Integer value (0..255) ... | # Schedule definitions for thorn RotatingSymmetry90
SCHEDULE Rot90_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot90_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot90_ComputeLevelExtent IN BoundaryConditions BEFO... | interpolate.c | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry90.h"
/* This is pretty hard coded into all the tensor types and cannot be
changed easily. */
#define DIM 3 /* spatial dimension */
... | rotatingsymmetry90.h
make.code.defn
registersymmetry.c
rotatingsymmetry90.c
| rotatingsymmetry90.h:
```
#ifndef ROTATINGSYMMETRY90_H
#define ROTATINGSYMMETRY90_H
#include "cctk.h"
#include "cctk_Arguments.h"
void Rot90_RegisterSymmetry (CCTK_ARGUMENTS);
int BndRot90VI (cGH const * restrict const cctkGH,
int const nvars,
CCTK_INT const * restrict const vis);
vo... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boundary condition. This is... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boun... |
CactusNumerical/RotatingSymmetry90 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry90
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry90
IMPLEMENTS: RotatingSymmetry90
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry90
BOOLEAN verbose "Produce screen output while applying boundary conditions"
{
} "no"
BOOLEAN poison_boundaries "Fill the symmetry boundary with a poison value before the symmetry is applied" STEERABLE=always
{
} "no"
CCTK_INT poison_value "Integer value (0..255) ... | # Schedule definitions for thorn RotatingSymmetry90
SCHEDULE Rot90_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot90_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot90_ComputeLevelExtent IN BoundaryConditions BEFO... | rotatingsymmetry90.h | #ifndef ROTATINGSYMMETRY90_H
#define ROTATINGSYMMETRY90_H
#include "cctk.h"
#include "cctk_Arguments.h"
void Rot90_RegisterSymmetry (CCTK_ARGUMENTS);
int BndRot90VI (cGH const * restrict const cctkGH,
int const nvars,
CCTK_INT const * restrict const vis);
void Rot90_ApplyBC (CCTK_ARG... | interpolate.c
make.code.defn
registersymmetry.c
rotatingsymmetry90.c
| interpolate.c:
```
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry90.h"
/* This is pretty hard coded into all the tensor types and cannot be
changed easily. */
#define DIM 3 /* spati... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boundary condition. This is... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boun... |
CactusNumerical/RotatingSymmetry90 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry90
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry90
IMPLEMENTS: RotatingSymmetry90
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry90
BOOLEAN verbose "Produce screen output while applying boundary conditions"
{
} "no"
BOOLEAN poison_boundaries "Fill the symmetry boundary with a poison value before the symmetry is applied" STEERABLE=always
{
} "no"
CCTK_INT poison_value "Integer value (0..255) ... | # Schedule definitions for thorn RotatingSymmetry90
SCHEDULE Rot90_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot90_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot90_ComputeLevelExtent IN BoundaryConditions BEFO... | make.code.defn | # Main make.code.defn file for thorn RotatingSymmetry90
# Source files in this directory
SRCS = interpolate.c rotatingsymmetry90.c registersymmetry.c
# Subdirectories containing source files
SUBDIRS =
| interpolate.c
rotatingsymmetry90.h
registersymmetry.c
rotatingsymmetry90.c
| interpolate.c:
```
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry90.h"
/* This is pretty hard coded into all the tensor types and cannot be
changed easily. */
#define DIM 3 /* spati... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boundary condition. This is... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boun... |
CactusNumerical/RotatingSymmetry90 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry90
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry90
IMPLEMENTS: RotatingSymmetry90
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry90
BOOLEAN verbose "Produce screen output while applying boundary conditions"
{
} "no"
BOOLEAN poison_boundaries "Fill the symmetry boundary with a poison value before the symmetry is applied" STEERABLE=always
{
} "no"
CCTK_INT poison_value "Integer value (0..255) ... | # Schedule definitions for thorn RotatingSymmetry90
SCHEDULE Rot90_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot90_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot90_ComputeLevelExtent IN BoundaryConditions BEFO... | registersymmetry.c | #include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include "rotatingsymmetry90.h"
void Rot90_RegisterSymmetry (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
CCTK_INT nboundaryzones[6];
CCTK_INT is_internal[6];
CCTK_INT is_staggered[6];
CCTK_INT shiftout[6]... | interpolate.c
rotatingsymmetry90.h
make.code.defn
rotatingsymmetry90.c
| interpolate.c:
```
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry90.h"
/* This is pretty hard coded into all the tensor types and cannot be
changed easily. */
#define DIM 3 /* spati... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boundary condition. This is... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boun... |
CactusNumerical/RotatingSymmetry90 | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn RotatingSymmetry90
REQUIRES THORNS: Slab
| # Interface definition for thorn RotatingSymmetry90
IMPLEMENTS: RotatingSymmetry90
USES INCLUDE HEADER: Slab.h
CCTK_INT FUNCTION SymmetryRegister (CCTK_STRING IN sym_name)
REQUIRES FUNCTION SymmetryRegister
# which_faces : array [N_FACES]
# symmetry_zone_width: array [N_FACES]
CCTK_INT FUNCTION ... | # Parameter definitions for thorn RotatingSymmetry90
BOOLEAN verbose "Produce screen output while applying boundary conditions"
{
} "no"
BOOLEAN poison_boundaries "Fill the symmetry boundary with a poison value before the symmetry is applied" STEERABLE=always
{
} "no"
CCTK_INT poison_value "Integer value (0..255) ... | # Schedule definitions for thorn RotatingSymmetry90
SCHEDULE Rot90_CheckTensorTypes AT paramcheck
{
LANG: C
} "Check tensor type definitions for consistency"
SCHEDULE Rot90_RegisterSymmetry IN SymmetryRegister
{
LANG: C
} "Register symmetry boundaries"
SCHEDULE Rot90_ComputeLevelExtent IN BoundaryConditions BEFO... | rotatingsymmetry90.c | #include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <util_ErrorCodes.h>
#include <util_Table.h>
#include <Slab.h>
#include "rotatingsymmetry90.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
/* This is pretty hard coded into all the tensor types an... | interpolate.c
rotatingsymmetry90.h
make.code.defn
registersymmetry.c
| interpolate.c:
```
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "util_ErrorCodes.h"
#include "util_Table.h"
#include "rotatingsymmetry90.h"
/* This is pretty hard coded into all the tensor types and cannot be
changed easily. */
#define DIM 3 /* spati... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Ca... | documentation.tex | Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boundary condition. This is... | README | ## README (README):
```
Cactus Code Thorn RotatingSymmetry90
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : GPL
--------------------------------------------------------------------------
1. Purpose
Provide a 90 degree rotational symmetry boun... |
CactusNumerical/Slab | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Slab
PROVIDES Slab
{
}
OPTIONAL LoopControl MPI
{
}
| # Interface definition for thorn Slab
IMPLEMENTS: Slab
INCLUDES HEADER: slab.h IN Slab.h
INCLUDES HEADER: slab.inc IN Slab.inc
USES INCLUDE HEADER: loopcontrol.h
CCTK_POINTER_TO_CONST \
FUNCTION GetMPICommWorld (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUNCTION GetMPICommWorld
| # Parameter definitions for thorn Slab
BOOLEAN timer_output "Print slabbing timings at shutdown time" STEERABLE=always
{
} "no"
BOOLEAN use_alltoallv "Use MPI_Alltoallv for communication?" STEERABLE=always
{
} "no"
| # Schedule definitions for thorn Slab
SCHEDULE Slab_InitMPIDatatypes AT startup after Driver_Startup
{
LANG: C
} "Create MPI datatypes for complex variables in C"
SCHEDULE Slab_InitTimers AT wragh
{
LANG: C
} "Initialise timers"
if (timer_output) {
SCHEDULE Slab_PrintTimers AT shutdown
{
LANG: C
} "Pri... | slab.cc | // TODO:
// Provide facilities for dim > 3
// Set up the slab exchange information in advance
// Slab in several stages
// Test slabbing without MPI
// Allow not setting the ghost zones
// Allow not using / not setting the boundaries
// Allow different numbers of ghost zones at the lower and upper boundary
// Print ... | slab.h
make.code.defn
slab.inc
| slab.h:
```
#ifndef SLAB_H
#define SLAB_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdio.h>
#include <cctk.h>
/*
* Slab_Transfer copies a slab from one array into a slab of another
* array.
*
* The src and dst variables describe the source and the destination
* slab, respectively.
*
* The variabl... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the C... | documentation.tex | Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfer slabs of arrays
betwee... | README | ## README (README):
```
Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfe... |
CactusNumerical/Slab | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Slab
PROVIDES Slab
{
}
OPTIONAL LoopControl MPI
{
}
| # Interface definition for thorn Slab
IMPLEMENTS: Slab
INCLUDES HEADER: slab.h IN Slab.h
INCLUDES HEADER: slab.inc IN Slab.inc
USES INCLUDE HEADER: loopcontrol.h
CCTK_POINTER_TO_CONST \
FUNCTION GetMPICommWorld (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUNCTION GetMPICommWorld
| # Parameter definitions for thorn Slab
BOOLEAN timer_output "Print slabbing timings at shutdown time" STEERABLE=always
{
} "no"
BOOLEAN use_alltoallv "Use MPI_Alltoallv for communication?" STEERABLE=always
{
} "no"
| # Schedule definitions for thorn Slab
SCHEDULE Slab_InitMPIDatatypes AT startup after Driver_Startup
{
LANG: C
} "Create MPI datatypes for complex variables in C"
SCHEDULE Slab_InitTimers AT wragh
{
LANG: C
} "Initialise timers"
if (timer_output) {
SCHEDULE Slab_PrintTimers AT shutdown
{
LANG: C
} "Pri... | slab.h | #ifndef SLAB_H
#define SLAB_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdio.h>
#include <cctk.h>
/*
* Slab_Transfer copies a slab from one array into a slab of another
* array.
*
* The src and dst variables describe the source and the destination
* slab, respectively.
*
* The variables gsh, lbnd... | slab.cc
make.code.defn
slab.inc
| slab.cc:
```
// TODO:
// Provide facilities for dim > 3
// Set up the slab exchange information in advance
// Slab in several stages
// Test slabbing without MPI
// Allow not setting the ghost zones
// Allow not using / not setting the boundaries
// Allow different numbers of ghost zones at the lower and upper boundary... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the C... | documentation.tex | Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfer slabs of arrays
betwee... | README | ## README (README):
```
Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfe... |
CactusNumerical/Slab | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Slab
PROVIDES Slab
{
}
OPTIONAL LoopControl MPI
{
}
| # Interface definition for thorn Slab
IMPLEMENTS: Slab
INCLUDES HEADER: slab.h IN Slab.h
INCLUDES HEADER: slab.inc IN Slab.inc
USES INCLUDE HEADER: loopcontrol.h
CCTK_POINTER_TO_CONST \
FUNCTION GetMPICommWorld (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUNCTION GetMPICommWorld
| # Parameter definitions for thorn Slab
BOOLEAN timer_output "Print slabbing timings at shutdown time" STEERABLE=always
{
} "no"
BOOLEAN use_alltoallv "Use MPI_Alltoallv for communication?" STEERABLE=always
{
} "no"
| # Schedule definitions for thorn Slab
SCHEDULE Slab_InitMPIDatatypes AT startup after Driver_Startup
{
LANG: C
} "Create MPI datatypes for complex variables in C"
SCHEDULE Slab_InitTimers AT wragh
{
LANG: C
} "Initialise timers"
if (timer_output) {
SCHEDULE Slab_PrintTimers AT shutdown
{
LANG: C
} "Pri... | make.code.defn | # Main make.code.defn file for thorn Slab
# Source files in this directory
SRCS = slab.cc
# Subdirectories containing source files
SUBDIRS =
| slab.cc
slab.h
slab.inc
| slab.cc:
```
// TODO:
// Provide facilities for dim > 3
// Set up the slab exchange information in advance
// Slab in several stages
// Test slabbing without MPI
// Allow not setting the ghost zones
// Allow not using / not setting the boundaries
// Allow different numbers of ghost zones at the lower and upper boundary... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the C... | documentation.tex | Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfer slabs of arrays
betwee... | README | ## README (README):
```
Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfe... |
CactusNumerical/Slab | https://bitbucket.org/cactuscode/cactusnumerical.git | # Configuration definition for thorn Slab
PROVIDES Slab
{
}
OPTIONAL LoopControl MPI
{
}
| # Interface definition for thorn Slab
IMPLEMENTS: Slab
INCLUDES HEADER: slab.h IN Slab.h
INCLUDES HEADER: slab.inc IN Slab.inc
USES INCLUDE HEADER: loopcontrol.h
CCTK_POINTER_TO_CONST \
FUNCTION GetMPICommWorld (CCTK_POINTER_TO_CONST IN cctkGH)
USES FUNCTION GetMPICommWorld
| # Parameter definitions for thorn Slab
BOOLEAN timer_output "Print slabbing timings at shutdown time" STEERABLE=always
{
} "no"
BOOLEAN use_alltoallv "Use MPI_Alltoallv for communication?" STEERABLE=always
{
} "no"
| # Schedule definitions for thorn Slab
SCHEDULE Slab_InitMPIDatatypes AT startup after Driver_Startup
{
LANG: C
} "Create MPI datatypes for complex variables in C"
SCHEDULE Slab_InitTimers AT wragh
{
LANG: C
} "Initialise timers"
if (timer_output) {
SCHEDULE Slab_PrintTimers AT shutdown
{
LANG: C
} "Pri... | slab.inc | ! -*-F90-*-
interface
subroutine Slab_Transfer (ierr, cctkGH, dim, &
src_gsh, src_lbnd, src_lsh, src_ash, &
src_lbbox, src_ubbox, src_nghostzones, &
src_off, src_str, src_len, &
dst_gsh, dst_lbnd, dst_lsh, dst_ash, &
dst_lbbox, dst_ubbox, dst_nghostzones, &
dst_off, d... | slab.cc
slab.h
make.code.defn
| slab.cc:
```
// TODO:
// Provide facilities for dim > 3
// Set up the slab exchange information in advance
// Slab in several stages
// Test slabbing without MPI
// Allow not setting the ghost zones
// Allow not using / not setting the boundaries
// Allow different numbers of ghost zones at the lower and upper boundary... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the C... | documentation.tex | Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfer slabs of arrays
betwee... | README | ## README (README):
```
Cactus Code Thorn Slab
Thorn Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Thorn Maintainer(s) : Erik Schnetter <schnetter@cct.lsu.edu>
--------------------------------------------------------------------------
Purpose of the thorn:
This thorn provides routines that use MPI to transfe... |
CactusNumerical/TestLocalReduce | https://bitbucket.org/cactuscode/cactusnumerical.git | # Interface definition for thorn TestLocalReduce
# $Header$
implements: TestLocalReduce
public:
real real_vals type=scalar
{
real_max_3D
real_max_2D
real_max_1D
real_sum_3D
real_sum_2D
real_sum_1D
real_avg_3D
real_avg_2D
real_avg_1D
} "results from real reduction"
int int_vals type=scalar
{
... | # Parameter definitions for thorn TestLocalReduce
# $Header$
INT array_nx "Size of arrays in x direction"
{
0:* :: ""
} 4
INT array_ny "Size of arrays in y direction"
{
0:* :: ""
} 5
INT array_nz "Size of arrays in z direction"
{
0:* :: ""
} 10
| # Schedule definitions for thorn TestLocalReduce
# $Header$
STORAGE: real_vals int_vals
schedule TestLocalReduceC_Maximum at CCTK_POSTINITIAL
{
LANG: C
} "Test out maximum reductions from C"
schedule TestLocalReduceC_Sum at CCTK_POSTINITIAL
{
LANG: C
} "Test out sum reductions from C"
schedule TestLocalReduceC... | Reduce_Maximum.c | /*@@
@file Reduce_Maximum.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Test the new local maximum reduction implementation
@enddesc
@version $Id$
@@*/
#include <stdlib.h>
#include "cctk.h"
#include "util_Table.h"
#include "cctk_Arguments.h"
#inclu... | Reduce_Avg.c
make.code.defn
Reduce_Sum.c
| Reduce_Avg.c:
```
/*@@
@file Reduce_Avg.c
@date Tue Aug 31 12:48:07 2004
@author Yaakoub Y El-Khamra
@desc
Test the local reduction interface and operators.
@enddesc
@version $Header$
@@*/
#include <stdlib.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.t... | |
CactusNumerical/TestLocalReduce | https://bitbucket.org/cactuscode/cactusnumerical.git | # Interface definition for thorn TestLocalReduce
# $Header$
implements: TestLocalReduce
public:
real real_vals type=scalar
{
real_max_3D
real_max_2D
real_max_1D
real_sum_3D
real_sum_2D
real_sum_1D
real_avg_3D
real_avg_2D
real_avg_1D
} "results from real reduction"
int int_vals type=scalar
{
... | # Parameter definitions for thorn TestLocalReduce
# $Header$
INT array_nx "Size of arrays in x direction"
{
0:* :: ""
} 4
INT array_ny "Size of arrays in y direction"
{
0:* :: ""
} 5
INT array_nz "Size of arrays in z direction"
{
0:* :: ""
} 10
| # Schedule definitions for thorn TestLocalReduce
# $Header$
STORAGE: real_vals int_vals
schedule TestLocalReduceC_Maximum at CCTK_POSTINITIAL
{
LANG: C
} "Test out maximum reductions from C"
schedule TestLocalReduceC_Sum at CCTK_POSTINITIAL
{
LANG: C
} "Test out sum reductions from C"
schedule TestLocalReduceC... | Reduce_Avg.c | /*@@
@file Reduce_Avg.c
@date Tue Aug 31 12:48:07 2004
@author Yaakoub Y El-Khamra
@desc
Test the local reduction interface and operators.
@enddesc
@version $Header$
@@*/
#include <stdlib.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const ... | Reduce_Maximum.c
make.code.defn
Reduce_Sum.c
| Reduce_Maximum.c:
```
/*@@
@file Reduce_Maximum.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Test the new local maximum reduction implementation
@enddesc
@version $Id$
@@*/
#include <stdlib.h>
#include "cctk.h"
#include "util_Table.h"
#include "cc... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.t... | |
CactusNumerical/TestLocalReduce | https://bitbucket.org/cactuscode/cactusnumerical.git | # Interface definition for thorn TestLocalReduce
# $Header$
implements: TestLocalReduce
public:
real real_vals type=scalar
{
real_max_3D
real_max_2D
real_max_1D
real_sum_3D
real_sum_2D
real_sum_1D
real_avg_3D
real_avg_2D
real_avg_1D
} "results from real reduction"
int int_vals type=scalar
{
... | # Parameter definitions for thorn TestLocalReduce
# $Header$
INT array_nx "Size of arrays in x direction"
{
0:* :: ""
} 4
INT array_ny "Size of arrays in y direction"
{
0:* :: ""
} 5
INT array_nz "Size of arrays in z direction"
{
0:* :: ""
} 10
| # Schedule definitions for thorn TestLocalReduce
# $Header$
STORAGE: real_vals int_vals
schedule TestLocalReduceC_Maximum at CCTK_POSTINITIAL
{
LANG: C
} "Test out maximum reductions from C"
schedule TestLocalReduceC_Sum at CCTK_POSTINITIAL
{
LANG: C
} "Test out sum reductions from C"
schedule TestLocalReduceC... | make.code.defn | # Main make.code.defn file for thorn TestReduce
# $Header$
# Source files in this directory
SRCS = Reduce_Maximum.c Reduce_Sum.c Reduce_Avg.c
# Subdirectories containing source files
SUBDIRS =
| Reduce_Maximum.c
Reduce_Avg.c
Reduce_Sum.c
| Reduce_Maximum.c:
```
/*@@
@file Reduce_Maximum.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Test the new local maximum reduction implementation
@enddesc
@version $Id$
@@*/
#include <stdlib.h>
#include "cctk.h"
#include "util_Table.h"
#include "cc... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.t... | |
CactusNumerical/TestLocalReduce | https://bitbucket.org/cactuscode/cactusnumerical.git | # Interface definition for thorn TestLocalReduce
# $Header$
implements: TestLocalReduce
public:
real real_vals type=scalar
{
real_max_3D
real_max_2D
real_max_1D
real_sum_3D
real_sum_2D
real_sum_1D
real_avg_3D
real_avg_2D
real_avg_1D
} "results from real reduction"
int int_vals type=scalar
{
... | # Parameter definitions for thorn TestLocalReduce
# $Header$
INT array_nx "Size of arrays in x direction"
{
0:* :: ""
} 4
INT array_ny "Size of arrays in y direction"
{
0:* :: ""
} 5
INT array_nz "Size of arrays in z direction"
{
0:* :: ""
} 10
| # Schedule definitions for thorn TestLocalReduce
# $Header$
STORAGE: real_vals int_vals
schedule TestLocalReduceC_Maximum at CCTK_POSTINITIAL
{
LANG: C
} "Test out maximum reductions from C"
schedule TestLocalReduceC_Sum at CCTK_POSTINITIAL
{
LANG: C
} "Test out sum reductions from C"
schedule TestLocalReduceC... | Reduce_Sum.c | /*@@
@file Reduce_Sum.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Test the new local sum reduction implementation
@enddesc
@version $Id$
@@*/
#include <stdlib.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static co... | Reduce_Maximum.c
Reduce_Avg.c
make.code.defn
| Reduce_Maximum.c:
```
/*@@
@file Reduce_Maximum.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Test the new local maximum reduction implementation
@enddesc
@version $Id$
@@*/
#include <stdlib.h>
#include "cctk.h"
#include "util_Table.h"
#include "cc... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestLocalReduce
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.t... | |
CactusTest/TestArrays | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn Arrays
# $Header$
implements: Arrays
REAL foo1d TYPE=ARRAY DIM=1 SIZE=xsize1d GHOSTSIZE=xghost1d
{
gf1d
}
REAL foo2d TYPE=ARRAY DIM=2 SIZE=xsize2d,ysize2d GHOSTSIZE=xghost2d,yghost2d
{
gf2d
}
REAL foo3d TYPE=ARRAY DIM=3 SIZE=xsize3d,ysize3d,zsize3d GHOSTSIZE=xghost3d,yghost3d,zg... | # Parameter definitions for thorn Arrays
# $Header$
private:
# 4D Arrays
INT xghost4d "Ghostzone size in x direction for 4d arrays"
{
0:* :: ""
} 1
INT yghost4d "Ghostzone size in y direction for 4d arrays"
{
0:* :: ""
} 1
INT zghost4d "Ghostzone size in z direction for 4d arrays"
{
0:* :: ""
} 1
INT tghost... | # Schedule definitions for thorn Arrays
# $Header$
storage: foo1d,foo2d,foo3d,foo4d
storage: bar_a_0d
storage: bar_a_1d bar_b_1d bar_c_1d bar_d_1d bar_e_1d bar_f_1d
storage: bar_a_2d bar_b_2d bar_c_2d bar_d_2d bar_e_2d bar_f_2d
storage: bar_g_2d bar_h_2d bar_i_2d bar_j_2d bar_k_2d bar_l_2d
storage: bar_a_3d bar_b_3d b... | make.code.defn | # Main make.code.defn file for thorn Arrays
# $Header$
# Source files in this directory
SRCS = Array.F
# Subdirectories containing source files
SUBDIRS =
| Array.F
| Array.F:
```
/*@@
@file Array.F
@date
@author Gabrielle Allen
@desc
Set up and use arrays
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Functions.h"
#include "cctk_Parameters.h"
subroutine SetUpFortranArrays(CCTK_ARGUMENTS)
im... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestArrays
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestArrays
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.tex ==... | |
CactusTest/TestArrays | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn Arrays
# $Header$
implements: Arrays
REAL foo1d TYPE=ARRAY DIM=1 SIZE=xsize1d GHOSTSIZE=xghost1d
{
gf1d
}
REAL foo2d TYPE=ARRAY DIM=2 SIZE=xsize2d,ysize2d GHOSTSIZE=xghost2d,yghost2d
{
gf2d
}
REAL foo3d TYPE=ARRAY DIM=3 SIZE=xsize3d,ysize3d,zsize3d GHOSTSIZE=xghost3d,yghost3d,zg... | # Parameter definitions for thorn Arrays
# $Header$
private:
# 4D Arrays
INT xghost4d "Ghostzone size in x direction for 4d arrays"
{
0:* :: ""
} 1
INT yghost4d "Ghostzone size in y direction for 4d arrays"
{
0:* :: ""
} 1
INT zghost4d "Ghostzone size in z direction for 4d arrays"
{
0:* :: ""
} 1
INT tghost... | # Schedule definitions for thorn Arrays
# $Header$
storage: foo1d,foo2d,foo3d,foo4d
storage: bar_a_0d
storage: bar_a_1d bar_b_1d bar_c_1d bar_d_1d bar_e_1d bar_f_1d
storage: bar_a_2d bar_b_2d bar_c_2d bar_d_2d bar_e_2d bar_f_2d
storage: bar_g_2d bar_h_2d bar_i_2d bar_j_2d bar_k_2d bar_l_2d
storage: bar_a_3d bar_b_3d b... | Array.F | /*@@
@file Array.F
@date
@author Gabrielle Allen
@desc
Set up and use arrays
@enddesc
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Functions.h"
#include "cctk_Parameters.h"
subroutine SetUpFortranArrays(CCTK_ARGUMENTS)
implicit none
... | make.code.defn
| make.code.defn:
```
# Main make.code.defn file for thorn Arrays
# $Header$
# Source files in this directory
SRCS = Array.F
# Subdirectories containing source files
SUBDIRS =
```
| === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestArrays
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestArrays
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.tex ==... | |
CactusTest/TestComplex | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestComplex
# $Header$
implements: testcomplex
complex cvars3d dim=3 type=gf timelevels=2
{
comp3d
} "3D complex grid functions"
#complex cvars2d dim=2 type=gf
#{
# comp2d
#} "2D complex grid functions"
#complex cvars1d dim=1 type=gf
#{
# comp1d
#} "1D complex grid functions"
c... | # Parameter definitions for thorn TestComplex
# $Header$
REAL power_value "power of the complex number to take" STEERABLE = ALWAYS
{
0.0: :: "Some positive value"
} 0.5
REAL real_value "power of the complex number to take" STEERABLE = ALWAYS
{
*:* :: "real part"
} 3
REAL imaginary_value "power of the complex numb... | # Schedule definitions for thorn TestComplex
# $Header$
STORAGE: cvars3d[2]
STORAGE: carrays3d carrays2d carrays1d cscalars
STORAGE: cmplx_output
schedule InitComplex3D at INITIAL
{
LANG: Fortran
} "Initialise 3D complex grid functions"
schedule EvolveComplex3D at EVOL
{
LANG: Fortran
SYNC: cvars3d
} "Evolve 3... | Complex.c | #include <math.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Id$";
CCTK_FILEVERSION(CactusTest_TestComplex_Complex_c);
void TestComplexPower(CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
CCTK_COMPLEX num, tmp;
num = CCTK... | make.code.defn
Complex3D.F77
| make.code.defn:
```
# Main make.code.defn file for thorn TestComplex
# $Header$
# Source files in this directory
SRCS = Complex3D.F77 Complex.c
# Subdirectories containing source files
SUBDIRS =
```
Complex3D.F77:
```
c $Header$
#include "cctk.h"
#include "cctk_Arguments.h"
subroutine InitComplex3D(CC... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestComplex
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestComplex
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.tex =... | |
CactusTest/TestComplex | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestComplex
# $Header$
implements: testcomplex
complex cvars3d dim=3 type=gf timelevels=2
{
comp3d
} "3D complex grid functions"
#complex cvars2d dim=2 type=gf
#{
# comp2d
#} "2D complex grid functions"
#complex cvars1d dim=1 type=gf
#{
# comp1d
#} "1D complex grid functions"
c... | # Parameter definitions for thorn TestComplex
# $Header$
REAL power_value "power of the complex number to take" STEERABLE = ALWAYS
{
0.0: :: "Some positive value"
} 0.5
REAL real_value "power of the complex number to take" STEERABLE = ALWAYS
{
*:* :: "real part"
} 3
REAL imaginary_value "power of the complex numb... | # Schedule definitions for thorn TestComplex
# $Header$
STORAGE: cvars3d[2]
STORAGE: carrays3d carrays2d carrays1d cscalars
STORAGE: cmplx_output
schedule InitComplex3D at INITIAL
{
LANG: Fortran
} "Initialise 3D complex grid functions"
schedule EvolveComplex3D at EVOL
{
LANG: Fortran
SYNC: cvars3d
} "Evolve 3... | make.code.defn | # Main make.code.defn file for thorn TestComplex
# $Header$
# Source files in this directory
SRCS = Complex3D.F77 Complex.c
# Subdirectories containing source files
SUBDIRS =
| Complex.c
Complex3D.F77
| Complex.c:
```
#include <math.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Id$";
CCTK_FILEVERSION(CactusTest_TestComplex_Complex_c);
void TestComplexPower(CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
CCTK_COMPLEX num, tmp;
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestComplex
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestComplex
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.tex =... | |
CactusTest/TestComplex | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestComplex
# $Header$
implements: testcomplex
complex cvars3d dim=3 type=gf timelevels=2
{
comp3d
} "3D complex grid functions"
#complex cvars2d dim=2 type=gf
#{
# comp2d
#} "2D complex grid functions"
#complex cvars1d dim=1 type=gf
#{
# comp1d
#} "1D complex grid functions"
c... | # Parameter definitions for thorn TestComplex
# $Header$
REAL power_value "power of the complex number to take" STEERABLE = ALWAYS
{
0.0: :: "Some positive value"
} 0.5
REAL real_value "power of the complex number to take" STEERABLE = ALWAYS
{
*:* :: "real part"
} 3
REAL imaginary_value "power of the complex numb... | # Schedule definitions for thorn TestComplex
# $Header$
STORAGE: cvars3d[2]
STORAGE: carrays3d carrays2d carrays1d cscalars
STORAGE: cmplx_output
schedule InitComplex3D at INITIAL
{
LANG: Fortran
} "Initialise 3D complex grid functions"
schedule EvolveComplex3D at EVOL
{
LANG: Fortran
SYNC: cvars3d
} "Evolve 3... | Complex3D.F77 | c $Header$
#include "cctk.h"
#include "cctk_Arguments.h"
subroutine InitComplex3D(CCTK_ARGUMENTS)
implicit none
DECLARE_CCTK_ARGUMENTS
integer grouplbnd(3), grouplsh(3)
integer i0,j0,k0
integer nx,ny,nz
integer i,j,k
integer ierr
i0 = cctk_lbnd(1)
j0... | Complex.c
make.code.defn
| Complex.c:
```
#include <math.h>
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
static const char *rcsid = "$Id$";
CCTK_FILEVERSION(CactusTest_TestComplex_Complex_c);
void TestComplexPower(CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
CCTK_COMPLEX num, tmp;
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file d... | documentation.tex | Cactus Code Thorn TestComplex
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestComplex
Author(s) : unknown
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== documentation.tex =... | |
CactusTest/TestFpointerNULL | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestFpointerNULL
# $Header$
implements: TestFpointerNULL
private:
REAL array_group TYPE=ARRAY DIM=2 SIZE=5,10
{
array
} "CCTK_REAL test array"
INT scalar_group TYPE=SCALAR
{
scalar
} "CCTK_INT test scalar"
| # Parameter definitions for thorn TestFpointerNULL
# $Header$
| # Schedule definitions for thorn TestFpointerNULL
# $Header$
STORAGE: scalar_group array_group
SCHEDULE TestFpointerNULL_Caller AT INITIAL
{
LANG: C
} "Test passing a NULL pointer from a C function into Fortran routine"
| make.code.defn | # Main make.code.defn file for thorn PassNULLtoFortran
# $Header$
# Source files in this directory
SRCS = Caller.c Callee.F77
| Caller.c
Callee.F77
| Caller.c:
```
/*@@
@file Caller.c
@date Thu 13 June 2002
@author Thomas Radke
@desc
C interface of the TestFpointerNULL thorn.
@enddesc
@version $Id$
@@*/
#include <stdio.h>
#include <string.h>
#include "cctk.h"
#include "cctk_FortranString.h"
/* the rcsid and the macr... | Cactus Code Thorn TestFpointerNULL
Author(s) : Thomas Radke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn tests whether a Fortran routine accepts a NULL pointer reference
as a function argument when called from a C fu... | README | ## README (README):
```
Cactus Code Thorn TestFpointerNULL
Author(s) : Thomas Radke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn tests whether a Fortran routine accepts a NULL pointer reference
as a function argument... | |||
CactusTest/TestFpointerNULL | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestFpointerNULL
# $Header$
implements: TestFpointerNULL
private:
REAL array_group TYPE=ARRAY DIM=2 SIZE=5,10
{
array
} "CCTK_REAL test array"
INT scalar_group TYPE=SCALAR
{
scalar
} "CCTK_INT test scalar"
| # Parameter definitions for thorn TestFpointerNULL
# $Header$
| # Schedule definitions for thorn TestFpointerNULL
# $Header$
STORAGE: scalar_group array_group
SCHEDULE TestFpointerNULL_Caller AT INITIAL
{
LANG: C
} "Test passing a NULL pointer from a C function into Fortran routine"
| Caller.c | /*@@
@file Caller.c
@date Thu 13 June 2002
@author Thomas Radke
@desc
C interface of the TestFpointerNULL thorn.
@enddesc
@version $Id$
@@*/
#include <stdio.h>
#include <string.h>
#include "cctk.h"
#include "cctk_FortranString.h"
/* the rcsid and the macro to use it */... | make.code.defn
Callee.F77
| make.code.defn:
```
# Main make.code.defn file for thorn PassNULLtoFortran
# $Header$
# Source files in this directory
SRCS = Caller.c Callee.F77
```
Callee.F77:
```
c @@
c @file Callee.c
c @date Thu 13 June 2002
c @author Thomas Radke
c @desc
c Fortran interface of the TestFpointerNULL ... | Cactus Code Thorn TestFpointerNULL
Author(s) : Thomas Radke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn tests whether a Fortran routine accepts a NULL pointer reference
as a function argument when called from a C fu... | README | ## README (README):
```
Cactus Code Thorn TestFpointerNULL
Author(s) : Thomas Radke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn tests whether a Fortran routine accepts a NULL pointer reference
as a function argument... | |||
CactusTest/TestFpointerNULL | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestFpointerNULL
# $Header$
implements: TestFpointerNULL
private:
REAL array_group TYPE=ARRAY DIM=2 SIZE=5,10
{
array
} "CCTK_REAL test array"
INT scalar_group TYPE=SCALAR
{
scalar
} "CCTK_INT test scalar"
| # Parameter definitions for thorn TestFpointerNULL
# $Header$
| # Schedule definitions for thorn TestFpointerNULL
# $Header$
STORAGE: scalar_group array_group
SCHEDULE TestFpointerNULL_Caller AT INITIAL
{
LANG: C
} "Test passing a NULL pointer from a C function into Fortran routine"
| Callee.F77 | c @@
c @file Callee.c
c @date Thu 13 June 2002
c @author Thomas Radke
c @desc
c Fortran interface of the TestFpointerNULL thorn.
c @enddesc
c @version $Id$
c@@
#include "cctk.h"
c @@
c @routine TestFpointerNULL_Callee
c @author Thomas Radke
c @date Thu 13 June 2002
c... | make.code.defn
Caller.c
| make.code.defn:
```
# Main make.code.defn file for thorn PassNULLtoFortran
# $Header$
# Source files in this directory
SRCS = Caller.c Callee.F77
```
Caller.c:
```
/*@@
@file Caller.c
@date Thu 13 June 2002
@author Thomas Radke
@desc
C interface of the TestFpointerNULL thorn.
... | Cactus Code Thorn TestFpointerNULL
Author(s) : Thomas Radke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn tests whether a Fortran routine accepts a NULL pointer reference
as a function argument when called from a C fu... | README | ## README (README):
```
Cactus Code Thorn TestFpointerNULL
Author(s) : Thomas Radke
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
This thorn tests whether a Fortran routine accepts a NULL pointer reference
as a function argument... | |||
CactusTest/TestGlobalReduce | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestGlobalReduce
# $Header$
implements:testglobalreduce
inherits: grid
public:
cctk_real real_3d dim=3 type=ARRAY size=array_nx,array_ny,array_nz
{
grid_real
} "grid array to be reduced of type real"
cctk_int int_3d dim=3 type=ARRAY size=array_nx,array_ny,array_nz
{
grid_int
} "g... | # Parameter definitions for thorn TestGlobalReduce
# $Header$
INT array_nx "Size of arrays in x direction"
{
0:* :: ""
} 5
INT array_ny "Size of arrays in y direction"
{
0:* :: ""
} 4
INT array_nz "Size of arrays in z direction"
{
0:* :: ""
} 10
INT dest_proc "processor to which reduction is to be made"
{
*:... | # Schedule definitions for thorn TestGlobapdReduce
# $Header$
STORAGE: real_3d int_3d real_vals int_vals weighted_real_vals weighted_int_vals real_gf[1] gf_vals[1] scalar_reduction weight_group
schedule TestGlobalReduce_Initial at CCTK_INITIAL
{
LANG:C
} "Initialize the input arrays to values"
schedule TestGlobalR... | Initial.c | /*@@
@file Initial.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Setup the grid arrays we want to test reduction with
@enddesc
@version $Id$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include <math.h>
static co... | make.code.defn
TestGlobalReduce.c
| make.code.defn:
```
# Main make.code.defn file for thorn TestGlobalReduce
# $Header$
# Source files in this directory
SRCS = Initial.c TestGlobalReduce.c
# Subdirectories containing source files
SUBDIRS =
```
TestGlobalReduce.c:
```
/*@@
@file TestGlobalReduce.c
@date Tues Sep 7 16:00:29 2004
... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestGlobalReduce
Author(s) : Yaakoub Y El Khamra
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestGlobalReduce
Author(s) : Yaakoub Y El Khamra
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== do... | |
CactusTest/TestGlobalReduce | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestGlobalReduce
# $Header$
implements:testglobalreduce
inherits: grid
public:
cctk_real real_3d dim=3 type=ARRAY size=array_nx,array_ny,array_nz
{
grid_real
} "grid array to be reduced of type real"
cctk_int int_3d dim=3 type=ARRAY size=array_nx,array_ny,array_nz
{
grid_int
} "g... | # Parameter definitions for thorn TestGlobalReduce
# $Header$
INT array_nx "Size of arrays in x direction"
{
0:* :: ""
} 5
INT array_ny "Size of arrays in y direction"
{
0:* :: ""
} 4
INT array_nz "Size of arrays in z direction"
{
0:* :: ""
} 10
INT dest_proc "processor to which reduction is to be made"
{
*:... | # Schedule definitions for thorn TestGlobapdReduce
# $Header$
STORAGE: real_3d int_3d real_vals int_vals weighted_real_vals weighted_int_vals real_gf[1] gf_vals[1] scalar_reduction weight_group
schedule TestGlobalReduce_Initial at CCTK_INITIAL
{
LANG:C
} "Initialize the input arrays to values"
schedule TestGlobalR... | make.code.defn | # Main make.code.defn file for thorn TestGlobalReduce
# $Header$
# Source files in this directory
SRCS = Initial.c TestGlobalReduce.c
# Subdirectories containing source files
SUBDIRS =
| Initial.c
TestGlobalReduce.c
| Initial.c:
```
/*@@
@file Initial.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Setup the grid arrays we want to test reduction with
@enddesc
@version $Id$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include <mat... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestGlobalReduce
Author(s) : Yaakoub Y El Khamra
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestGlobalReduce
Author(s) : Yaakoub Y El Khamra
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== do... | |
CactusTest/TestGlobalReduce | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestGlobalReduce
# $Header$
implements:testglobalreduce
inherits: grid
public:
cctk_real real_3d dim=3 type=ARRAY size=array_nx,array_ny,array_nz
{
grid_real
} "grid array to be reduced of type real"
cctk_int int_3d dim=3 type=ARRAY size=array_nx,array_ny,array_nz
{
grid_int
} "g... | # Parameter definitions for thorn TestGlobalReduce
# $Header$
INT array_nx "Size of arrays in x direction"
{
0:* :: ""
} 5
INT array_ny "Size of arrays in y direction"
{
0:* :: ""
} 4
INT array_nz "Size of arrays in z direction"
{
0:* :: ""
} 10
INT dest_proc "processor to which reduction is to be made"
{
*:... | # Schedule definitions for thorn TestGlobapdReduce
# $Header$
STORAGE: real_3d int_3d real_vals int_vals weighted_real_vals weighted_int_vals real_gf[1] gf_vals[1] scalar_reduction weight_group
schedule TestGlobalReduce_Initial at CCTK_INITIAL
{
LANG:C
} "Initialize the input arrays to values"
schedule TestGlobalR... | TestGlobalReduce.c | /*@@
@file TestGlobalReduce.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Test the global reduction implementation
@enddesc
@version $Header$
@@*/
#include <stdio.h>
#include "cctk.h"
#include "util_Table.h"
#include "cctk_Arguments.h"
#include "cc... | Initial.c
make.code.defn
| Initial.c:
```
/*@@
@file Initial.c
@date Tues Sep 7 16:00:29 2004
@author Yaakoub El Khamra
@desc
Setup the grid arrays we want to test reduction with
@enddesc
@version $Id$
@@*/
#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
#include <mat... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestGlobalReduce
Author(s) : Yaakoub Y El Khamra
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
| README | ## README (README):
```
Cactus Code Thorn TestGlobalReduce
Author(s) : Yaakoub Y El Khamra
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
not documented
```
## Documentation (.tex files):
Files: documentation.tex
```tex
=== do... | |
CactusTest/TestMoL | https://bitbucket.org/cactuscode/cactustest.git | # Configuration definitions for thorn TestMoL
| implements: TestMoL
inherits: MethodOfLines # not really required but useful to make sure MoL is active
################################################################
### Aliased registration and type changing functions for the ###
### standard (i.e., real) GFs. ###
####################... | private:
KEYWORD RHSexpression "expression to use for the right-hand-side of the ODE"
{
"1" :: "unit rhs"
"t" :: "linear in time rhs"
"t**2" :: "quadratic in time rhs"
"t**3" :: "cubic in time rhs"
"t**4" :: "quartic in time rhs"
"t**5" :: "quintic in time rhs"
"t**6" :: "sixth order in time rhs"
"t**7... | STORAGE: evolved_gf[3] evolvedslow_gf[3] constrained_gf[3] sandr_gf[3]
STORAGE: rhs_gf[1] rhsslow_gf[1]
STORAGE: diff_gf[1] analytic_gf[1] diffslow_gf[1] analyticslow_gf[1]
STORAGE: evolved_ga[3] constrained_ga[3] sandr_ga[3]
STORAGE: rhs_ga[1]
STORAGE: diff_ga[1] analytic_ga[1]
schedule TestMoL_RegisterVars in MoL_Re... | Init.c | #include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include <assert.h>
/*****************************************************************************
************** External routines ********************************************
****************************************************************... | Register.c
RHS.c
make.code.defn
| Register.c:
```
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include <assert.h>
/*****************************************************************************
************** External routines ********************************************
************************************************... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right-hand-side
and tests tha... | README | ## README (README):
```
Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right... |
CactusTest/TestMoL | https://bitbucket.org/cactuscode/cactustest.git | # Configuration definitions for thorn TestMoL
| implements: TestMoL
inherits: MethodOfLines # not really required but useful to make sure MoL is active
################################################################
### Aliased registration and type changing functions for the ###
### standard (i.e., real) GFs. ###
####################... | private:
KEYWORD RHSexpression "expression to use for the right-hand-side of the ODE"
{
"1" :: "unit rhs"
"t" :: "linear in time rhs"
"t**2" :: "quadratic in time rhs"
"t**3" :: "cubic in time rhs"
"t**4" :: "quartic in time rhs"
"t**5" :: "quintic in time rhs"
"t**6" :: "sixth order in time rhs"
"t**7... | STORAGE: evolved_gf[3] evolvedslow_gf[3] constrained_gf[3] sandr_gf[3]
STORAGE: rhs_gf[1] rhsslow_gf[1]
STORAGE: diff_gf[1] analytic_gf[1] diffslow_gf[1] analyticslow_gf[1]
STORAGE: evolved_ga[3] constrained_ga[3] sandr_ga[3]
STORAGE: rhs_ga[1]
STORAGE: diff_ga[1] analytic_ga[1]
schedule TestMoL_RegisterVars in MoL_Re... | Register.c | #include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include <assert.h>
/*****************************************************************************
************** External routines ********************************************
****************************************************************... | Init.c
RHS.c
make.code.defn
| Init.c:
```
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include <assert.h>
/*****************************************************************************
************** External routines ********************************************
****************************************************... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right-hand-side
and tests tha... | README | ## README (README):
```
Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right... |
CactusTest/TestMoL | https://bitbucket.org/cactuscode/cactustest.git | # Configuration definitions for thorn TestMoL
| implements: TestMoL
inherits: MethodOfLines # not really required but useful to make sure MoL is active
################################################################
### Aliased registration and type changing functions for the ###
### standard (i.e., real) GFs. ###
####################... | private:
KEYWORD RHSexpression "expression to use for the right-hand-side of the ODE"
{
"1" :: "unit rhs"
"t" :: "linear in time rhs"
"t**2" :: "quadratic in time rhs"
"t**3" :: "cubic in time rhs"
"t**4" :: "quartic in time rhs"
"t**5" :: "quintic in time rhs"
"t**6" :: "sixth order in time rhs"
"t**7... | STORAGE: evolved_gf[3] evolvedslow_gf[3] constrained_gf[3] sandr_gf[3]
STORAGE: rhs_gf[1] rhsslow_gf[1]
STORAGE: diff_gf[1] analytic_gf[1] diffslow_gf[1] analyticslow_gf[1]
STORAGE: evolved_ga[3] constrained_ga[3] sandr_ga[3]
STORAGE: rhs_ga[1]
STORAGE: diff_ga[1] analytic_ga[1]
schedule TestMoL_RegisterVars in MoL_Re... | RHS.c | #include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include <assert.h>
#include <math.h>
/*****************************************************************************
************** Local types **************************************************
**********************************************... | Init.c
Register.c
make.code.defn
| Init.c:
```
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include <assert.h>
/*****************************************************************************
************** External routines ********************************************
****************************************************... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right-hand-side
and tests tha... | README | ## README (README):
```
Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right... |
CactusTest/TestMoL | https://bitbucket.org/cactuscode/cactustest.git | # Configuration definitions for thorn TestMoL
| implements: TestMoL
inherits: MethodOfLines # not really required but useful to make sure MoL is active
################################################################
### Aliased registration and type changing functions for the ###
### standard (i.e., real) GFs. ###
####################... | private:
KEYWORD RHSexpression "expression to use for the right-hand-side of the ODE"
{
"1" :: "unit rhs"
"t" :: "linear in time rhs"
"t**2" :: "quadratic in time rhs"
"t**3" :: "cubic in time rhs"
"t**4" :: "quartic in time rhs"
"t**5" :: "quintic in time rhs"
"t**6" :: "sixth order in time rhs"
"t**7... | STORAGE: evolved_gf[3] evolvedslow_gf[3] constrained_gf[3] sandr_gf[3]
STORAGE: rhs_gf[1] rhsslow_gf[1]
STORAGE: diff_gf[1] analytic_gf[1] diffslow_gf[1] analyticslow_gf[1]
STORAGE: evolved_ga[3] constrained_ga[3] sandr_ga[3]
STORAGE: rhs_ga[1]
STORAGE: diff_ga[1] analytic_ga[1]
schedule TestMoL_RegisterVars in MoL_Re... | make.code.defn | # Source files in this directory
SRCS = Register.c RHS.c Init.c
# Subdirectories containing source files
SUBDIRS =
| Init.c
Register.c
RHS.c
| Init.c:
```
#include "cctk.h"
#include "cctk_Parameters.h"
#include "cctk_Arguments.h"
#include <assert.h>
/*****************************************************************************
************** External routines ********************************************
****************************************************... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right-hand-side
and tests tha... | README | ## README (README):
```
Cactus Code Thorn TestMoL
Author(s) : Roland Haas <rhaas@caltech.edu>
Maintainer(s): Roland Haas <rhaas@caltech.edu>
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Tests the ODE integration methods in MoL by providing a simple right... |
CactusTest/TestPar | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestPar
IMPLEMENTS: TestPar
| # Parameter definitions for thorn TestPar
STRING string1 ""
{
".*" :: "Any string"
} ""
STRING string2 ""
{
".*" :: "Any string"
} ""
STRING string3 ""
{
".*" :: "Any string"
} ""
STRING string4 ""
{
".*" :: "Any string"
} ""
STRING string5 ""
{
".*" :: "Any string"
} ""
STRING string6 ""
{
".*" :: "A... | # Schedule definitions for thorn TestPar
SCHEDULE TestPar_PrintStrings AT initial
{
LANG: C
} "Output string parameters"
SCHEDULE TestPar_SetValues AT initial
{
LANG: C
} "Set values based on parameters"
| SetValues.c | #include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <cctk_File.h>
#include <util_String.h>
#include <stdio.h>
#include <stdlib.h>
void TestPar_SetValues (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
FILE *fh = NULL;
char *buf = NULL;
if(C... | make.code.defn
PrintStrings.c
| make.code.defn:
```
# Main make.code.defn file for thorn TestPar
# Source files in this directory
SRCS = PrintStrings.c SetValues.c
# Subdirectories containing source files
SUBDIRS =
```
PrintStrings.c:
```
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
void TestPar_PrintStrings (CCTK_... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestPar
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Test parameter file syntax.
| README | ## README (README):
```
Cactus Code Thorn TestPar
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Test parameter file syntax.
```
## Documentation (.tex files):
Files: documenta... | |
CactusTest/TestPar | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestPar
IMPLEMENTS: TestPar
| # Parameter definitions for thorn TestPar
STRING string1 ""
{
".*" :: "Any string"
} ""
STRING string2 ""
{
".*" :: "Any string"
} ""
STRING string3 ""
{
".*" :: "Any string"
} ""
STRING string4 ""
{
".*" :: "Any string"
} ""
STRING string5 ""
{
".*" :: "Any string"
} ""
STRING string6 ""
{
".*" :: "A... | # Schedule definitions for thorn TestPar
SCHEDULE TestPar_PrintStrings AT initial
{
LANG: C
} "Output string parameters"
SCHEDULE TestPar_SetValues AT initial
{
LANG: C
} "Set values based on parameters"
| make.code.defn | # Main make.code.defn file for thorn TestPar
# Source files in this directory
SRCS = PrintStrings.c SetValues.c
# Subdirectories containing source files
SUBDIRS =
| SetValues.c
PrintStrings.c
| SetValues.c:
```
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <cctk_File.h>
#include <util_String.h>
#include <stdio.h>
#include <stdlib.h>
void TestPar_SetValues (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
FILE *fh = NULL;
char *buf ... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestPar
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Test parameter file syntax.
| README | ## README (README):
```
Cactus Code Thorn TestPar
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Test parameter file syntax.
```
## Documentation (.tex files):
Files: documenta... | |
CactusTest/TestPar | https://bitbucket.org/cactuscode/cactustest.git | # Interface definition for thorn TestPar
IMPLEMENTS: TestPar
| # Parameter definitions for thorn TestPar
STRING string1 ""
{
".*" :: "Any string"
} ""
STRING string2 ""
{
".*" :: "Any string"
} ""
STRING string3 ""
{
".*" :: "Any string"
} ""
STRING string4 ""
{
".*" :: "Any string"
} ""
STRING string5 ""
{
".*" :: "Any string"
} ""
STRING string6 ""
{
".*" :: "A... | # Schedule definitions for thorn TestPar
SCHEDULE TestPar_PrintStrings AT initial
{
LANG: C
} "Output string parameters"
SCHEDULE TestPar_SetValues AT initial
{
LANG: C
} "Set values based on parameters"
| PrintStrings.c | #include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
void TestPar_PrintStrings (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
CCTK_VInfo (CCTK_THORNSTRING, "String 1: \"%s\"", string1);
CCTK_VInfo (CCTK_THORNSTRING, "String 2: \"%s\"", string2);
CCTK_VInfo (CCTK_... | SetValues.c
make.code.defn
| SetValues.c:
```
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <cctk_File.h>
#include <util_String.h>
#include <stdio.h>
#include <stdlib.h>
void TestPar_SetValues (CCTK_ARGUMENTS)
{
DECLARE_CCTK_ARGUMENTS;
DECLARE_CCTK_PARAMETERS;
int i;
FILE *fh = NULL;
char *buf ... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn TestPar
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Test parameter file syntax.
| README | ## README (README):
```
Cactus Code Thorn TestPar
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Cactus team
Licence : LGPL
--------------------------------------------------------------------------
1. Purpose
Test parameter file syntax.
```
## Documentation (.tex files):
Files: documenta... | |
CactusUtils/Trigger | https://bitbucket.org/cactuscode/cactusutils.git | # Interface definition for thorn Trigger
inherits: IO
implements: trigger
CCTK_REAL Trigger_Vars DISTRIB=CONSTANT tags='checkpoint="no"'
{
trigger_cctk_iteration
trigger_cctk_time
} "Scalars for the triggers"
| # Parameter definitions for thorn Nice
# parameter values are parsed into a GH extension at startup so cannot be
# (meaningfully) steered at runtime
CCTK_INT Trigger_Number "Number of triggers" STEERABLE=RECOVER
{
0:10 :: "The number of triggers that are defined"
} 0
STRING Trigger_Checked_Variable[10] "variable to... | # Schedule definitions for thorn Trigger
schedule Trigger_Startup at STARTUP
{
LANG: C
} "Startup Routine"
schedule Trigger_ParamCheck AT PARAMCHECK
{
LANG: C
} "Parameter checking"
schedule Trigger_Check at ANALYSIS before AHFinderDirect_setupupdate
{
LANG: C
# schedule global-early so that eg. o... | make.code.defn | # Main make.code.defn file for thorn Nice
# Source files in this directory
SRCS = trigger.c
| trigger.c
| trigger.c:
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_WarnLevel.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
/* Trigger GH extension structure */
typedef struct
{
int number;
int *active;
int *checked_variable;
int *output_variables;
int *ou... | === documentation.tex ===
% *======================================================================*
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Cactus make system.
% The scripts employed by the make system automatically include
% pages about vari... | documentation.tex | Cactus Code Thorn SystemStatistics
Author(s) : Frank Loeffler <knarf@cct.lsu.edu>
Maintainer(s): Frank Loeffler <knarf@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
Purpose of this thorn
---------------------
This thorn can be used to define... | README | ## README (README):
```
Cactus Code Thorn SystemStatistics
Author(s) : Frank Loeffler <knarf@cct.lsu.edu>
Maintainer(s): Frank Loeffler <knarf@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
Purpose of this thorn
---------------------
This tho... | |
CactusUtils/Trigger | https://bitbucket.org/cactuscode/cactusutils.git | # Interface definition for thorn Trigger
inherits: IO
implements: trigger
CCTK_REAL Trigger_Vars DISTRIB=CONSTANT tags='checkpoint="no"'
{
trigger_cctk_iteration
trigger_cctk_time
} "Scalars for the triggers"
| # Parameter definitions for thorn Nice
# parameter values are parsed into a GH extension at startup so cannot be
# (meaningfully) steered at runtime
CCTK_INT Trigger_Number "Number of triggers" STEERABLE=RECOVER
{
0:10 :: "The number of triggers that are defined"
} 0
STRING Trigger_Checked_Variable[10] "variable to... | # Schedule definitions for thorn Trigger
schedule Trigger_Startup at STARTUP
{
LANG: C
} "Startup Routine"
schedule Trigger_ParamCheck AT PARAMCHECK
{
LANG: C
} "Parameter checking"
schedule Trigger_Check at ANALYSIS before AHFinderDirect_setupupdate
{
LANG: C
# schedule global-early so that eg. o... | trigger.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cctk.h"
#include "cctk_WarnLevel.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"
/* Trigger GH extension structure */
typedef struct
{
int number;
int *active;
int *checked_variable;
int *output_variables;
int *output_variables_... | make.code.defn
| make.code.defn:
```
# Main make.code.defn file for thorn Nice
# Source files in this directory
SRCS = trigger.c
```
| === documentation.tex ===
% *======================================================================*
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built with the Cactus make system.
% The scripts employed by the make system automatically include
% pages about vari... | documentation.tex | Cactus Code Thorn SystemStatistics
Author(s) : Frank Loeffler <knarf@cct.lsu.edu>
Maintainer(s): Frank Loeffler <knarf@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
Purpose of this thorn
---------------------
This thorn can be used to define... | README | ## README (README):
```
Cactus Code Thorn SystemStatistics
Author(s) : Frank Loeffler <knarf@cct.lsu.edu>
Maintainer(s): Frank Loeffler <knarf@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
Purpose of this thorn
---------------------
This tho... | |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-8-VSX.h | // -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#define vec8_architecture ... | vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-defa... | vectors-8-DoubleHummer.h:
```
// -*-C++-*-
// Vectorise using IBM's Blue Gene/P Double Hummer (Power)
// Use the type double _Complex directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>
#include <assert.... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-8-DoubleHummer.h | // -*-C++-*-
// Vectorise using IBM's Blue Gene/P Double Hummer (Power)
// Use the type double _Complex directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp>
#include <assert.h>
#ifdef __cplusplus
# incl... | vectors-8-VSX.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-default.h
mac... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-8-AVX.h | // -*-C++-*-
// Vectorise using Intel's or AMD's AVX
// Use the type __m256d directly, without introducing a wrapper class
#include <cstdlib>
#include <cstring>
#include <immintrin.h>
#ifdef __FMA4__
# include <x86intrin.h>
#endif
#ifdef __FMA4__
# define vec8_architecture_FMA4 "+FMA4"
#else
# define vec8_... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-defa... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-4-default.h | // -*-C++-*-
// Fallback vectorisation implementation: Do not vectorise
// We use macros here, so that we are not surprised by compilers which
// don't like to inline functions. This should also make debug builds
// (which may not inline) more efficient.
#include <assert.h>
#include <math.h>
#define vec4_archite... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-default.... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-4-SSE.h | // -*-C++-*-
// Vectorise using Intel's or AMD's SSE
// Use the type __m128 directly, without introducing a wrapper class
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <xmmintrin.h>
#ifdef __SSE4_1__
// Intel's SSE 4.1
# include <smmintrin.h>
#endif
#ifdef __SSE4A__
// AMD's... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-defa... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-8-MIC.h | // -*-C++-*-
// Vectorise using Intel's MIC
// Use the type __m512d directly, without introducing a wrapper class
// See
// <http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/index.htm#GUID-B8DF6000-6872-47B4-AA64-D47A38AF21BD.htm>
// and
// <http://software.intel.co... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-defa... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors.h | // -*-C++-*-
#ifndef VECTORS_H
#define VECTORS_H
#include <cctk.h>
#define vec_static_assert(x) namespace { typedef int vsa[(x) ? 1 : -1]; }
#if VECTORISE
# if defined __AVX__ && !defined DISABLE_AVX // Intel AVX
# include "vectors-4-AVX.h"
# elif defined __SSE__ // Intel SSE
# include "vectors... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-8-default.h | // -*-C++-*-
// Fallback vectorisation implementation: Do not vectorise
#include <cassert>
#include <cmath>
#define vec8_architecture "scalar (no vectorisation, 64-bit precision)"
// Use CCTK_REAL8
#define CCTK_REAL8_VEC CCTK_REAL8
// Number of vector elements in a vector
#define CCTK_REAL8_VEC_SIZE 1
vec_stat... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-default.... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-4-Altivec.h | // -*-C++-*-
// Vectorise using IBM's Altivec (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
#include <altivec.h>
#define vec4_architecture "Altivec"
// Vector type corresponding to CCTK_REAL
#define CCTK_REAL4_VEC vector float
// N... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-default.... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| make.code.defn | # Main make.code.defn file for thorn Vectors
# Source files in this directory
SRCS = vectors.cc test.cc
# Subdirectories containing source files
SUBDIRS =
| vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-def... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| test.cc | #include "vectors.h"
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
using namespace std;
inline CCTK_REAL my_sgn(CCTK_REAL const x) {
return x == (CCTK_REAL)0.0 ? (CCTK_REAL)0.0 : copysign((CCTK_... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vector... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-8-QPX.h | // -*-C++-*-
// Vectorise using IBM's Blue Gene/Q QPX (Power)
#ifndef __clang__
// Use the type vector4double directly, without introducing a wrapper class
// Use macros instead of inline functions
// Note: bgxlC_r does not like const declarations, so we need to cast
// them away and/or omit them everywhere
// See ... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-defa... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-4-AVX.h | // -*-C++-*-
// Vectorise using Intel's or AMD's AVX
// Use the type __m256 directly, without introducing a wrapper class
#include <cstdlib>
#include <cstring>
#include <immintrin.h>
#ifdef __FMA4__
# include <x86intrin.h>
#endif
#ifdef __FMA4__
# define vec4_architecture_FMA4 "+FMA4"
#else
# define vec4_a... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-defa... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors.cc | #include "vectors.h"
#include <cctk.h>
#include <cctk_Arguments.h>
#include <cctk_Parameters.h>
extern "C"
int Vectors_Startup(void)
{
CCTK_VInfo(CCTK_THORNSTRING,
"Using vector size %d for architecture %s",
CCTK_REAL_VEC_SIZE, vec_architecture);
return 0;
}
| vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| vectors-8-SSE2.h | // -*-C++-*-
// Vectorise using Intel's or AMD's SSE2
// Use the type __m128d directly, without introducing a wrapper class
#include <cassert>
#include <cmath>
#include <emmintrin.h>
#ifdef __SSE4_1__
// Intel's SSE 4.1
# include <smmintrin.h>
#endif
#ifdef __SSE4A__
// AMD's SSE 4a
# include <ammintrin.h>
// I... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-defau... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| macros/vectors-8-AVX.h | // Vectorise using Intel's or AMD's AVX
// Use the type __m256d directly, without introducing a wrapper class
// Use macros instead of inline functions
#if VECTORISE_EMULATE_AVX
# include "avxintrin_emu.h"
#else
# include <immintrin.h>
#endif
#ifdef __FMA4__
# include <fma4intrin.h>
#endif
#ifdef __FMA4__
# ... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macros/vectors-8-default.h
m... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| macros/vectors-4-default.h | // Fallback vectorisation implementation: Do not vectorise
// We use macros here, so that we are not surprised by compilers which
// don't like to inline functions. This should also make debug builds
// (which may not inline) more efficient.
#include <assert.h>
#include <math.h>
#define vec4_architecture "scalar... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-SSE.h
macros/vectors-8-default.h
macro... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| macros/vectors-4-SSE.h | // Vectorise using Intel's or AMD's SSE
// Use the type __m128 directly, without introducing a wrapper class
// Use macros instead of inline functions
#include <assert.h>
#include <math.h>
#include <xmmintrin.h>
#ifdef __SSE4_1__
// Intel's SSE 4.1
# include <smmintrin.h>
#endif
#ifdef __SSE4A__
// AMD's SSE 4a
#... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-8-default.h
m... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| macros/vectors-8-default.h | // Fallback vectorisation implementation: Do not vectorise
// We use macros here, so that we are not surprised by compilers which
// don't like to inline functions. This should also make debug builds
// (which may not inline) more efficient.
#include <assert.h>
#include <math.h>
#define vec8_architecture "scalar... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macro... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
CactusUtils/Vectors | https://bitbucket.org/cactuscode/cactusutils.git | # Configuration definitions for thorn Vectors
PROVIDES Vectors
{
SCRIPT configure.sh
LANG bash
OPTIONS \
VECTORISE \
VECTORISE_ALIGNED_ARRAYS \
VECTORISE_ALWAYS_USE_UNALIGNED_LOADS \
VECTORISE_ALWAYS_USE_ALIGNED_LOADS \
V... | # Interface definition for thorn Vectors
IMPLEMENTS: Vectors
INCLUDE HEADER: vectors.h IN vectors.h
| # Parameter definitions for thorn Vectors
BOOLEAN verbose "Verbose output during vector tests"
{
} "no"
| # Schedule definitions for thorn Vectors
schedule Vectors_Startup at CCTK_STARTUP
{
LANG: C
} "Print startup message"
schedule Vectors_Test at CCTK_PARAMCHECK
{
LANG: C
} "Run correctness tests."
| macros/vectors-8-SSE2.h | // Vectorise using Intel's or AMD's SSE2
// Use the type __m128d directly, without introducing a wrapper class
// Use macros instead of inline functions
#include <assert.h>
#include <math.h>
#include <emmintrin.h>
#ifdef __SSE4_1__
// Intel's SSE 4.1
# include <smmintrin.h>
#endif
#ifdef __SSE4A__
// AMD's SSE 4a... | vectors-8-VSX.h
vectors-8-DoubleHummer.h
vectors-8-AVX.h
vectors-4-default.h
vectors-4-SSE.h
vectors-8-MIC.h
vectors.h
vectors-8-default.h
vectors-4-Altivec.h
make.code.defn
test.cc
vectors-8-QPX.h
vectors-4-AVX.h
vectors.cc
vectors-8-SSE2.h
macros/vectors-8-AVX.h
macros/vectors-4-default.h
macros/vectors-4-SSE.h
macro... | vectors-8-VSX.h:
```
// -*-C++-*-
// Vectorise using IBM's Altivec VSX (Power)
// Use the type vector double directly, without introducing a wrapper class
// Use macros instead of inline functions
// See <http://pic.dhe.ibm.com/infocenter/comphelp/v111v131/index.jsp>
#include <altivec.h>
#include <math.h>
#defi... | === documentation.tex ===
% *======================================================================*
% Cactus Thorn template for ThornGuide documentation
% Author: Ian Kelley
% Date: Sun Jun 02, 2002
% $Header$
%
% Thorn documentation in the latex file doc/documentation.tex
% will be included in ThornGuides built... | documentation.tex | Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ class template that help
ve... | README | ## README (README):
```
Cactus Code Thorn Vectors
Author(s) : Erik Schnetter <schnetter@cct.lsu.edu>
Maintainer(s): Erik Schnetter <schnetter@cct.lsu.edu>
Licence : LGPLv2.1 or later
--------------------------------------------------------------------------
1. Purpose
Provide C macro definitions and a C++ cla... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.