1 /// Copyright (c) 2017-2022, Lawrence Livermore National Security, LLC and other CEED contributors. 2 /// All Rights Reserved. See the top-level LICENSE and NOTICE files for details. 3 /// 4 /// SPDX-License-Identifier: BSD-2-Clause 5 /// 6 /// This file is part of CEED: http://github.com/ceed 7 8 /// @file 9 /// Public header for types and macros used in user QFunction source code 10 #ifndef _ceed_qfunction_defs_h 11 #define _ceed_qfunction_defs_h 12 13 #include <stddef.h> 14 #include <stdint.h> 15 16 /** 17 @ingroup CeedQFunction 18 This macro defines compiler attributes to the CEED_QFUNCTION to force inlining for called functions. 19 The `inline` declaration does not necessarily enforce a compiler to inline a function. 20 This can be detrimental to performance, so here we force inlining to occur unless inlining has been forced off (like during debugging). 21 **/ 22 #ifndef CEED_QFUNCTION_ATTR 23 #ifndef __NO_INLINE__ 24 #if defined(__GNUC__) || defined(__clang__) 25 #define CEED_QFUNCTION_ATTR __attribute__((flatten)) 26 #elif defined(__INTEL_COMPILER) 27 #define CEED_QFUNCTION_ATTR _Pragma("forceinline") 28 #else 29 #define CEED_QFUNCTION_ATTR 30 #endif 31 #else 32 #define CEED_QFUNCTION_ATTR 33 #endif 34 #if defined(__GNUC__) || defined(__clang__) 35 #define CEED_QFUNCTION_HELPER_ATTR CEED_QFUNCTION_ATTR __attribute__((always_inline)) 36 #else 37 #define CEED_QFUNCTION_HELPER_ATTR CEED_QFUNCTION_ATTR 38 #endif 39 #endif 40 41 /** 42 @ingroup CeedQFunction 43 This macro populates the correct function annotations for User QFunction source for code generation backends or populates default values for CPU 44 backends. It also creates a variable `name_loc` populated with the correct source path for creating the respective User QFunction. 45 **/ 46 #ifndef CEED_QFUNCTION 47 #define CEED_QFUNCTION(name) \ 48 static const char name##_loc[] = __FILE__ ":" #name; \ 49 CEED_QFUNCTION_ATTR static int name 50 #endif 51 52 /** 53 @ingroup CeedQFunction 54 This macro populates the correct function annotations for User QFunction helper function source for code generation backends or populates default 55 values for CPU backends. 56 **/ 57 #ifndef CEED_QFUNCTION_HELPER 58 #define CEED_QFUNCTION_HELPER CEED_QFUNCTION_HELPER_ATTR static inline 59 #endif 60 61 /** 62 @ingroup CeedQFunction 63 Using VLA syntax to reshape User QFunction inputs and outputs can make user code more readable. 64 VLA is a C99 feature that is not supported by the C++ dialect used by CUDA. 65 This macro allows users to use the VLA syntax with the CUDA backends. 66 **/ 67 #ifndef CEED_Q_VLA 68 #define CEED_Q_VLA Q 69 #endif 70 71 /** 72 @ingroup Ceed 73 This macro provides the appropriate SIMD Pragma for the compilation environment. 74 Code generation backends may redefine this macro, as needed. 75 **/ 76 #ifndef CeedPragmaSIMD 77 #if defined(__INTEL_COMPILER) 78 #define CeedPragmaSIMD _Pragma("vector") 79 /// Cannot use Intel pragma ivdep because it miscompiles unpacking symmetric tensors, as in Poisson2DApply, where the SIMD loop body contains 80 /// temporaries such as the following. 81 /// 82 /// const CeedScalar dXdxdXdxT[2][2] = {{qd[i+0*Q], qd[i+2*Q]}, 83 /// {qd[i+2*Q], qd[i+1*Q]}}; 84 /// for (int j=0; j<2; j++) 85 /// vg[i+j*Q] = (du[0] * dXdxdXdxT[0][j] + du[1] * dXdxdXdxT[1][j]); 86 /// 87 /// Miscompilation with pragma ivdep observed with icc (ICC) 19.0.5.281 20190815 at -O2 and above. 88 #elif defined(__GNUC__) && __GNUC__ >= 5 89 #define CeedPragmaSIMD _Pragma("GCC ivdep") 90 #elif defined(_OPENMP) && _OPENMP >= 201307 // OpenMP-4.0 (July, 2013) 91 #define CeedPragmaSIMD _Pragma("omp simd") 92 #else 93 #define CeedPragmaSIMD 94 #endif 95 #endif 96 97 /// Integer type, used for indexing 98 /// @ingroup Ceed 99 typedef int32_t CeedInt; 100 #define CeedInt_FMT "d" 101 102 /// Integer type, used array sizes 103 /// @ingroup Ceed 104 typedef ptrdiff_t CeedSize; 105 #define CeedSize_FMT "td" 106 107 /// Scalar (floating point) types 108 /// 109 /// @ingroup Ceed 110 typedef enum { 111 /// Single precision 112 CEED_SCALAR_FP32, 113 /// Double precision 114 CEED_SCALAR_FP64 115 } CeedScalarType; 116 /// Base scalar type for the library to use: change which header is included to change the precision. 117 #include "ceed-f64.h" // IWYU pragma: export 118 119 /// Ceed error code. 120 /// 121 /// This enum is used to specify the type of error returned by a function. 122 /// A zero error code is success, negative error codes indicate terminal errors and positive error codes indicate nonterminal errors. 123 /// With nonterminal errors the object state has not been modified, but with terminal errors the object data is likely modified or corrupted. 124 /// @ingroup Ceed 125 typedef enum { 126 /// Success error code 127 CEED_ERROR_SUCCESS = 0, 128 /// Minor error, generic 129 CEED_ERROR_MINOR = 1, 130 /// Minor error, dimension mismatch in inputs 131 CEED_ERROR_DIMENSION = 2, 132 /// Minor error, incomplete object setup 133 CEED_ERROR_INCOMPLETE = 3, 134 /// Minor error, incompatible arguments/configuration 135 CEED_ERROR_INCOMPATIBLE = 4, 136 /// Minor error, access lock problem 137 CEED_ERROR_ACCESS = 5, 138 /// Major error, generic 139 CEED_ERROR_MAJOR = -1, 140 /// Major error, internal backend error 141 CEED_ERROR_BACKEND = -2, 142 /// Major error, operation unsupported by current backend 143 CEED_ERROR_UNSUPPORTED = -3, 144 } CeedErrorType; 145 146 /// Specify memory type. 147 /// Many Ceed interfaces take or return pointers to memory. 148 /// This enum is used to specify where the memory being provided or requested must reside. 149 /// @ingroup Ceed 150 typedef enum { 151 /// Memory resides on the host 152 CEED_MEM_HOST, 153 /// Memory resides on a device (corresponding to \ref Ceed resource) 154 CEED_MEM_DEVICE, 155 } CeedMemType; 156 157 /// Conveys ownership status of arrays passed to Ceed interfaces. 158 /// @ingroup Ceed 159 typedef enum { 160 /// Implementation will copy the values and not store the passed pointer. 161 CEED_COPY_VALUES, 162 /// Implementation can use and modify the data provided by the user, but does not take ownership. 163 CEED_USE_POINTER, 164 /// Implementation takes ownership of the pointer and will free using CeedFree() when done using it. 165 /// The user should not assume that the pointer remains valid after ownership has been transferred. 166 /// Note that arrays allocated using C++ operator new or other allocators cannot generally be freed using CeedFree(). 167 /// CeedFree() is capable of freeing any memory that can be freed using free(). 168 CEED_OWN_POINTER, 169 } CeedCopyMode; 170 171 /// Denotes type of vector norm to be computed 172 /// @ingroup CeedVector 173 typedef enum { 174 /// \f$\Vert \bm{x}\Vert_1 = \sum_i \vert x_i\vert\f$ 175 CEED_NORM_1, 176 /// \f$\Vert \bm{x} \Vert_2 = \sqrt{\sum_i x_i^2}\f$ 177 CEED_NORM_2, 178 /// \f$\Vert \bm{x} \Vert_\infty = \max_i \vert x_i \vert\f$ 179 CEED_NORM_MAX, 180 } CeedNormType; 181 182 /// Denotes whether a linear transformation or its transpose should be applied 183 /// @ingroup CeedBasis 184 typedef enum { 185 /// Apply the linear transformation 186 CEED_NOTRANSPOSE, 187 /// Apply the transpose 188 CEED_TRANSPOSE 189 } CeedTransposeMode; 190 191 /// Basis evaluation mode 192 /// @ingroup CeedBasis 193 typedef enum { 194 /// Perform no evaluation (either because there is no data or it is already at quadrature points) 195 CEED_EVAL_NONE = 0, 196 /// Interpolate from nodes to quadrature points 197 CEED_EVAL_INTERP = 1, 198 /// Evaluate gradients at quadrature points from input in the basis 199 CEED_EVAL_GRAD = 2, 200 /// Evaluate divergence at quadrature points from input in the basis 201 CEED_EVAL_DIV = 4, 202 /// Evaluate curl at quadrature points from input in the basis 203 CEED_EVAL_CURL = 8, 204 /// Using no input, evaluate quadrature weights on the reference element 205 CEED_EVAL_WEIGHT = 16, 206 } CeedEvalMode; 207 208 /// Type of quadrature; also used for location of nodes 209 /// @ingroup CeedBasis 210 typedef enum { 211 /// Gauss-Legendre quadrature 212 CEED_GAUSS = 0, 213 /// Gauss-Legendre-Lobatto quadrature 214 CEED_GAUSS_LOBATTO = 1, 215 } CeedQuadMode; 216 217 /// Type of basis shape to create non-tensor element basis. 218 /// Dimension can be extracted with bitwise AND (CeedElemTopology & 2**(dim + 2)) == TRUE 219 /// @ingroup CeedBasis 220 typedef enum { 221 /// Line 222 CEED_TOPOLOGY_LINE = 1 << 16 | 0, 223 /// Triangle - 2D shape 224 CEED_TOPOLOGY_TRIANGLE = 2 << 16 | 1, 225 /// Quadralateral - 2D shape 226 CEED_TOPOLOGY_QUAD = 2 << 16 | 2, 227 /// Tetrahedron - 3D shape 228 CEED_TOPOLOGY_TET = 3 << 16 | 3, 229 /// Pyramid - 3D shape 230 CEED_TOPOLOGY_PYRAMID = 3 << 16 | 4, 231 /// Prism - 3D shape 232 CEED_TOPOLOGY_PRISM = 3 << 16 | 5, 233 /// Hexehedron - 3D shape 234 CEED_TOPOLOGY_HEX = 3 << 16 | 6, 235 } CeedElemTopology; 236 237 /// Denotes type of data stored in a CeedQFunctionContext field 238 /// @ingroup CeedQFunction 239 typedef enum { 240 /// Double precision value 241 CEED_CONTEXT_FIELD_DOUBLE = 1, 242 /// 32 bit integer value 243 CEED_CONTEXT_FIELD_INT32 = 2, 244 } CeedContextFieldType; 245 246 #endif 247