diff --git a/interface/ceed-fortran.c b/interface/ceed-fortran.c index af3ba24a8c..fd09fe5ad2 100644 --- a/interface/ceed-fortran.c +++ b/interface/ceed-fortran.c @@ -25,10 +25,36 @@ #define FORTRAN_BASIS_NONE -8 #define FORTRAN_QFUNCTION_NONE -9 -static Ceed *Ceed_dict = NULL; -static int Ceed_count = 0; -static int Ceed_n = 0; -static int Ceed_count_max = 0; +static CeedRequest *CeedRequest_dict = NULL; +static int max_CeedRequest = 0; +static int num_CeedRequest = 0; +static int num_active_CeedRequest = 0; + +static inline void fCeedRequestExpandDict(void) { + max_CeedRequest += max_CeedRequest / 2 + 1; + CeedRealloc(max_CeedRequest, &CeedRequest_dict); +} + +static inline void fCeedRequestAccept(int *request) { + *request = num_CeedRequest; + num_CeedRequest++; + num_active_CeedRequest++; +} + +#define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) +CEED_EXTERN void fCeedRequestWait(int *request, int *err) { + // TODO Uncomment this once CeedRequestWait is implemented + //*err = CeedRequestWait(&CeedRequest_dict[*request]); + + if (*err == 0) { + num_active_CeedRequest--; + if (num_active_CeedRequest == 0) { + CeedFree(&CeedRequest_dict); + num_CeedRequest = 0; + max_CeedRequest = 0; + } + } +} // This test should actually be for the gfortran version, but we don't currently // have a configure system to determine that (TODO). At present, this will use @@ -60,21 +86,28 @@ typedef int fortran_charlen_t; // ----------------------------------------------------------------------------- // Ceed // ----------------------------------------------------------------------------- +static Ceed *Ceed_dict = NULL; +static int max_Ceed = 0; +static int num_Ceed = 0; +static int num_active_Ceed = 0; + +static inline void fCeedExpandDict(void) { + max_Ceed += max_Ceed / 2 + 1; + CeedRealloc(max_Ceed, &Ceed_dict); +} + +static inline void fCeedAccept(int *ceed) { + *ceed = num_Ceed; + num_Ceed++; + num_active_Ceed++; +} + #define fCeedInit FORTRAN_NAME(ceedinit, CEEDINIT) CEED_EXTERN void fCeedInit(const char *resource, int *ceed, int *err, fortran_charlen_t resource_len) { FIX_STRING(resource); - if (Ceed_count == Ceed_count_max) { - Ceed_count_max += Ceed_count_max / 2 + 1; - CeedRealloc(Ceed_count_max, &Ceed_dict); - } - - Ceed *ceed_ = &Ceed_dict[Ceed_count]; - *err = CeedInit(resource_c, ceed_); - - if (*err == 0) { - *ceed = Ceed_count++; - Ceed_n++; - } + if (num_Ceed == max_Ceed) fCeedExpandDict(); + *err = CeedInit(resource_c, &Ceed_dict[num_Ceed]); + if (*err == 0) fCeedAccept(ceed); } #define fCeedIsDeterministic FORTRAN_NAME(ceedisdeterministic, CEEDISDETERMINISTIC) @@ -98,11 +131,11 @@ CEED_EXTERN void fCeedDestroy(int *ceed, int *err) { if (*err == 0) { *ceed = FORTRAN_NULL; - Ceed_n--; - if (Ceed_n == 0) { + num_active_Ceed--; + if (num_active_Ceed == 0) { CeedFree(&Ceed_dict); - Ceed_count = 0; - Ceed_count_max = 0; + num_Ceed = 0; + max_Ceed = 0; } } } @@ -110,75 +143,80 @@ CEED_EXTERN void fCeedDestroy(int *ceed, int *err) { // ----------------------------------------------------------------------------- // CeedVector // ----------------------------------------------------------------------------- -static CeedVector *CeedVector_dict = NULL; -static int CeedVector_count = 0; -static int CeedVector_n = 0; -static int CeedVector_count_max = 0; +static CeedVector *CeedVector_dict = NULL; +static int max_CeedVector = 0; +static int num_CeedVector = 0; +static int num_active_CeedVector = 0; -#define fCeedVectorCreate FORTRAN_NAME(ceedvectorcreate, CEEDVECTORCREATE) -CEED_EXTERN void fCeedVectorCreate(int *ceed, int *length, int *vec, int *err) { - if (CeedVector_count == CeedVector_count_max) { - CeedVector_count_max += CeedVector_count_max / 2 + 1; - CeedRealloc(CeedVector_count_max, &CeedVector_dict); - } +static inline void fCeedVectorExpandDict(void) { + max_CeedVector += max_CeedVector / 2 + 1; + CeedRealloc(max_CeedVector, &CeedVector_dict); +} - CeedVector *vec_ = &CeedVector_dict[CeedVector_count]; - *err = CeedVectorCreate(Ceed_dict[*ceed], *length, vec_); +static inline void fCeedVectorAccept(int *vec) { + *vec = num_CeedVector; + num_CeedVector++; + num_active_CeedVector++; +} - if (*err == 0) { - *vec = CeedVector_count++; - CeedVector_n++; - } +#define fCeedVectorCreate FORTRAN_NAME(ceedvectorcreate, CEEDVECTORCREATE) +CEED_EXTERN void fCeedVectorCreate(int *ceed, int *length, int *vec, int *err) { + if (num_CeedVector == max_CeedVector) fCeedVectorExpandDict(); + *err = CeedVectorCreate(Ceed_dict[*ceed], *length, &CeedVector_dict[num_CeedVector]); + if (*err == 0) fCeedVectorAccept(vec); } #define fCeedVectorSetArray FORTRAN_NAME(ceedvectorsetarray, CEEDVECTORSETARRAY) -CEED_EXTERN void fCeedVectorSetArray(int *vec, int *memtype, int *copymode, CeedScalar *array, int64_t *offset, int *err) { - *err = CeedVectorSetArray(CeedVector_dict[*vec], (CeedMemType)*memtype, (CeedCopyMode)*copymode, (CeedScalar *)(array + *offset)); +CEED_EXTERN void fCeedVectorSetArray(int *vec, int *mem_type, int *copy_mode, CeedScalar *array, int64_t *offset, int *err) { + *err = CeedVectorSetArray(CeedVector_dict[*vec], (CeedMemType)*mem_type, (CeedCopyMode)*copy_mode, (CeedScalar *)(array + *offset)); } #define fCeedVectorTakeArray FORTRAN_NAME(ceedvectortakearray, CEEDVECTORTAKEARRAY) -CEED_EXTERN void fCeedVectorTakeArray(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) { - CeedScalar *b; - CeedVector vec_ = CeedVector_dict[*vec]; - *err = CeedVectorTakeArray(vec_, (CeedMemType)*memtype, &b); - *offset = b - array; +CEED_EXTERN void fCeedVectorTakeArray(int *vec, int *mem_type, CeedScalar *array, int64_t *offset, int *err) { + CeedScalar *array_c; + + *err = CeedVectorTakeArray(CeedVector_dict[*vec], (CeedMemType)*mem_type, &array_c); + *offset = array_c - array; } #define fCeedVectorSyncArray FORTRAN_NAME(ceedvectorsyncarray, CEEDVECTORSYNCARRAY) -CEED_EXTERN void fCeedVectorSyncArray(int *vec, int *memtype, int *err) { *err = CeedVectorSyncArray(CeedVector_dict[*vec], (CeedMemType)*memtype); } +CEED_EXTERN void fCeedVectorSyncArray(int *vec, int *mem_type, int *err) { + *err = CeedVectorSyncArray(CeedVector_dict[*vec], (CeedMemType)*mem_type); +} #define fCeedVectorSetValue FORTRAN_NAME(ceedvectorsetvalue, CEEDVECTORSETVALUE) CEED_EXTERN void fCeedVectorSetValue(int *vec, CeedScalar *value, int *err) { *err = CeedVectorSetValue(CeedVector_dict[*vec], *value); } #define fCeedVectorGetArray FORTRAN_NAME(ceedvectorgetarray, CEEDVECTORGETARRAY) -CEED_EXTERN void fCeedVectorGetArray(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) { - CeedScalar *b; - CeedVector vec_ = CeedVector_dict[*vec]; - *err = CeedVectorGetArray(vec_, (CeedMemType)*memtype, &b); - *offset = b - array; +CEED_EXTERN void fCeedVectorGetArray(int *vec, int *mem_type, CeedScalar *array, int64_t *offset, int *err) { + CeedScalar *array_c; + + *err = CeedVectorGetArray(CeedVector_dict[*vec], (CeedMemType)*mem_type, &array_c); + *offset = array_c - array; } #define fCeedVectorGetArrayRead FORTRAN_NAME(ceedvectorgetarrayread, CEEDVECTORGETARRAYREAD) -CEED_EXTERN void fCeedVectorGetArrayRead(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) { - const CeedScalar *b; - CeedVector vec_ = CeedVector_dict[*vec]; - *err = CeedVectorGetArrayRead(vec_, (CeedMemType)*memtype, &b); - *offset = b - array; +CEED_EXTERN void fCeedVectorGetArrayRead(int *vec, int *mem_type, CeedScalar *array, int64_t *offset, int *err) { + const CeedScalar *array_c; + + *err = CeedVectorGetArrayRead(CeedVector_dict[*vec], (CeedMemType)*mem_type, &array_c); + *offset = array_c - array; } #define fCeedVectorGetArrayWrite FORTRAN_NAME(ceedvectorgetarraywrite, CEEDVECTORGETARRAYWRITE) -CEED_EXTERN void fCeedVectorGetArrayWrite(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) { - CeedScalar *b; - CeedVector vec_ = CeedVector_dict[*vec]; - *err = CeedVectorGetArrayWrite(vec_, (CeedMemType)*memtype, &b); - *offset = b - array; +CEED_EXTERN void fCeedVectorGetArrayWrite(int *vec, int *mem_type, CeedScalar *array, int64_t *offset, int *err) { + CeedScalar *array_c; + + *err = CeedVectorGetArrayWrite(CeedVector_dict[*vec], (CeedMemType)*mem_type, &array_c); + *offset = array_c - array; } #define fCeedVectorRestoreArray FORTRAN_NAME(ceedvectorrestorearray, CEEDVECTORRESTOREARRAY) CEED_EXTERN void fCeedVectorRestoreArray(int *vec, CeedScalar *array, int64_t *offset, int *err) { - CeedScalar *offsetArray = array + *offset; - *err = CeedVectorRestoreArray(CeedVector_dict[*vec], &offsetArray); - *offset = 0; + CeedScalar *array_offset = array + *offset; + + *err = CeedVectorRestoreArray(CeedVector_dict[*vec], &array_offset); + *offset = 0; } #define fCeedVectorRestoreArrayRead FORTRAN_NAME(ceedvectorrestorearrayread, CEEDVECTORRESTOREARRAYREAD) @@ -188,8 +226,8 @@ CEED_EXTERN void fCeedVectorRestoreArrayRead(int *vec, const CeedScalar *array, } #define fCeedVectorNorm FORTRAN_NAME(ceedvectornorm, CEEDVECTORNORM) -CEED_EXTERN void fCeedVectorNorm(int *vec, int *type, CeedScalar *norm, int *err) { - *err = CeedVectorNorm(CeedVector_dict[*vec], (CeedNormType)*type, norm); +CEED_EXTERN void fCeedVectorNorm(int *vec, int *norm_type, CeedScalar *norm, int *err) { + *err = CeedVectorNorm(CeedVector_dict[*vec], (CeedNormType)*norm_type, norm); } #define fCeedVectorReciprocal FORTRAN_NAME(ceedvectorreciprocal, CEEDVECTORRECIPROCAL) @@ -208,11 +246,11 @@ CEED_EXTERN void fCeedVectorDestroy(int *vec, int *err) { if (*err == 0) { *vec = FORTRAN_NULL; - CeedVector_n--; - if (CeedVector_n == 0) { + num_active_CeedVector--; + if (num_active_CeedVector == 0) { CeedFree(&CeedVector_dict); - CeedVector_count = 0; - CeedVector_count_max = 0; + num_CeedVector = 0; + max_CeedVector = 0; } } } @@ -220,284 +258,203 @@ CEED_EXTERN void fCeedVectorDestroy(int *vec, int *err) { // ----------------------------------------------------------------------------- // CeedElemRestriction // ----------------------------------------------------------------------------- -static CeedElemRestriction *CeedElemRestriction_dict = NULL; -static int CeedElemRestriction_count = 0; -static int CeedElemRestriction_n = 0; -static int CeedElemRestriction_count_max = 0; +static CeedElemRestriction *CeedElemRestriction_dict = NULL; +static int max_CeedElemRestriction = 0; +static int num_CeedElemRestriction = 0; +static int num_active_CeedElemRestriction = 0; -#define fCeedElemRestrictionCreate FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE) -CEED_EXTERN void fCeedElemRestrictionCreate(int *ceed, int *nelements, int *esize, int *num_comp, int *comp_stride, int *lsize, int *memtype, - int *copymode, const int *offsets, int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } +static inline void fCeedElemRestrictionExpandDict(void) { + max_CeedElemRestriction += max_CeedElemRestriction / 2 + 1; + CeedRealloc(max_CeedElemRestriction, &CeedElemRestriction_dict); +} - const int *offsets_ = offsets; +static inline void fCeedElemRestrictionAccept(int *rstr) { + *rstr = num_CeedElemRestriction; + num_CeedElemRestriction++; + num_active_CeedElemRestriction++; +} - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype, - (CeedCopyMode)*copymode, offsets_, elemrestriction_); +#define fCeedElemRestrictionCreate FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE) +CEED_EXTERN void fCeedElemRestrictionCreate(int *ceed, int *num_elem, int *elem_size, int *num_comp, int *comp_stride, int *l_vec_size, int *mem_type, + int *copy_mode, const int *offsets, int *rstr, int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } + const int *offsets_c = offsets; + + *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *num_elem, *elem_size, *num_comp, *comp_stride, *l_vec_size, (CeedMemType)*mem_type, + (CeedCopyMode)*copy_mode, offsets_c, &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } #define fCeedElemRestrictionCreateOriented FORTRAN_NAME(ceedelemrestrictioncreateoriented, CEEDELEMRESTRICTIONCREATEORIENTED) -CEED_EXTERN void fCeedElemRestrictionCreateOriented(int *ceed, int *nelements, int *esize, int *num_comp, int *comp_stride, int *lsize, int *memtype, - int *copymode, const int *offsets, const bool *orients, int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } +CEED_EXTERN void fCeedElemRestrictionCreateOriented(int *ceed, int *num_elem, int *elem_size, int *num_comp, int *comp_stride, int *l_vec_size, + int *mem_type, int *copy_mode, const int *offsets, const bool *orients, int *rstr, int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); - const int *offsets_ = offsets; - const bool *orients_ = orients; + const int *offsets_c = offsets; + const bool *orients_c = orients; - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreateOriented(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype, - (CeedCopyMode)*copymode, offsets_, orients_, elemrestriction_); - - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } + *err = CeedElemRestrictionCreateOriented(Ceed_dict[*ceed], *num_elem, *elem_size, *num_comp, *comp_stride, *l_vec_size, (CeedMemType)*mem_type, + (CeedCopyMode)*copy_mode, offsets_c, orients_c, &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } #define fCeedElemRestrictionCreateCurlOriented FORTRAN_NAME(ceedelemrestrictioncreatecurloriented, CEEDELEMRESTRICTIONCREATECURLORIENTED) -CEED_EXTERN void fCeedElemRestrictionCreateCurlOriented(int *ceed, int *nelements, int *esize, int *num_comp, int *comp_stride, int *lsize, - int *memtype, int *copymode, const int *offsets, const int8_t *curlorients, - int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } - - const int *offsets_ = offsets; - const int8_t *curlorients_ = curlorients; +CEED_EXTERN void fCeedElemRestrictionCreateCurlOriented(int *ceed, int *num_elem, int *elem_size, int *num_comp, int *comp_stride, int *l_vec_size, + int *mem_type, int *copy_mode, const int *offsets, const int8_t *curl_orients, int *rstr, + int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreateCurlOriented(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype, - (CeedCopyMode)*copymode, offsets_, curlorients_, elemrestriction_); + const int *offsets_c = offsets; + const int8_t *curl_orients_c = curl_orients; - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } + *err = + CeedElemRestrictionCreateCurlOriented(Ceed_dict[*ceed], *num_elem, *elem_size, *num_comp, *comp_stride, *l_vec_size, (CeedMemType)*mem_type, + (CeedCopyMode)*copy_mode, offsets_c, curl_orients_c, &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } #define fCeedElemRestrictionCreateStrided FORTRAN_NAME(ceedelemrestrictioncreatestrided, CEEDELEMRESTRICTIONCREATESTRIDED) -CEED_EXTERN void fCeedElemRestrictionCreateStrided(int *ceed, int *nelements, int *esize, int *num_comp, int *lsize, int *strides, - int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } - - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreateStrided(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *lsize, - *strides == FORTRAN_STRIDES_BACKEND ? CEED_STRIDES_BACKEND : strides, elemrestriction_); - - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } +CEED_EXTERN void fCeedElemRestrictionCreateStrided(int *ceed, int *num_elem, int *elem_size, int *num_comp, int *l_vec_size, int *strides, int *rstr, + int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); + *err = CeedElemRestrictionCreateStrided(Ceed_dict[*ceed], *num_elem, *elem_size, *num_comp, *l_vec_size, + *strides == FORTRAN_STRIDES_BACKEND ? CEED_STRIDES_BACKEND : strides, + &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } #define fCeedElemRestrictionCreateBlocked FORTRAN_NAME(ceedelemrestrictioncreateblocked, CEEDELEMRESTRICTIONCREATEBLOCKED) -CEED_EXTERN void fCeedElemRestrictionCreateBlocked(int *ceed, int *nelements, int *esize, int *blocksize, int *num_comp, int *comp_stride, int *lsize, - int *memtype, int *copymode, const int *offsets, int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } +CEED_EXTERN void fCeedElemRestrictionCreateBlocked(int *ceed, int *num_elem, int *elem_size, int *block_size, int *num_comp, int *comp_stride, + int *l_vec_size, int *mem_type, int *copy_mode, const int *offsets, int *rstr, int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); - const int *offsets_ = offsets; + const int *offsets_c = offsets; - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], *nelements, *esize, *blocksize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype, - (CeedCopyMode)*copymode, offsets_, elemrestriction_); - - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } + *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], *num_elem, *elem_size, *block_size, *num_comp, *comp_stride, *l_vec_size, + (CeedMemType)*mem_type, (CeedCopyMode)*copy_mode, offsets_c, + &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } #define fCeedElemRestrictionCreateBlockedOriented FORTRAN_NAME(ceedelemrestrictioncreateblockedoriented, CEEDELEMRESTRICTIONCREATEBLOCKEDORIENTED) -CEED_EXTERN void fCeedElemRestrictionCreateBlockedOriented(int *ceed, int *nelements, int *esize, int *blocksize, int *num_comp, int *comp_stride, - int *lsize, int *memtype, int *copymode, const int *offsets, const bool *orients, - int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } +CEED_EXTERN void fCeedElemRestrictionCreateBlockedOriented(int *ceed, int *num_elem, int *elem_size, int *block_size, int *num_comp, int *comp_stride, + int *l_vec_size, int *mem_type, int *copy_mode, const int *offsets, const bool *orients, + int *rstr, int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); - const int *offsets_ = offsets; - const bool *orients_ = orients; + const int *offsets_c = offsets; + const bool *orients_c = orients; - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreateBlockedOriented(Ceed_dict[*ceed], *nelements, *esize, *blocksize, *num_comp, *comp_stride, *lsize, - (CeedMemType)*memtype, (CeedCopyMode)*copymode, offsets_, orients_, elemrestriction_); - - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } + *err = CeedElemRestrictionCreateBlockedOriented(Ceed_dict[*ceed], *num_elem, *elem_size, *block_size, *num_comp, *comp_stride, *l_vec_size, + (CeedMemType)*mem_type, (CeedCopyMode)*copy_mode, offsets_c, orients_c, + &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } #define fCeedElemRestrictionCreateBlockedCurlOriented \ FORTRAN_NAME(ceedelemrestrictioncreateblockedcurloriented, CEEDELEMRESTRICTIONCREATEBLOCKEDCURLORIENTED) -CEED_EXTERN void fCeedElemRestrictionCreateBlockedCurlOriented(int *ceed, int *nelements, int *esize, int *blocksize, int *num_comp, int *comp_stride, - int *lsize, int *memtype, int *copymode, const int *offsets, const int8_t *curlorients, - int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } +CEED_EXTERN void fCeedElemRestrictionCreateBlockedCurlOriented(int *ceed, int *num_elem, int *elem_size, int *block_size, int *num_comp, + int *comp_stride, int *l_vec_size, int *mem_type, int *copy_mode, const int *offsets, + const int8_t *curl_orients, int *rstr, int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); - const int *offsets_ = offsets; - const int8_t *curlorients_ = curlorients; + const int *offsets_c = offsets; + const int8_t *curl_orients_c = curl_orients; - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreateBlockedCurlOriented(Ceed_dict[*ceed], *nelements, *esize, *blocksize, *num_comp, *comp_stride, *lsize, - (CeedMemType)*memtype, (CeedCopyMode)*copymode, offsets_, curlorients_, elemrestriction_); - - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } + *err = CeedElemRestrictionCreateBlockedCurlOriented(Ceed_dict[*ceed], *num_elem, *elem_size, *block_size, *num_comp, *comp_stride, *l_vec_size, + (CeedMemType)*mem_type, (CeedCopyMode)*copy_mode, offsets_c, curl_orients_c, + &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } #define fCeedElemRestrictionCreateBlockedStrided FORTRAN_NAME(ceedelemrestrictioncreateblockedstrided, CEEDELEMRESTRICTIONCREATEBLOCKEDSTRIDED) -CEED_EXTERN void fCeedElemRestrictionCreateBlockedStrided(int *ceed, int *nelements, int *esize, int *blk_size, int *num_comp, int *lsize, - int *strides, int *elemrestriction, int *err) { - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } - - CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; - *err = CeedElemRestrictionCreateBlockedStrided(Ceed_dict[*ceed], *nelements, *esize, *blk_size, *num_comp, *lsize, strides, elemrestriction_); - - if (*err == 0) { - *elemrestriction = CeedElemRestriction_count++; - CeedElemRestriction_n++; - } +CEED_EXTERN void fCeedElemRestrictionCreateBlockedStrided(int *ceed, int *num_elem, int *elem_size, int *block_size, int *num_comp, int *l_vec_size, + int *strides, int *rstr, int *err) { + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); + *err = CeedElemRestrictionCreateBlockedStrided(Ceed_dict[*ceed], *num_elem, *elem_size, *block_size, *num_comp, *l_vec_size, strides, + &CeedElemRestriction_dict[num_CeedElemRestriction]); + if (*err == 0) fCeedElemRestrictionAccept(rstr); } -static CeedRequest *CeedRequest_dict = NULL; -static int CeedRequest_count = 0; -static int CeedRequest_n = 0; -static int CeedRequest_count_max = 0; - #define fCeedElemRestrictionApply FORTRAN_NAME(ceedelemrestrictionapply, CEEDELEMRESTRICTIONAPPLY) -CEED_EXTERN void fCeedElemRestrictionApply(int *elemr, int *tmode, int *uvec, int *ruvec, int *rqst, int *err) { - int createRequest = 1; +CEED_EXTERN void fCeedElemRestrictionApply(int *rstr, int *t_mode, int *u, int *ru, int *request, int *err) { + bool create_request = true; + // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) - if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) createRequest = 0; + if (*request == FORTRAN_REQUEST_IMMEDIATE || *request == FORTRAN_REQUEST_ORDERED) create_request = false; + if (create_request && num_CeedRequest == max_CeedRequest) fCeedRequestExpandDict(); - if (createRequest && CeedRequest_count == CeedRequest_count_max) { - CeedRequest_count_max += CeedRequest_count_max / 2 + 1; - CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); - } + CeedRequest *request_c; - CeedRequest *rqst_; - if (*rqst == FORTRAN_REQUEST_IMMEDIATE) { - rqst_ = CEED_REQUEST_IMMEDIATE; - } else if (*rqst == FORTRAN_REQUEST_ORDERED) { - rqst_ = CEED_REQUEST_ORDERED; + if (*request == FORTRAN_REQUEST_IMMEDIATE) { + request_c = CEED_REQUEST_IMMEDIATE; + } else if (*request == FORTRAN_REQUEST_ORDERED) { + request_c = CEED_REQUEST_ORDERED; } else { - rqst_ = &CeedRequest_dict[CeedRequest_count]; + request_c = &CeedRequest_dict[num_CeedRequest]; } - *err = - CeedElemRestrictionApply(CeedElemRestriction_dict[*elemr], (CeedTransposeMode)*tmode, CeedVector_dict[*uvec], CeedVector_dict[*ruvec], rqst_); - - if (*err == 0 && createRequest) { - *rqst = CeedRequest_count++; - CeedRequest_n++; - } + *err = CeedElemRestrictionApply(CeedElemRestriction_dict[*rstr], (CeedTransposeMode)*t_mode, CeedVector_dict[*u], CeedVector_dict[*ru], request_c); + if (*err == 0 && create_request) fCeedRequestAccept(request); } #define fCeedElemRestrictionApplyBlock FORTRAN_NAME(ceedelemrestrictionapplyblock, CEEDELEMRESTRICTIONAPPLYBLOCK) -CEED_EXTERN void fCeedElemRestrictionApplyBlock(int *elemr, int *block, int *tmode, int *uvec, int *ruvec, int *rqst, int *err) { - int createRequest = 1; +CEED_EXTERN void fCeedElemRestrictionApplyBlock(int *rstr, int *block, int *t_mode, int *u, int *ru, int *request, int *err) { + bool create_request = true; + // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) - if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) createRequest = 0; + if (*request == FORTRAN_REQUEST_IMMEDIATE || *request == FORTRAN_REQUEST_ORDERED) create_request = false; + if (create_request && num_CeedRequest == max_CeedRequest) fCeedRequestExpandDict(); - if (createRequest && CeedRequest_count == CeedRequest_count_max) { - CeedRequest_count_max += CeedRequest_count_max / 2 + 1; - CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); - } + CeedRequest *request_c; - CeedRequest *rqst_; - if (*rqst == FORTRAN_REQUEST_IMMEDIATE) { - rqst_ = CEED_REQUEST_IMMEDIATE; - } else if (*rqst == FORTRAN_REQUEST_ORDERED) { - rqst_ = CEED_REQUEST_ORDERED; + if (*request == FORTRAN_REQUEST_IMMEDIATE) { + request_c = CEED_REQUEST_IMMEDIATE; + } else if (*request == FORTRAN_REQUEST_ORDERED) { + request_c = CEED_REQUEST_ORDERED; } else { - rqst_ = &CeedRequest_dict[CeedRequest_count]; + request_c = &CeedRequest_dict[num_CeedRequest]; } - *err = CeedElemRestrictionApplyBlock(CeedElemRestriction_dict[*elemr], *block, (CeedTransposeMode)*tmode, CeedVector_dict[*uvec], - CeedVector_dict[*ruvec], rqst_); - - if (*err == 0 && createRequest) { - *rqst = CeedRequest_count++; - CeedRequest_n++; - } + *err = CeedElemRestrictionApplyBlock(CeedElemRestriction_dict[*rstr], *block, (CeedTransposeMode)*t_mode, CeedVector_dict[*u], CeedVector_dict[*ru], + request_c); + if (*err == 0 && create_request) fCeedRequestAccept(request); } #define fCeedElemRestrictionGetMultiplicity FORTRAN_NAME(ceedelemrestrictiongetmultiplicity, CEEDELEMRESTRICTIONGETMULTIPLICITY) -CEED_EXTERN void fCeedElemRestrictionGetMultiplicity(int *elemr, int *mult, int *err) { - *err = CeedElemRestrictionGetMultiplicity(CeedElemRestriction_dict[*elemr], CeedVector_dict[*mult]); +CEED_EXTERN void fCeedElemRestrictionGetMultiplicity(int *rstr, int *mult, int *err) { + *err = CeedElemRestrictionGetMultiplicity(CeedElemRestriction_dict[*rstr], CeedVector_dict[*mult]); } #define fCeedElemRestrictionGetELayout FORTRAN_NAME(ceedelemrestrictiongetelayout, CEEDELEMRESTRICTIONGETELAYOUT) -CEED_EXTERN void fCeedElemRestrictionGetELayout(int *elemr, int *layout, int *err) { +CEED_EXTERN void fCeedElemRestrictionGetELayout(int *rstr, int *layout, int *err) { CeedInt layout_c[3]; - *err = CeedElemRestrictionGetELayout(CeedElemRestriction_dict[*elemr], layout_c); + + *err = CeedElemRestrictionGetELayout(CeedElemRestriction_dict[*rstr], layout_c); for (int i = 0; i < 3; i++) layout[i] = layout_c[i]; } #define fCeedElemRestrictionSetNumViewTabs FORTRAN_NAME(ceedelemrestrictionsetnumviewtabs, CEEDELEMRESTRICTIONSETNUMVIEWTABS) -CEED_EXTERN void fCeedElemRestrictionSetNumViewTabs(int *elemr, int *num_tabs, int *err) { - *err = CeedElemRestrictionSetNumViewTabs(CeedElemRestriction_dict[*elemr], *num_tabs); +CEED_EXTERN void fCeedElemRestrictionSetNumViewTabs(int *rstr, int *num_tabs, int *err) { + *err = CeedElemRestrictionSetNumViewTabs(CeedElemRestriction_dict[*rstr], *num_tabs); } #define fCeedElemRestrictionView FORTRAN_NAME(ceedelemrestrictionview, CEEDELEMRESTRICTIONVIEW) -CEED_EXTERN void fCeedElemRestrictionView(int *elemr, int *err) { *err = CeedElemRestrictionView(CeedElemRestriction_dict[*elemr], stdout); } - -#define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) -CEED_EXTERN void fCeedRequestWait(int *rqst, int *err) { - // TODO Uncomment this once CeedRequestWait is implemented - //*err = CeedRequestWait(&CeedRequest_dict[*rqst]); - - if (*err == 0) { - CeedRequest_n--; - if (CeedRequest_n == 0) { - CeedFree(&CeedRequest_dict); - CeedRequest_count = 0; - CeedRequest_count_max = 0; - } - } -} +CEED_EXTERN void fCeedElemRestrictionView(int *rstr, int *err) { *err = CeedElemRestrictionView(CeedElemRestriction_dict[*rstr], stdout); } #define fCeedElemRestrictionDestroy FORTRAN_NAME(ceedelemrestrictiondestroy, CEEDELEMRESTRICTIONDESTROY) -CEED_EXTERN void fCeedElemRestrictionDestroy(int *elem, int *err) { - if (*elem == FORTRAN_NULL) return; - *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*elem]); +CEED_EXTERN void fCeedElemRestrictionDestroy(int *rstr, int *err) { + if (*rstr == FORTRAN_NULL) return; + *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*rstr]); if (*err == 0) { - *elem = FORTRAN_NULL; - CeedElemRestriction_n--; - if (CeedElemRestriction_n == 0) { + *rstr = FORTRAN_NULL; + num_active_CeedElemRestriction--; + if (num_active_CeedElemRestriction == 0) { CeedFree(&CeedElemRestriction_dict); - CeedElemRestriction_count = 0; - CeedElemRestriction_count_max = 0; + num_CeedElemRestriction = 0; + max_CeedElemRestriction = 0; } } } @@ -505,93 +462,64 @@ CEED_EXTERN void fCeedElemRestrictionDestroy(int *elem, int *err) { // ----------------------------------------------------------------------------- // CeedBasis // ----------------------------------------------------------------------------- -static CeedBasis *CeedBasis_dict = NULL; -static int CeedBasis_count = 0; -static int CeedBasis_n = 0; -static int CeedBasis_count_max = 0; +static CeedBasis *CeedBasis_dict = NULL; +static int max_CeedBasis = 0; +static int num_CeedBasis = 0; +static int num_active_CeedBasis = 0; -#define fCeedBasisCreateTensorH1Lagrange FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE) -CEED_EXTERN void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, int *num_comp, int *P, int *Q, int *quadmode, int *basis, int *err) { - if (CeedBasis_count == CeedBasis_count_max) { - CeedBasis_count_max += CeedBasis_count_max / 2 + 1; - CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); - } +static inline void fCeedBasisExpandDict(void) { + max_CeedBasis += max_CeedBasis / 2 + 1; + CeedRealloc(max_CeedBasis, &CeedBasis_dict); +} - *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *num_comp, *P, *Q, (CeedQuadMode)*quadmode, &CeedBasis_dict[CeedBasis_count]); +static inline void fCeedBasisAccept(int *basis) { + *basis = num_CeedBasis; + num_CeedBasis++; + num_active_CeedBasis++; +} - if (*err == 0) { - *basis = CeedBasis_count++; - CeedBasis_n++; - } +#define fCeedBasisCreateTensorH1Lagrange FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE) +CEED_EXTERN void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, int *num_comp, int *P, int *Q, int *quad_mode, int *basis, int *err) { + if (num_CeedBasis == max_CeedBasis) fCeedBasisExpandDict(); + *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *num_comp, *P, *Q, (CeedQuadMode)*quad_mode, &CeedBasis_dict[num_CeedBasis]); + if (*err == 0) fCeedBasisAccept(basis); } #define fCeedBasisCreateTensorH1 FORTRAN_NAME(ceedbasiscreatetensorh1, CEEDBASISCREATETENSORH1) CEED_EXTERN void fCeedBasisCreateTensorH1(int *ceed, int *dim, int *num_comp, int *P_1d, int *Q_1d, const CeedScalar *interp_1d, const CeedScalar *grad_1d, const CeedScalar *q_ref_1d, const CeedScalar *q_weight_1d, int *basis, int *err) { - if (CeedBasis_count == CeedBasis_count_max) { - CeedBasis_count_max += CeedBasis_count_max / 2 + 1; - CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); - } - + if (num_CeedBasis == max_CeedBasis) fCeedBasisExpandDict(); *err = CeedBasisCreateTensorH1(Ceed_dict[*ceed], *dim, *num_comp, *P_1d, *Q_1d, interp_1d, grad_1d, q_ref_1d, q_weight_1d, - &CeedBasis_dict[CeedBasis_count]); - - if (*err == 0) { - *basis = CeedBasis_count++; - CeedBasis_n++; - } + &CeedBasis_dict[num_CeedBasis]); + if (*err == 0) fCeedBasisAccept(basis); } #define fCeedBasisCreateH1 FORTRAN_NAME(ceedbasiscreateh1, CEEDBASISCREATEH1) -CEED_EXTERN void fCeedBasisCreateH1(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *grad, - const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) { - if (CeedBasis_count == CeedBasis_count_max) { - CeedBasis_count_max += CeedBasis_count_max / 2 + 1; - CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); - } - - *err = CeedBasisCreateH1(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, grad, qref, qweight, - &CeedBasis_dict[CeedBasis_count]); - - if (*err == 0) { - *basis = CeedBasis_count++; - CeedBasis_n++; - } +CEED_EXTERN void fCeedBasisCreateH1(int *ceed, int *topo, int *num_comp, int *num_nodes, int *num_qpts, const CeedScalar *interp, + const CeedScalar *grad, const CeedScalar *q_ref, const CeedScalar *q_weight, int *basis, int *err) { + if (num_CeedBasis == max_CeedBasis) fCeedBasisExpandDict(); + *err = CeedBasisCreateH1(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *num_nodes, *num_qpts, interp, grad, q_ref, q_weight, + &CeedBasis_dict[num_CeedBasis]); + if (*err == 0) fCeedBasisAccept(basis); } #define fCeedBasisCreateHdiv FORTRAN_NAME(ceedbasiscreatehdiv, CEEDBASISCREATEHDIV) -CEED_EXTERN void fCeedBasisCreateHdiv(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *div, - const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) { - if (CeedBasis_count == CeedBasis_count_max) { - CeedBasis_count_max += CeedBasis_count_max / 2 + 1; - CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); - } - - *err = CeedBasisCreateHdiv(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, div, qref, qweight, - &CeedBasis_dict[CeedBasis_count]); - - if (*err == 0) { - *basis = CeedBasis_count++; - CeedBasis_n++; - } +CEED_EXTERN void fCeedBasisCreateHdiv(int *ceed, int *topo, int *num_comp, int *num_nodes, int *num_qpts, const CeedScalar *interp, + const CeedScalar *div, const CeedScalar *q_ref, const CeedScalar *q_weight, int *basis, int *err) { + if (num_CeedBasis == max_CeedBasis) fCeedBasisExpandDict(); + *err = CeedBasisCreateHdiv(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *num_nodes, *num_qpts, interp, div, q_ref, q_weight, + &CeedBasis_dict[num_CeedBasis]); + if (*err == 0) fCeedBasisAccept(basis); } #define fCeedBasisCreateHcurl FORTRAN_NAME(ceedbasiscreatehcurl, CEEDBASISCREATEHCURL) -CEED_EXTERN void fCeedBasisCreateHcurl(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *curl, - const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) { - if (CeedBasis_count == CeedBasis_count_max) { - CeedBasis_count_max += CeedBasis_count_max / 2 + 1; - CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); - } - - *err = CeedBasisCreateHcurl(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, curl, qref, qweight, - &CeedBasis_dict[CeedBasis_count]); - - if (*err == 0) { - *basis = CeedBasis_count++; - CeedBasis_n++; - } +CEED_EXTERN void fCeedBasisCreateHcurl(int *ceed, int *topo, int *num_comp, int *num_nodes, int *num_qpts, const CeedScalar *interp, + const CeedScalar *curl, const CeedScalar *q_ref, const CeedScalar *q_weight, int *basis, int *err) { + if (num_CeedBasis == max_CeedBasis) fCeedBasisExpandDict(); + *err = CeedBasisCreateHcurl(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *num_nodes, *num_qpts, interp, curl, q_ref, q_weight, + &CeedBasis_dict[num_CeedBasis]); + if (*err == 0) fCeedBasisAccept(basis); } #define fCeedBasisSetNumViewTabs FORTRAN_NAME(ceedbasissetnumviewtabs, CEEDBASISSETNUMVIEWTABS) @@ -606,39 +534,41 @@ CEED_EXTERN void fCeedBasisGetCollocatedGrad(int *basis, CeedScalar *colo_grad_1 } #define fCeedBasisApply FORTRAN_NAME(ceedbasisapply, CEEDBASISAPPLY) -CEED_EXTERN void fCeedBasisApply(int *basis, int *num_elem, int *tmode, int *eval_mode, int *u, int *v, int *err) { - *err = CeedBasisApply(CeedBasis_dict[*basis], *num_elem, (CeedTransposeMode)*tmode, (CeedEvalMode)*eval_mode, +CEED_EXTERN void fCeedBasisApply(int *basis, int *num_elem, int *t_mode, int *eval_mode, int *u, int *v, int *err) { + *err = CeedBasisApply(CeedBasis_dict[*basis], *num_elem, (CeedTransposeMode)*t_mode, (CeedEvalMode)*eval_mode, *u == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*u], CeedVector_dict[*v]); } #define fCeedBasisGetNumNodes FORTRAN_NAME(ceedbasisgetnumnodes, CEEDBASISGETNUMNODES) -CEED_EXTERN void fCeedBasisGetNumNodes(int *basis, int *P, int *err) { *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], P); } +CEED_EXTERN void fCeedBasisGetNumNodes(int *basis, int *num_nodes, int *err) { *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], num_nodes); } #define fCeedBasisGetNumQuadraturePoints FORTRAN_NAME(ceedbasisgetnumquadraturepoints, CEEDBASISGETNUMQUADRATUREPOINTS) -CEED_EXTERN void fCeedBasisGetNumQuadraturePoints(int *basis, int *Q, int *err) { *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], Q); } +CEED_EXTERN void fCeedBasisGetNumQuadraturePoints(int *basis, int *num_q_pts, int *err) { + *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], num_q_pts); +} #define fCeedBasisGetInterp1D FORTRAN_NAME(ceedbasisgetinterp1d, CEEDBASISGETINTERP1D) CEED_EXTERN void fCeedBasisGetInterp1D(int *basis, CeedScalar *interp_1d, int64_t *offset, int *err) { - const CeedScalar *interp1d_; - CeedBasis basis_ = CeedBasis_dict[*basis]; - *err = CeedBasisGetInterp1D(basis_, &interp1d_); - *offset = interp1d_ - interp_1d; + const CeedScalar *interp_1d_c; + + *err = CeedBasisGetInterp1D(CeedBasis_dict[*basis], &interp_1d_c); + *offset = interp_1d_c - interp_1d; } #define fCeedBasisGetGrad1D FORTRAN_NAME(ceedbasisgetgrad1d, CEEDBASISGETGRAD1D) CEED_EXTERN void fCeedBasisGetGrad1D(int *basis, CeedScalar *grad_1d, int64_t *offset, int *err) { - const CeedScalar *grad1d_; - CeedBasis basis_ = CeedBasis_dict[*basis]; - *err = CeedBasisGetGrad1D(basis_, &grad1d_); - *offset = grad1d_ - grad_1d; + const CeedScalar *grad_1d_c; + + *err = CeedBasisGetGrad1D(CeedBasis_dict[*basis], &grad_1d_c); + *offset = grad_1d_c - grad_1d; } #define fCeedBasisGetQRef FORTRAN_NAME(ceedbasisgetqref, CEEDBASISGETQREF) CEED_EXTERN void fCeedBasisGetQRef(int *basis, CeedScalar *q_ref, int64_t *offset, int *err) { - const CeedScalar *qref_; - CeedBasis basis_ = CeedBasis_dict[*basis]; - *err = CeedBasisGetQRef(basis_, &qref_); - *offset = qref_ - q_ref; + const CeedScalar *q_ref_c; + + *err = CeedBasisGetQRef(CeedBasis_dict[*basis], &q_ref_c); + *offset = q_ref_c - q_ref; } #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy, CEEDBASISDESTROY) @@ -648,11 +578,11 @@ CEED_EXTERN void fCeedBasisDestroy(int *basis, int *err) { if (*err == 0) { *basis = FORTRAN_NULL; - CeedBasis_n--; - if (CeedBasis_n == 0) { + num_active_CeedBasis--; + if (num_active_CeedBasis == 0) { CeedFree(&CeedBasis_dict); - CeedBasis_count = 0; - CeedBasis_count_max = 0; + num_CeedBasis = 0; + max_CeedBasis = 0; } } } @@ -670,38 +600,42 @@ CEED_EXTERN void fCeedLobattoQuadrature(int *Q, CeedScalar *q_ref_1d, CeedScalar // ----------------------------------------------------------------------------- // CeedQFunctionContext // ----------------------------------------------------------------------------- -static CeedQFunctionContext *CeedQFunctionContext_dict = NULL; -static int CeedQFunctionContext_count = 0; -static int CeedQFunctionContext_n = 0; -static int CeedQFunctionContext_count_max = 0; +static CeedQFunctionContext *CeedQFunctionContext_dict = NULL; +static int max_CeedQFunctionContext = 0; +static int num_CeedQFunctionContext = 0; +static int num_active_CeedQFunctionContext = 0; -#define fCeedQFunctionContextCreate FORTRAN_NAME(ceedqfunctioncontextcreate, CEEDQFUNCTIONCONTEXTCREATE) -CEED_EXTERN void fCeedQFunctionContextCreate(int *ceed, int *ctx, int *err) { - if (CeedQFunctionContext_count == CeedQFunctionContext_count_max) { - CeedQFunctionContext_count_max += CeedQFunctionContext_count_max / 2 + 1; - CeedRealloc(CeedQFunctionContext_count_max, &CeedQFunctionContext_dict); - } +static inline void fCeedQFunctionContextExpandDict(void) { + max_CeedQFunctionContext += max_CeedQFunctionContext / 2 + 1; + CeedRealloc(max_CeedQFunctionContext, &CeedQFunctionContext_dict); +} - CeedQFunctionContext *ctx_ = &CeedQFunctionContext_dict[CeedQFunctionContext_count]; +static inline void fCeedQFunctionContextAccept(int *ctx) { + *ctx = num_CeedQFunctionContext; + num_CeedQFunctionContext++; + num_active_CeedQFunctionContext++; +} - *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], ctx_); - if (*err) return; - *ctx = CeedQFunctionContext_count++; - CeedQFunctionContext_n++; +#define fCeedQFunctionContextCreate FORTRAN_NAME(ceedqfunctioncontextcreate, CEEDQFUNCTIONCONTEXTCREATE) +CEED_EXTERN void fCeedQFunctionContextCreate(int *ceed, int *ctx, int *err) { + if (num_CeedQFunctionContext == max_CeedQFunctionContext) fCeedQFunctionContextExpandDict(); + *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], &CeedQFunctionContext_dict[num_CeedQFunctionContext]); + if (*err == 0) fCeedQFunctionContextAccept(ctx); } #define fCeedQFunctionContextSetData FORTRAN_NAME(ceedqfunctioncontextsetdata, CEEDQFUNCTIONCONTEXTSETDATA) -CEED_EXTERN void fCeedQFunctionContextSetData(int *ctx, int *memtype, int *copymode, CeedInt *n, CeedScalar *data, int64_t *offset, int *err) { +CEED_EXTERN void fCeedQFunctionContextSetData(int *ctx, int *mem_type, int *copy_mode, CeedInt *n, CeedScalar *data, int64_t *offset, int *err) { size_t ctx_size = ((size_t)*n) * sizeof(CeedScalar); - *err = CeedQFunctionContextSetData(CeedQFunctionContext_dict[*ctx], (CeedMemType)*memtype, (CeedCopyMode)*copymode, ctx_size, data + *offset); + + *err = CeedQFunctionContextSetData(CeedQFunctionContext_dict[*ctx], (CeedMemType)*mem_type, (CeedCopyMode)*copy_mode, ctx_size, data + *offset); } #define fCeedQFunctionContextGetData FORTRAN_NAME(ceedqfunctioncontextgetdata, CEEDQFUNCTIONCONTEXTGETDATA) -CEED_EXTERN void fCeedQFunctionContextGetData(int *ctx, int *memtype, CeedScalar *data, int64_t *offset, int *err) { - CeedScalar *b; - CeedQFunctionContext ctx_ = CeedQFunctionContext_dict[*ctx]; - *err = CeedQFunctionContextGetData(ctx_, (CeedMemType)*memtype, &b); - *offset = b - data; +CEED_EXTERN void fCeedQFunctionContextGetData(int *ctx, int *mem_type, CeedScalar *data, int64_t *offset, int *err) { + CeedScalar *data_c; + + *err = CeedQFunctionContextGetData(CeedQFunctionContext_dict[*ctx], (CeedMemType)*mem_type, &data_c); + *offset = data_c - data; } #define fCeedQFunctionContextRestoreData FORTRAN_NAME(ceedqfunctioncontextrestoredata, CEEDQFUNCTIONCONTEXTRESTOREDATA) @@ -725,11 +659,11 @@ CEED_EXTERN void fCeedQFunctionContextDestroy(int *ctx, int *err) { if (*err == 0) { *ctx = FORTRAN_NULL; - CeedQFunctionContext_n--; - if (CeedQFunctionContext_n == 0) { + num_active_CeedQFunctionContext--; + if (num_active_CeedQFunctionContext == 0) { CeedFree(&CeedQFunctionContext_dict); - CeedQFunctionContext_count = 0; - CeedQFunctionContext_count_max = 0; + num_CeedQFunctionContext = 0; + max_CeedQFunctionContext = 0; } } } @@ -737,143 +671,122 @@ CEED_EXTERN void fCeedQFunctionContextDestroy(int *ctx, int *err) { // ----------------------------------------------------------------------------- // CeedQFunction // ----------------------------------------------------------------------------- -static CeedQFunction *CeedQFunction_dict = NULL; -static int CeedQFunction_count = 0; -static int CeedQFunction_n = 0; -static int CeedQFunction_count_max = 0; - -static int CeedQFunctionFortranStub(void *ctx, int nq, const CeedScalar *const *u, CeedScalar *const *v) { - CeedFortranContext fctx = ctx; - CeedQFunctionContext inner_ctx = fctx->inner_ctx; +static CeedQFunction *CeedQFunction_dict = NULL; +static int num_CeedQFunction = 0; +static int num_active_CeedQFunction = 0; +static int max_CeedQFunction = 0; + +static inline void fCeedQFunctionExpandDict(void) { + max_CeedQFunction += max_CeedQFunction / 2 + 1; + CeedRealloc(max_CeedQFunction, &CeedQFunction_dict); +} + +static inline void fCeedQFunctionAccept(int *qf) { + *qf = num_CeedQFunction; + num_CeedQFunction++; + num_active_CeedQFunction++; +} + +// Note: Device backends are generating their own kernels from single source files, so only Host backends need to use this Fortran stub +static int CeedQFunctionFortranStub(void *ctx, int num_qpts, const CeedScalar *const *u, CeedScalar *const *v) { int ierr; + CeedFortranContext ctx_data = ctx; + CeedQFunctionContext inner_ctx = ctx_data->inner_ctx; + CeedScalar *ctx_f = NULL; - CeedScalar *ctx_ = NULL; - // Note: Device backends are generating their own kernels from - // single source files, so only Host backends need to - // use this Fortran stub. if (inner_ctx) { - ierr = CeedQFunctionContextGetData(inner_ctx, CEED_MEM_HOST, &ctx_); + ierr = CeedQFunctionContextGetData(inner_ctx, CEED_MEM_HOST, &ctx_f); CeedCall(ierr); } - - fctx->f((void *)ctx_, &nq, u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7], u[8], u[9], u[10], u[11], u[12], u[13], u[14], u[15], v[0], v[1], v[2], - v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15], &ierr); - + ctx_data->f((void *)ctx_f, &num_qpts, u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7], u[8], u[9], u[10], u[11], u[12], u[13], u[14], u[15], v[0], + v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15], &ierr); if (inner_ctx) { - ierr = CeedQFunctionContextRestoreData(inner_ctx, &ctx_); + ierr = CeedQFunctionContextRestoreData(inner_ctx, &ctx_f); CeedCall(ierr); } - return ierr; } #define fCeedQFunctionCreateInterior FORTRAN_NAME(ceedqfunctioncreateinterior, CEEDQFUNCTIONCREATEINTERIOR) CEED_EXTERN void fCeedQFunctionCreateInterior( int *ceed, int *vec_length, - void (*f)(void *ctx, int *nq, const CeedScalar *u, const CeedScalar *u1, const CeedScalar *u2, const CeedScalar *u3, const CeedScalar *u4, + void (*f)(void *ctx, int *num_qpts, const CeedScalar *u, const CeedScalar *u1, const CeedScalar *u2, const CeedScalar *u3, const CeedScalar *u4, const CeedScalar *u5, const CeedScalar *u6, const CeedScalar *u7, const CeedScalar *u8, const CeedScalar *u9, const CeedScalar *u10, const CeedScalar *u11, const CeedScalar *u12, const CeedScalar *u13, const CeedScalar *u14, const CeedScalar *u15, CeedScalar *v, CeedScalar *v1, CeedScalar *v2, CeedScalar *v3, CeedScalar *v4, CeedScalar *v5, CeedScalar *v6, CeedScalar *v7, CeedScalar *v8, CeedScalar *v9, CeedScalar *v10, CeedScalar *v11, CeedScalar *v12, CeedScalar *v13, CeedScalar *v14, CeedScalar *v15, int *err), const char *source, int *qf, int *err, fortran_charlen_t source_len) { FIX_STRING(source); - if (CeedQFunction_count == CeedQFunction_count_max) { - CeedQFunction_count_max += CeedQFunction_count_max / 2 + 1; - CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); - } + if (num_CeedQFunction == max_CeedQFunction) fCeedQFunctionExpandDict(); - CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; - *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vec_length, CeedQFunctionFortranStub, source_c, qf_); + CeedQFunction *qf_c = &CeedQFunction_dict[num_CeedQFunction]; - if (*err == 0) { - *qf = CeedQFunction_count++; - CeedQFunction_n++; - } + *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vec_length, CeedQFunctionFortranStub, source_c, qf_c); + if (*err == 0) fCeedQFunctionAccept(qf); + + CeedQFunctionContext ctx_c; + CeedFortranContext ctx_data; - CeedFortranContext fctxdata; - *err = CeedCalloc(1, &fctxdata); + *err = CeedCalloc(1, &ctx_data); if (*err) return; - fctxdata->f = f; - fctxdata->inner_ctx = NULL; - CeedQFunctionContext fctx; - *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], &fctx); + + ctx_data->f = f; + ctx_data->inner_ctx = NULL; + + *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], &ctx_c); if (*err) return; - *err = CeedQFunctionContextSetData(fctx, CEED_MEM_HOST, CEED_OWN_POINTER, sizeof(*fctxdata), fctxdata); + *err = CeedQFunctionContextSetData(ctx_c, CEED_MEM_HOST, CEED_OWN_POINTER, sizeof(*ctx_data), ctx_data); if (*err) return; - *err = CeedQFunctionSetContext(*qf_, fctx); + *err = CeedQFunctionSetContext(*qf_c, ctx_c); if (*err) return; - CeedQFunctionContextDestroy(&fctx); + CeedQFunctionContextDestroy(&ctx_c); if (*err) return; - - *err = CeedQFunctionSetFortranStatus(*qf_, true); + *err = CeedQFunctionSetFortranStatus(*qf_c, true); } #define fCeedQFunctionCreateInteriorByName FORTRAN_NAME(ceedqfunctioncreateinteriorbyname, CEEDQFUNCTIONCREATEINTERIORBYNAME) CEED_EXTERN void fCeedQFunctionCreateInteriorByName(int *ceed, const char *name, int *qf, int *err, fortran_charlen_t name_len) { FIX_STRING(name); - if (CeedQFunction_count == CeedQFunction_count_max) { - CeedQFunction_count_max += CeedQFunction_count_max / 2 + 1; - CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); - } - - CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; - *err = CeedQFunctionCreateInteriorByName(Ceed_dict[*ceed], name_c, qf_); - - if (*err == 0) { - *qf = CeedQFunction_count++; - CeedQFunction_n++; - } + if (num_CeedQFunction == max_CeedQFunction) fCeedQFunctionExpandDict(); + *err = CeedQFunctionCreateInteriorByName(Ceed_dict[*ceed], name_c, &CeedQFunction_dict[num_CeedQFunction]); + if (*err == 0) fCeedQFunctionAccept(qf); } #define fCeedQFunctionCreateIdentity FORTRAN_NAME(ceedqfunctioncreateidentity, CEEDQFUNCTIONCREATEIDENTITY) CEED_EXTERN void fCeedQFunctionCreateIdentity(int *ceed, int *size, int *inmode, int *outmode, int *qf, int *err) { - if (CeedQFunction_count == CeedQFunction_count_max) { - CeedQFunction_count_max += CeedQFunction_count_max / 2 + 1; - CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); - } - - CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; - *err = CeedQFunctionCreateIdentity(Ceed_dict[*ceed], *size, (CeedEvalMode)*inmode, (CeedEvalMode)*outmode, qf_); - - if (*err == 0) { - *qf = CeedQFunction_count++; - CeedQFunction_n++; - } + if (num_CeedQFunction == max_CeedQFunction) fCeedQFunctionExpandDict(); + *err = CeedQFunctionCreateIdentity(Ceed_dict[*ceed], *size, (CeedEvalMode)*inmode, (CeedEvalMode)*outmode, &CeedQFunction_dict[num_CeedQFunction]); + if (*err == 0) fCeedQFunctionAccept(qf); } #define fCeedQFunctionAddInput FORTRAN_NAME(ceedqfunctionaddinput, CEEDQFUNCTIONADDINPUT) CEED_EXTERN void fCeedQFunctionAddInput(int *qf, const char *field_name, CeedInt *num_comp, CeedEvalMode *eval_mode, int *err, fortran_charlen_t field_name_len) { FIX_STRING(field_name); - CeedQFunction qf_ = CeedQFunction_dict[*qf]; - - *err = CeedQFunctionAddInput(qf_, field_name_c, *num_comp, *eval_mode); + *err = CeedQFunctionAddInput(CeedQFunction_dict[*qf], field_name_c, *num_comp, *eval_mode); } #define fCeedQFunctionAddOutput FORTRAN_NAME(ceedqfunctionaddoutput, CEEDQFUNCTIONADDOUTPUT) CEED_EXTERN void fCeedQFunctionAddOutput(int *qf, const char *field_name, CeedInt *num_comp, CeedEvalMode *eval_mode, int *err, fortran_charlen_t field_name_len) { FIX_STRING(field_name); - CeedQFunction qf_ = CeedQFunction_dict[*qf]; - - *err = CeedQFunctionAddOutput(qf_, field_name_c, *num_comp, *eval_mode); + *err = CeedQFunctionAddOutput(CeedQFunction_dict[*qf], field_name_c, *num_comp, *eval_mode); } #define fCeedQFunctionSetContext FORTRAN_NAME(ceedqfunctionsetcontext, CEEDQFUNCTIONSETCONTEXT) CEED_EXTERN void fCeedQFunctionSetContext(int *qf, int *ctx, int *err) { - CeedQFunction qf_ = CeedQFunction_dict[*qf]; - CeedQFunctionContext ctx_ = CeedQFunctionContext_dict[*ctx]; + CeedQFunctionContext ctx_c; + CeedQFunctionContext ctx_f = CeedQFunctionContext_dict[*ctx]; + CeedFortranContext ctx_data; - CeedQFunctionContext fctx; - *err = CeedQFunctionGetContext(qf_, &fctx); + *err = CeedQFunctionGetContext(CeedQFunction_dict[*qf], &ctx_c); if (*err) return; - CeedFortranContext fctxdata; - *err = CeedQFunctionContextGetData(fctx, CEED_MEM_HOST, &fctxdata); + *err = CeedQFunctionContextGetData(ctx_c, CEED_MEM_HOST, &ctx_data); if (*err) return; - fctxdata->inner_ctx = ctx_; - *err = CeedQFunctionContextRestoreData(fctx, (void **)&fctxdata); + ctx_data->inner_ctx = ctx_f; + *err = CeedQFunctionContextRestoreData(ctx_c, (void **)&ctx_data); if (*err) return; - *err = CeedQFunctionContextDestroy(&fctx); + *err = CeedQFunctionContextDestroy(&ctx_c); } #define fCeedQFunctionSetNumViewTabs FORTRAN_NAME(ceedqfunctionsetnumviewtabs, CEEDQFUNCTIONSETNUMVIEWTABS) @@ -882,19 +795,16 @@ CEED_EXTERN void fCeedQFunctionSetNumViewTabs(int *qf, int *num_tabs, int *err) } #define fCeedQFunctionView FORTRAN_NAME(ceedqfunctionview, CEEDQFUNCTIONVIEW) -CEED_EXTERN void fCeedQFunctionView(int *qf, int *err) { - CeedQFunction qf_ = CeedQFunction_dict[*qf]; - - *err = CeedQFunctionView(qf_, stdout); -} +CEED_EXTERN void fCeedQFunctionView(int *qf, int *err) { *err = CeedQFunctionView(CeedQFunction_dict[*qf], stdout); } #define fCeedQFunctionApply FORTRAN_NAME(ceedqfunctionapply, CEEDQFUNCTIONAPPLY) // TODO Need Fixing, double pointer -CEED_EXTERN void fCeedQFunctionApply(int *qf, int *Q, int *u, int *u1, int *u2, int *u3, int *u4, int *u5, int *u6, int *u7, int *u8, int *u9, +CEED_EXTERN void fCeedQFunctionApply(int *qf, int *num_qpts, int *u, int *u1, int *u2, int *u3, int *u4, int *u5, int *u6, int *u7, int *u8, int *u9, int *u10, int *u11, int *u12, int *u13, int *u14, int *u15, int *v, int *v1, int *v2, int *v3, int *v4, int *v5, int *v6, int *v7, int *v8, int *v9, int *v10, int *v11, int *v12, int *v13, int *v14, int *v15, int *err) { - CeedQFunction qf_ = CeedQFunction_dict[*qf]; - CeedVector *in; + CeedVector *in; + CeedVector *out; + *err = CeedCalloc(CEED_FIELD_MAX, &in); if (*err) return; in[0] = *u == FORTRAN_NULL ? NULL : CeedVector_dict[*u]; @@ -913,7 +823,7 @@ CEED_EXTERN void fCeedQFunctionApply(int *qf, int *Q, int *u, int *u1, int *u2, in[13] = *u13 == FORTRAN_NULL ? NULL : CeedVector_dict[*u13]; in[14] = *u14 == FORTRAN_NULL ? NULL : CeedVector_dict[*u14]; in[15] = *u15 == FORTRAN_NULL ? NULL : CeedVector_dict[*u15]; - CeedVector *out; + *err = CeedCalloc(CEED_FIELD_MAX, &out); if (*err) return; out[0] = *v == FORTRAN_NULL ? NULL : CeedVector_dict[*v]; @@ -932,7 +842,8 @@ CEED_EXTERN void fCeedQFunctionApply(int *qf, int *Q, int *u, int *u1, int *u2, out[13] = *v13 == FORTRAN_NULL ? NULL : CeedVector_dict[*v13]; out[14] = *v14 == FORTRAN_NULL ? NULL : CeedVector_dict[*v14]; out[15] = *v15 == FORTRAN_NULL ? NULL : CeedVector_dict[*v15]; - *err = CeedQFunctionApply(qf_, *Q, in, out); + + *err = CeedQFunctionApply(CeedQFunction_dict[*qf], *num_qpts, in, out); if (*err) return; *err = CeedFree(&in); @@ -947,11 +858,11 @@ CEED_EXTERN void fCeedQFunctionDestroy(int *qf, int *err) { *err = CeedQFunctionDestroy(&CeedQFunction_dict[*qf]); if (*err == 0) { *qf = FORTRAN_NULL; - CeedQFunction_n--; - if (CeedQFunction_n == 0) { - *err = CeedFree(&CeedQFunction_dict); - CeedQFunction_count = 0; - CeedQFunction_count_max = 0; + num_active_CeedQFunction--; + if (num_active_CeedQFunction == 0) { + *err = CeedFree(&CeedQFunction_dict); + num_CeedQFunction = 0; + max_CeedQFunction = 0; } } } @@ -959,379 +870,293 @@ CEED_EXTERN void fCeedQFunctionDestroy(int *qf, int *err) { // ----------------------------------------------------------------------------- // CeedOperator // ----------------------------------------------------------------------------- -static CeedOperator *CeedOperator_dict = NULL; -static int CeedOperator_count = 0; -static int CeedOperator_n = 0; -static int CeedOperator_count_max = 0; +static CeedOperator *CeedOperator_dict = NULL; +static int num_CeedOperator = 0; +static int num_active_CeedOperator = 0; +static int max_CeedOperator = 0; + +static inline void fCeedOperatorExpandDict(void) { + max_CeedOperator += max_CeedOperator / 2 + 1; + CeedRealloc(max_CeedOperator, &CeedOperator_dict); +} + +static inline void fCeedOperatorAccept(int *op) { + *op = num_CeedOperator; + num_CeedOperator++; + num_active_CeedOperator++; +} #define fCeedOperatorCreate FORTRAN_NAME(ceedoperatorcreate, CEEDOPERATORCREATE) CEED_EXTERN void fCeedOperatorCreate(int *ceed, int *qf, int *dqf, int *dqfT, int *op, int *err) { - if (CeedOperator_count == CeedOperator_count_max) { - CeedOperator_count_max += CeedOperator_count_max / 2 + 1; - CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); - } + if (num_CeedOperator == max_CeedOperator) fCeedOperatorExpandDict(); - CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; + CeedQFunction dqf_c = CEED_QFUNCTION_NONE, dqfT_c = CEED_QFUNCTION_NONE; + if (*dqf != FORTRAN_QFUNCTION_NONE) dqf_c = CeedQFunction_dict[*dqf]; + if (*dqfT != FORTRAN_QFUNCTION_NONE) dqfT_c = CeedQFunction_dict[*dqfT]; - CeedQFunction dqf_ = CEED_QFUNCTION_NONE, dqfT_ = CEED_QFUNCTION_NONE; - if (*dqf != FORTRAN_QFUNCTION_NONE) dqf_ = CeedQFunction_dict[*dqf]; - if (*dqfT != FORTRAN_QFUNCTION_NONE) dqfT_ = CeedQFunction_dict[*dqfT]; - - *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_, dqfT_, op_); - if (*err) return; - *op = CeedOperator_count++; - CeedOperator_n++; + *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_c, dqfT_c, &CeedOperator_dict[num_CeedOperator]); + if (*err == 0) fCeedOperatorAccept(op); } #define fCeedOperatorCreateComposite FORTRAN_NAME(ceedoperatorcreatecomposite, CEEDOPERATORCREATECOMPOSITE) CEED_EXTERN void fCeedOperatorCreateComposite(int *ceed, int *op, int *err) { - if (CeedOperator_count == CeedOperator_count_max) { - CeedOperator_count_max += CeedOperator_count_max / 2 + 1; - CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); - } - - CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; - - *err = CeedOperatorCreateComposite(Ceed_dict[*ceed], op_); - if (*err) return; - *op = CeedOperator_count++; - CeedOperator_n++; + if (num_CeedOperator == max_CeedOperator) fCeedOperatorExpandDict(); + *err = CeedOperatorCreateComposite(Ceed_dict[*ceed], &CeedOperator_dict[num_CeedOperator]); + if (*err == 0) fCeedOperatorAccept(op); } #define fCeedOperatorSetField FORTRAN_NAME(ceedoperatorsetfield, CEEDOPERATORSETFIELD) -CEED_EXTERN void fCeedOperatorSetField(int *op, const char *field_name, int *r, int *b, int *v, int *err, fortran_charlen_t field_name_len) { +CEED_EXTERN void fCeedOperatorSetField(int *op, const char *field_name, int *rstr, int *basis, int *vec, int *err, fortran_charlen_t field_name_len) { FIX_STRING(field_name); - CeedElemRestriction r_; - CeedBasis b_; - CeedVector v_; - - CeedOperator op_ = CeedOperator_dict[*op]; - - if (*r == FORTRAN_NULL) { - r_ = NULL; - } else if (*r == FORTRAN_ELEMRESTRICTION_NONE) { - r_ = CEED_ELEMRESTRICTION_NONE; + CeedVector vec_c; + CeedElemRestriction rstr_c; + CeedBasis basis_c; + + if (*vec == FORTRAN_NULL) { + vec_c = NULL; + } else if (*vec == FORTRAN_VECTOR_ACTIVE) { + vec_c = CEED_VECTOR_ACTIVE; + } else if (*vec == FORTRAN_VECTOR_NONE) { + vec_c = CEED_VECTOR_NONE; } else { - r_ = CeedElemRestriction_dict[*r]; + vec_c = CeedVector_dict[*vec]; } - - if (*b == FORTRAN_NULL) { - b_ = NULL; - } else if (*b == FORTRAN_BASIS_NONE) { - b_ = CEED_BASIS_NONE; + if (*rstr == FORTRAN_NULL) { + rstr_c = NULL; + } else if (*rstr == FORTRAN_ELEMRESTRICTION_NONE) { + rstr_c = CEED_ELEMRESTRICTION_NONE; } else { - b_ = CeedBasis_dict[*b]; + rstr_c = CeedElemRestriction_dict[*rstr]; } - if (*v == FORTRAN_NULL) { - v_ = NULL; - } else if (*v == FORTRAN_VECTOR_ACTIVE) { - v_ = CEED_VECTOR_ACTIVE; - } else if (*v == FORTRAN_VECTOR_NONE) { - v_ = CEED_VECTOR_NONE; + if (*basis == FORTRAN_NULL) { + basis_c = NULL; + } else if (*basis == FORTRAN_BASIS_NONE) { + basis_c = CEED_BASIS_NONE; } else { - v_ = CeedVector_dict[*v]; + basis_c = CeedBasis_dict[*basis]; } - *err = CeedOperatorSetField(op_, field_name_c, r_, b_, v_); + *err = CeedOperatorSetField(CeedOperator_dict[*op], field_name_c, rstr_c, basis_c, vec_c); } #define fCeedOperatorCompositeAddSub FORTRAN_NAME(ceedoperatorcompositeaddsub, CEEDOPERATORCOMPOSITEADDSUB) -CEED_EXTERN void fCeedOperatorCompositeAddSub(int *compositeop, int *subop, int *err) { - CeedOperator compositeop_ = CeedOperator_dict[*compositeop]; - CeedOperator subop_ = CeedOperator_dict[*subop]; - - *err = CeedOperatorCompositeAddSub(compositeop_, subop_); +CEED_EXTERN void fCeedOperatorCompositeAddSub(int *composite_op, int *sub_op, int *err) { + *err = CeedOperatorCompositeAddSub(CeedOperator_dict[*composite_op], CeedOperator_dict[*sub_op]); } #define fCeedOperatorSetName FORTRAN_NAME(ceedoperatorsetname, CEEDOPERATORSETNAME) CEED_EXTERN void fCeedOperatorSetName(int *op, const char *name, int *err, fortran_charlen_t name_len) { FIX_STRING(name); - CeedOperator op_ = CeedOperator_dict[*op]; - - *err = CeedOperatorSetName(op_, name_c); + *err = CeedOperatorSetName(CeedOperator_dict[*op], name_c); } #define fCeedOperatorSetNumViewTabs FORTRAN_NAME(ceedoperatorsetnumviewtabs, CEEDOPERATORSETNUMVIEWTABS) -CEED_EXTERN void fCeedOperatorSetNumViewTabs(int *op, int *ntabs, int *err) { - CeedOperator op_ = CeedOperator_dict[*op]; - - *err = CeedOperatorSetNumViewTabs(op_, *ntabs); +CEED_EXTERN void fCeedOperatorSetNumViewTabs(int *op, int *num_tabs, int *err) { + *err = CeedOperatorSetNumViewTabs(CeedOperator_dict[*op], *num_tabs); } #define fCeedOperatorLinearAssembleQFunction FORTRAN_NAME(ceedoperatorlinearassembleqfunction, CEEDOPERATORLINEARASSEMBLEQFUNCTION) -CEED_EXTERN void fCeedOperatorLinearAssembleQFunction(int *op, int *assembledvec, int *assembledrstr, int *rqst, int *err) { - // Vector - if (CeedVector_count == CeedVector_count_max) { - CeedVector_count_max += CeedVector_count_max / 2 + 1; - CeedRealloc(CeedVector_count_max, &CeedVector_dict); - } - CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; - - // Restriction - if (CeedElemRestriction_count == CeedElemRestriction_count_max) { - CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1; - CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); - } - CeedElemRestriction *rstr_ = &CeedElemRestriction_dict[CeedElemRestriction_count]; +CEED_EXTERN void fCeedOperatorLinearAssembleQFunction(int *op, int *assembled_vec, int *assembled_rstr, int *request, int *err) { + bool create_request = true; - int createRequest = 1; // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) - if (*rqst == -1 || *rqst == -2) { - createRequest = 0; - } + if (*request == FORTRAN_REQUEST_IMMEDIATE || *request == FORTRAN_REQUEST_ORDERED) create_request = false; + if (create_request && num_CeedRequest == max_CeedRequest) fCeedRequestExpandDict(); - if (createRequest && CeedRequest_count == CeedRequest_count_max) { - CeedRequest_count_max += CeedRequest_count_max / 2 + 1; - CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); - } + CeedRequest *request_c; - CeedRequest *rqst_; - if (*rqst == -1) { - rqst_ = CEED_REQUEST_IMMEDIATE; - } else if (*rqst == -2) { - rqst_ = CEED_REQUEST_ORDERED; + if (*request == FORTRAN_REQUEST_IMMEDIATE) { + request_c = CEED_REQUEST_IMMEDIATE; + } else if (*request == FORTRAN_REQUEST_ORDERED) { + request_c = CEED_REQUEST_ORDERED; } else { - rqst_ = &CeedRequest_dict[CeedRequest_count]; + request_c = &CeedRequest_dict[num_CeedRequest]; } - *err = CeedOperatorLinearAssembleQFunction(CeedOperator_dict[*op], assembledvec_, rstr_, rqst_); - if (*err) return; - if (createRequest) { - *rqst = CeedRequest_count++; - CeedRequest_n++; - } + // Vector + if (num_CeedVector == max_CeedVector) fCeedVectorExpandDict(); + // Restriction + if (num_CeedElemRestriction == max_CeedElemRestriction) fCeedElemRestrictionExpandDict(); + + // Assembly + *err = CeedOperatorLinearAssembleQFunction(CeedOperator_dict[*op], &CeedVector_dict[num_CeedVector], + &CeedElemRestriction_dict[num_CeedElemRestriction], request_c); if (*err == 0) { - *assembledrstr = CeedElemRestriction_count++; - CeedElemRestriction_n++; - *assembledvec = CeedVector_count++; - CeedVector_n++; + fCeedVectorAccept(assembled_vec); + fCeedElemRestrictionAccept(assembled_rstr); + if (create_request) fCeedRequestAccept(request); } } #define fCeedOperatorLinearAssembleDiagonal FORTRAN_NAME(ceedoperatorlinearassemblediagonal, CEEDOPERATORLINEARASSEMBLEDIAGONAL) -CEED_EXTERN void fCeedOperatorLinearAssembleDiagonal(int *op, int *assembledvec, int *rqst, int *err) { - int createRequest = 1; +CEED_EXTERN void fCeedOperatorLinearAssembleDiagonal(int *op, int *assembled_vec, int *request, int *err) { + bool create_request = true; + // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) - if (*rqst == -1 || *rqst == -2) { - createRequest = 0; - } + if (*request == FORTRAN_REQUEST_IMMEDIATE || *request == FORTRAN_REQUEST_ORDERED) create_request = false; + if (create_request && num_CeedRequest == max_CeedRequest) fCeedRequestExpandDict(); - if (createRequest && CeedRequest_count == CeedRequest_count_max) { - CeedRequest_count_max += CeedRequest_count_max / 2 + 1; - CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); - } + CeedRequest *request_c; - CeedRequest *rqst_; - if (*rqst == -1) { - rqst_ = CEED_REQUEST_IMMEDIATE; - } else if (*rqst == -2) { - rqst_ = CEED_REQUEST_ORDERED; + if (*request == FORTRAN_REQUEST_IMMEDIATE) { + request_c = CEED_REQUEST_IMMEDIATE; + } else if (*request == FORTRAN_REQUEST_ORDERED) { + request_c = CEED_REQUEST_ORDERED; } else { - rqst_ = &CeedRequest_dict[CeedRequest_count]; + request_c = &CeedRequest_dict[num_CeedRequest]; } - *err = CeedOperatorLinearAssembleDiagonal(CeedOperator_dict[*op], CeedVector_dict[*assembledvec], rqst_); - if (*err) return; - if (createRequest) { - *rqst = CeedRequest_count++; - CeedRequest_n++; - } + *err = CeedOperatorLinearAssembleDiagonal(CeedOperator_dict[*op], CeedVector_dict[*assembled_vec], request_c); + if (*err == 0 && create_request) fCeedRequestAccept(request); } #define fCeedOperatorMultigridLevelCreate FORTRAN_NAME(ceedoperatormultigridlevelcreate, CEEDOPERATORMULTIGRIDLEVELCREATE) -CEED_EXTERN void fCeedOperatorMultigridLevelCreate(int *opFine, int *pMultFine, int *rstrCoarse, int *basisCoarse, int *opCoarse, int *opProlong, - int *opRestrict, int *err) { +CEED_EXTERN void fCeedOperatorMultigridLevelCreate(int *op_fine, int *p_mult_fine, int *rstr_coarse, int *basis_coarse, int *op_coarse, + int *op_prolong, int *op_restrict, int *err) { // Operators - CeedOperator opCoarse_, opProlong_, opRestrict_; + CeedOperator op_coarse_c, op_prolong_c, op_restrict_c; // C interface call - *err = CeedOperatorMultigridLevelCreate(CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], CeedElemRestriction_dict[*rstrCoarse], - CeedBasis_dict[*basisCoarse], &opCoarse_, &opProlong_, &opRestrict_); + *err = CeedOperatorMultigridLevelCreate(CeedOperator_dict[*op_fine], CeedVector_dict[*p_mult_fine], CeedElemRestriction_dict[*rstr_coarse], + CeedBasis_dict[*basis_coarse], &op_coarse_c, &op_prolong_c, &op_restrict_c); if (*err) return; - while (CeedOperator_count + 2 >= CeedOperator_count_max) { - CeedOperator_count_max += CeedOperator_count_max / 2 + 1; - } - CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); - CeedOperator_dict[CeedOperator_count] = opCoarse_; - *opCoarse = CeedOperator_count++; - CeedOperator_dict[CeedOperator_count] = opProlong_; - *opProlong = CeedOperator_count++; - CeedOperator_dict[CeedOperator_count] = opRestrict_; - *opRestrict = CeedOperator_count++; - CeedOperator_n += 3; + while (num_CeedOperator + 2 >= max_CeedOperator) max_CeedOperator += max_CeedOperator / 2 + 1; + CeedRealloc(max_CeedOperator, &CeedOperator_dict); + CeedOperator_dict[num_CeedOperator] = op_coarse_c; + *op_coarse = num_CeedOperator++; + CeedOperator_dict[num_CeedOperator] = op_prolong_c; + *op_prolong = num_CeedOperator++; + CeedOperator_dict[num_CeedOperator] = op_restrict_c; + *op_restrict = num_CeedOperator++; + num_active_CeedOperator += 3; } #define fCeedOperatorMultigridLevelCreateTensorH1 FORTRAN_NAME(ceedoperatormultigridlevelcreatetensorh1, CEEDOPERATORMULTIGRIDLEVELCREATETENSORH1) -CEED_EXTERN void fCeedOperatorMultigridLevelCreateTensorH1(int *opFine, int *pMultFine, int *rstrCoarse, int *basisCoarse, - const CeedScalar *interpCtoF, int *opCoarse, int *opProlong, int *opRestrict, int *err) { +CEED_EXTERN void fCeedOperatorMultigridLevelCreateTensorH1(int *op_fine, int *p_mult_fine, int *rstr_coarse, int *basis_coarse, + const CeedScalar *interp_c_to_f, int *op_coarse, int *op_prolong, int *op_restrict, + int *err) { // Operators - CeedOperator opCoarse_, opProlong_, opRestrict_; + CeedOperator op_coarse_c, op_prolong_c, op_restrict_c; // C interface call - *err = CeedOperatorMultigridLevelCreateTensorH1(CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], CeedElemRestriction_dict[*rstrCoarse], - CeedBasis_dict[*basisCoarse], interpCtoF, &opCoarse_, &opProlong_, &opRestrict_); + *err = CeedOperatorMultigridLevelCreateTensorH1(CeedOperator_dict[*op_fine], CeedVector_dict[*p_mult_fine], CeedElemRestriction_dict[*rstr_coarse], + CeedBasis_dict[*basis_coarse], interp_c_to_f, &op_coarse_c, &op_prolong_c, &op_restrict_c); if (*err) return; - while (CeedOperator_count + 2 >= CeedOperator_count_max) { - CeedOperator_count_max += CeedOperator_count_max / 2 + 1; - } - CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); - CeedOperator_dict[CeedOperator_count] = opCoarse_; - *opCoarse = CeedOperator_count++; - CeedOperator_dict[CeedOperator_count] = opProlong_; - *opProlong = CeedOperator_count++; - CeedOperator_dict[CeedOperator_count] = opRestrict_; - *opRestrict = CeedOperator_count++; - CeedOperator_n += 3; + while (num_CeedOperator + 2 >= max_CeedOperator) max_CeedOperator += max_CeedOperator / 2 + 1; + CeedRealloc(max_CeedOperator, &CeedOperator_dict); + CeedOperator_dict[num_CeedOperator] = op_coarse_c; + *op_coarse = num_CeedOperator++; + CeedOperator_dict[num_CeedOperator] = op_prolong_c; + *op_prolong = num_CeedOperator++; + CeedOperator_dict[num_CeedOperator] = op_restrict_c; + *op_restrict = num_CeedOperator++; + num_active_CeedOperator += 3; } #define fCeedOperatorMultigridLevelCreateH1 FORTRAN_NAME(ceedoperatormultigridlevelcreateh1, CEEDOPERATORMULTIGRIDLEVELCREATEH1) -CEED_EXTERN void fCeedOperatorMultigridLevelCreateH1(int *opFine, int *pMultFine, int *rstrCoarse, int *basisCoarse, const CeedScalar *interpCtoF, - int *opCoarse, int *opProlong, int *opRestrict, int *err) { +CEED_EXTERN void fCeedOperatorMultigridLevelCreateH1(int *op_fine, int *p_mult_fine, int *rstr_coarse, int *basis_coarse, + const CeedScalar *interp_c_to_f, int *op_coarse, int *op_prolong, int *op_restrict, int *err) { // Operators - CeedOperator opCoarse_, opProlong_, opRestrict_; + CeedOperator op_coarse_c, op_prolong_c, op_restrict_c; // C interface call - *err = CeedOperatorMultigridLevelCreateH1(CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], CeedElemRestriction_dict[*rstrCoarse], - CeedBasis_dict[*basisCoarse], interpCtoF, &opCoarse_, &opProlong_, &opRestrict_); + *err = CeedOperatorMultigridLevelCreateH1(CeedOperator_dict[*op_fine], CeedVector_dict[*p_mult_fine], CeedElemRestriction_dict[*rstr_coarse], + CeedBasis_dict[*basis_coarse], interp_c_to_f, &op_coarse_c, &op_prolong_c, &op_restrict_c); if (*err) return; - while (CeedOperator_count + 2 >= CeedOperator_count_max) { - CeedOperator_count_max += CeedOperator_count_max / 2 + 1; - } - CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); - CeedOperator_dict[CeedOperator_count] = opCoarse_; - *opCoarse = CeedOperator_count++; - CeedOperator_dict[CeedOperator_count] = opProlong_; - *opProlong = CeedOperator_count++; - CeedOperator_dict[CeedOperator_count] = opRestrict_; - *opRestrict = CeedOperator_count++; - CeedOperator_n += 3; + while (num_CeedOperator + 2 >= max_CeedOperator) max_CeedOperator += max_CeedOperator / 2 + 1; + CeedRealloc(max_CeedOperator, &CeedOperator_dict); + CeedOperator_dict[num_CeedOperator] = op_coarse_c; + *op_coarse = num_CeedOperator++; + CeedOperator_dict[num_CeedOperator] = op_prolong_c; + *op_prolong = num_CeedOperator++; + CeedOperator_dict[num_CeedOperator] = op_restrict_c; + *op_restrict = num_CeedOperator++; + num_active_CeedOperator += 3; } #define fCeedOperatorView FORTRAN_NAME(ceedoperatorview, CEEDOPERATORVIEW) -CEED_EXTERN void fCeedOperatorView(int *op, int *err) { - CeedOperator op_ = CeedOperator_dict[*op]; - - *err = CeedOperatorView(op_, stdout); -} +CEED_EXTERN void fCeedOperatorView(int *op, int *err) { *err = CeedOperatorView(CeedOperator_dict[*op], stdout); } #define fCeedOperatorCreateFDMElementInverse FORTRAN_NAME(ceedoperatorcreatefdmelementinverse, CEEDOPERATORCREATEFDMELEMENTINVERSE) -CEED_EXTERN void fCeedOperatorCreateFDMElementInverse(int *op, int *fdminv, int *rqst, int *err) { - // Operator - if (CeedOperator_count == CeedOperator_count_max) { - CeedOperator_count_max += CeedOperator_count_max / 2 + 1; - CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); - } - CeedOperator *fdminv_ = &CeedOperator_dict[CeedOperator_count]; +CEED_EXTERN void fCeedOperatorCreateFDMElementInverse(int *op, int *fdm_inv, int *request, int *err) { + bool create_request = true; - int createRequest = 1; // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) - if (*rqst == -1 || *rqst == -2) { - createRequest = 0; - } + if (*request == FORTRAN_REQUEST_IMMEDIATE || *request == FORTRAN_REQUEST_ORDERED) create_request = false; + if (create_request && num_CeedRequest == max_CeedRequest) fCeedRequestExpandDict(); - if (createRequest && CeedRequest_count == CeedRequest_count_max) { - CeedRequest_count_max += CeedRequest_count_max / 2 + 1; - CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); - } + CeedRequest *request_c; - CeedRequest *rqst_; - if (*rqst == -1) { - rqst_ = CEED_REQUEST_IMMEDIATE; - } else if (*rqst == -2) { - rqst_ = CEED_REQUEST_ORDERED; + if (*request == FORTRAN_REQUEST_IMMEDIATE) { + request_c = CEED_REQUEST_IMMEDIATE; + } else if (*request == FORTRAN_REQUEST_ORDERED) { + request_c = CEED_REQUEST_ORDERED; } else { - rqst_ = &CeedRequest_dict[CeedRequest_count]; + request_c = &CeedRequest_dict[num_CeedRequest]; } - *err = CeedOperatorCreateFDMElementInverse(CeedOperator_dict[*op], fdminv_, rqst_); - if (*err) return; - if (createRequest) { - *rqst = CeedRequest_count++; - CeedRequest_n++; - } + // Operator + if (num_CeedOperator == max_CeedOperator) fCeedOperatorExpandDict(); + *err = CeedOperatorCreateFDMElementInverse(CeedOperator_dict[*op], &CeedOperator_dict[num_CeedOperator], request_c); if (*err == 0) { - *fdminv = CeedOperator_count++; - CeedOperator_n++; + fCeedOperatorAccept(fdm_inv); + if (create_request) fCeedRequestAccept(request); } } #define fCeedOperatorApply FORTRAN_NAME(ceedoperatorapply, CEEDOPERATORAPPLY) -CEED_EXTERN void fCeedOperatorApply(int *op, int *ustatevec, int *resvec, int *rqst, int *err) { - CeedVector ustatevec_ = (*ustatevec == FORTRAN_NULL) ? NULL : (*ustatevec == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*ustatevec]); - CeedVector resvec_ = (*resvec == FORTRAN_NULL) ? NULL : (*resvec == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*resvec]); +CEED_EXTERN void fCeedOperatorApply(int *op, int *in, int *out, int *request, int *err) { + bool create_request = true; - int createRequest = 1; // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) - if (*rqst == -1 || *rqst == -2) { - createRequest = 0; - } + if (*request == FORTRAN_REQUEST_IMMEDIATE || *request == FORTRAN_REQUEST_ORDERED) create_request = false; + if (create_request && num_CeedRequest == max_CeedRequest) fCeedRequestExpandDict(); - if (createRequest && CeedRequest_count == CeedRequest_count_max) { - CeedRequest_count_max += CeedRequest_count_max / 2 + 1; - CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); - } + CeedRequest *request_c; - CeedRequest *rqst_; - if (*rqst == -1) { - rqst_ = CEED_REQUEST_IMMEDIATE; - } else if (*rqst == -2) { - rqst_ = CEED_REQUEST_ORDERED; + if (*request == FORTRAN_REQUEST_IMMEDIATE) { + request_c = CEED_REQUEST_IMMEDIATE; + } else if (*request == FORTRAN_REQUEST_ORDERED) { + request_c = CEED_REQUEST_ORDERED; } else { - rqst_ = &CeedRequest_dict[CeedRequest_count]; + request_c = &CeedRequest_dict[num_CeedRequest]; } - *err = CeedOperatorApply(CeedOperator_dict[*op], ustatevec_, resvec_, rqst_); - if (*err) return; - if (createRequest) { - *rqst = CeedRequest_count++; - CeedRequest_n++; - } + CeedVector in_c = (*in == FORTRAN_NULL) ? NULL : (*in == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*in]); + CeedVector out_c = (*out == FORTRAN_NULL) ? NULL : (*out == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*out]); + + *err = CeedOperatorApply(CeedOperator_dict[*op], in_c, out_c, request_c); + if (*err == 0 && create_request) fCeedRequestAccept(request); } #define fCeedOperatorApplyAdd FORTRAN_NAME(ceedoperatorapplyadd, CEEDOPERATORAPPLYADD) -CEED_EXTERN void fCeedOperatorApplyAdd(int *op, int *ustatevec, int *resvec, int *rqst, int *err) { - CeedVector ustatevec_ = *ustatevec == FORTRAN_NULL ? NULL : CeedVector_dict[*ustatevec]; - CeedVector resvec_ = *resvec == FORTRAN_NULL ? NULL : CeedVector_dict[*resvec]; +CEED_EXTERN void fCeedOperatorApplyAdd(int *op, int *in, int *out, int *request, int *err) { + bool create_request = true; - int createRequest = 1; // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) - if (*rqst == -1 || *rqst == -2) { - createRequest = 0; - } + if (*request == FORTRAN_REQUEST_IMMEDIATE || *request == FORTRAN_REQUEST_ORDERED) create_request = false; + if (create_request && num_CeedRequest == max_CeedRequest) fCeedRequestExpandDict(); - if (createRequest && CeedRequest_count == CeedRequest_count_max) { - CeedRequest_count_max += CeedRequest_count_max / 2 + 1; - CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); - } + CeedRequest *request_c; - CeedRequest *rqst_; - if (*rqst == -1) { - rqst_ = CEED_REQUEST_IMMEDIATE; - } else if (*rqst == -2) { - rqst_ = CEED_REQUEST_ORDERED; + if (*request == FORTRAN_REQUEST_IMMEDIATE) { + request_c = CEED_REQUEST_IMMEDIATE; + } else if (*request == FORTRAN_REQUEST_ORDERED) { + request_c = CEED_REQUEST_ORDERED; } else { - rqst_ = &CeedRequest_dict[CeedRequest_count]; + request_c = &CeedRequest_dict[num_CeedRequest]; } - *err = CeedOperatorApplyAdd(CeedOperator_dict[*op], ustatevec_, resvec_, rqst_); - if (*err) return; - if (createRequest) { - *rqst = CeedRequest_count++; - CeedRequest_n++; - } -} + CeedVector in_c = (*in == FORTRAN_NULL) ? NULL : (*in == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*in]); + CeedVector out_c = (*out == FORTRAN_NULL) ? NULL : (*out == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*out]); -#define fCeedOperatorApplyJacobian FORTRAN_NAME(ceedoperatorapplyjacobian, CEEDOPERATORAPPLYJACOBIAN) -CEED_EXTERN void fCeedOperatorApplyJacobian(int *op, int *qdatavec, int *ustatevec, int *dustatevec, int *dresvec, int *rqst, int *err) { - // TODO Uncomment this when CeedOperatorApplyJacobian is implemented - // *err = CeedOperatorApplyJacobian(CeedOperator_dict[*op], CeedVector_dict[*qdatavec], - // CeedVector_dict[*ustatevec], CeedVector_dict[*dustatevec], - // CeedVector_dict[*dresvec], &CeedRequest_dict[*rqst]); + *err = CeedOperatorApplyAdd(CeedOperator_dict[*op], in_c, out_c, request_c); + if (*err == 0 && create_request) fCeedRequestAccept(request); } #define fCeedOperatorDestroy FORTRAN_NAME(ceedoperatordestroy, CEEDOPERATORDESTROY) @@ -1340,11 +1165,11 @@ CEED_EXTERN void fCeedOperatorDestroy(int *op, int *err) { *err = CeedOperatorDestroy(&CeedOperator_dict[*op]); if (*err == 0) { *op = FORTRAN_NULL; - CeedOperator_n--; - if (CeedOperator_n == 0) { - *err = CeedFree(&CeedOperator_dict); - CeedOperator_count = 0; - CeedOperator_count_max = 0; + num_active_CeedOperator--; + if (num_active_CeedOperator == 0) { + *err = CeedFree(&CeedOperator_dict); + num_CeedOperator = 0; + max_CeedOperator = 0; } } }