From b5c5786911f22d2f4504db665c75d7759042d78f Mon Sep 17 00:00:00 2001 From: Jeremy L Thompson Date: Tue, 1 Sep 2026 10:29:31 +0200 Subject: [PATCH] minor - avoid returning function call --- backends/avx/ceed-avx-tensor.c | 9 ++-- backends/blocked/ceed-blocked-operator.c | 6 ++- .../cuda-gen/ceed-cuda-gen-operator-build.cpp | 6 ++- backends/cuda-gen/ceed-cuda-gen-operator.c | 12 +++-- backends/cuda-ref/ceed-cuda-ref-operator.c | 6 ++- .../cuda-ref/ceed-cuda-ref-qfunctioncontext.c | 15 ++++-- backends/cuda-ref/ceed-cuda-ref-restriction.c | 9 ++-- backends/cuda-ref/ceed-cuda-ref-vector.c | 18 ++++--- .../hip-gen/ceed-hip-gen-operator-build.cpp | 6 ++- backends/hip-gen/ceed-hip-gen-operator.c | 6 ++- backends/hip-ref/ceed-hip-ref-operator.c | 6 ++- .../hip-ref/ceed-hip-ref-qfunctioncontext.c | 15 ++++-- backends/hip-ref/ceed-hip-ref-restriction.c | 9 ++-- backends/hip-ref/ceed-hip-ref-vector.c | 21 +++++--- backends/opt/ceed-opt-operator.c | 6 ++- backends/opt/ceed-opt-tensor.c | 6 ++- backends/ref/ceed-ref-operator.c | 12 +++-- backends/ref/ceed-ref-restriction.c | 48 ++++++++++++------- backends/ref/ceed-ref-vector.c | 9 ++-- .../sycl-ref/ceed-sycl-ref-operator.sycl.cpp | 6 ++- .../ceed-sycl-ref-qfunctioncontext.sycl.cpp | 15 ++++-- backends/sycl-ref/ceed-sycl-vector.sycl.cpp | 18 ++++--- backends/sycl/ceed-sycl-common.hpp | 3 +- interface/ceed-elemrestriction.c | 6 ++- interface/ceed-operator.c | 27 +++++++---- interface/ceed-preconditioning.c | 6 ++- interface/ceed-qfunctioncontext.c | 9 ++-- 27 files changed, 210 insertions(+), 105 deletions(-) diff --git a/backends/avx/ceed-avx-tensor.c b/backends/avx/ceed-avx-tensor.c index 01d8182912..c851fcee4b 100644 --- a/backends/avx/ceed-avx-tensor.c +++ b/backends/avx/ceed-avx-tensor.c @@ -258,15 +258,18 @@ static inline int CeedTensorContract_Avx_Single(CeedTensorContract contract, Cee //------------------------------------------------------------------------------ static int CeedTensorContract_Avx_Blocked_4_8(CeedTensorContract contract, CeedInt A, CeedInt B, CeedInt C, CeedInt J, const CeedScalar *restrict t, CeedTransposeMode t_mode, const CeedInt add, const CeedScalar *restrict u, CeedScalar *restrict v) { - return CeedTensorContract_Avx_Blocked(contract, A, B, C, J, t, t_mode, add, u, v, 4, 8); + CeedCallBackend(CeedTensorContract_Avx_Blocked(contract, A, B, C, J, t, t_mode, add, u, v, 4, 8)); + return CEED_ERROR_SUCCESS; } static int CeedTensorContract_Avx_Remainder_8_8(CeedTensorContract contract, CeedInt A, CeedInt B, CeedInt C, CeedInt J, const CeedScalar *restrict t, CeedTransposeMode t_mode, const CeedInt add, const CeedScalar *restrict u, CeedScalar *restrict v) { - return CeedTensorContract_Avx_Remainder(contract, A, B, C, J, t, t_mode, add, u, v, 8, 8); + CeedCallBackend(CeedTensorContract_Avx_Remainder(contract, A, B, C, J, t, t_mode, add, u, v, 8, 8)); + return CEED_ERROR_SUCCESS; } static int CeedTensorContract_Avx_Single_4_8(CeedTensorContract contract, CeedInt A, CeedInt B, CeedInt C, CeedInt J, const CeedScalar *restrict t, CeedTransposeMode t_mode, const CeedInt add, const CeedScalar *restrict u, CeedScalar *restrict v) { - return CeedTensorContract_Avx_Single(contract, A, B, C, J, t, t_mode, add, u, v, 4, 8); + CeedCallBackend(CeedTensorContract_Avx_Single(contract, A, B, C, J, t, t_mode, add, u, v, 4, 8)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/blocked/ceed-blocked-operator.c b/backends/blocked/ceed-blocked-operator.c index 1c2358b647..406ce97cea 100644 --- a/backends/blocked/ceed-blocked-operator.c +++ b/backends/blocked/ceed-blocked-operator.c @@ -738,14 +738,16 @@ static inline int CeedOperatorLinearAssembleQFunctionCore_Blocked(CeedOperator o // Assemble Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunction_Blocked(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Blocked(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Blocked(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ // Update Assembled Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionUpdate_Blocked(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Blocked(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Blocked(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/cuda-gen/ceed-cuda-gen-operator-build.cpp b/backends/cuda-gen/ceed-cuda-gen-operator-build.cpp index 950949b2ee..9fa6df8e6f 100644 --- a/backends/cuda-gen/ceed-cuda-gen-operator-build.cpp +++ b/backends/cuda-gen/ceed-cuda-gen-operator-build.cpp @@ -2162,11 +2162,13 @@ static int CeedOperatorBuildKernelAssemblyAtPoints_Cuda_gen(CeedOperator op, boo } extern "C" int CeedOperatorBuildKernelDiagonalAssemblyAtPoints_Cuda_gen(CeedOperator op, bool *is_good_build) { - return CeedOperatorBuildKernelAssemblyAtPoints_Cuda_gen(op, false, is_good_build); + CeedCallBackend(CeedOperatorBuildKernelAssemblyAtPoints_Cuda_gen(op, false, is_good_build)); + return CEED_ERROR_SUCCESS; } extern "C" int CeedOperatorBuildKernelFullAssemblyAtPoints_Cuda_gen(CeedOperator op, bool *is_good_build) { - return CeedOperatorBuildKernelAssemblyAtPoints_Cuda_gen(op, true, is_good_build); + CeedCallBackend(CeedOperatorBuildKernelAssemblyAtPoints_Cuda_gen(op, true, is_good_build)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/cuda-gen/ceed-cuda-gen-operator.c b/backends/cuda-gen/ceed-cuda-gen-operator.c index 87b4ccfeb1..760d756d7b 100644 --- a/backends/cuda-gen/ceed-cuda-gen-operator.c +++ b/backends/cuda-gen/ceed-cuda-gen-operator.c @@ -511,7 +511,8 @@ static int CeedOperatorApplyAddComposite_Cuda_gen(CeedOperator op, CeedVector in impl->captured_input_ptr = NULL; impl->captured_output_ptr = NULL; CeedCallBackend(CeedOperatorSetEnableCudaGraph(op, false)); - return CeedOperatorApplyAddComposite_NoGraph_Cuda_gen(op, input_vec, output_vec, request); + CeedCallBackend(CeedOperatorApplyAddComposite_NoGraph_Cuda_gen(op, input_vec, output_vec, request)); + return CEED_ERROR_SUCCESS; } impl->graph_created = true; } @@ -526,7 +527,8 @@ static int CeedOperatorApplyAddComposite_Cuda_gen(CeedOperator op, CeedVector in impl->captured_input_ptr = NULL; impl->captured_output_ptr = NULL; CeedCallBackend(CeedOperatorSetEnableCudaGraph(op, false)); - return CeedOperatorApplyAddComposite_NoGraph_Cuda_gen(op, input_vec, output_vec, request); + CeedCallBackend(CeedOperatorApplyAddComposite_NoGraph_Cuda_gen(op, input_vec, output_vec, request)); + return CEED_ERROR_SUCCESS; } return CEED_ERROR_SUCCESS; } @@ -721,11 +723,13 @@ static int CeedOperatorLinearAssembleQFunctionCore_Cuda_gen(CeedOperator op, boo } static int CeedOperatorLinearAssembleQFunction_Cuda_gen(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Cuda_gen(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Cuda_gen(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } static int CeedOperatorLinearAssembleQFunctionUpdate_Cuda_gen(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Cuda_gen(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Cuda_gen(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/cuda-ref/ceed-cuda-ref-operator.c b/backends/cuda-ref/ceed-cuda-ref-operator.c index a3cb8b2378..c5132937e5 100644 --- a/backends/cuda-ref/ceed-cuda-ref-operator.c +++ b/backends/cuda-ref/ceed-cuda-ref-operator.c @@ -1132,14 +1132,16 @@ static inline int CeedOperatorLinearAssembleQFunctionCore_Cuda(CeedOperator op, // Assemble Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunction_Cuda(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Cuda(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Cuda(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ // Update Assembled Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionUpdate_Cuda(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Cuda(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Cuda(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/cuda-ref/ceed-cuda-ref-qfunctioncontext.c b/backends/cuda-ref/ceed-cuda-ref-qfunctioncontext.c index 884e6b5306..d3ee844477 100644 --- a/backends/cuda-ref/ceed-cuda-ref-qfunctioncontext.c +++ b/backends/cuda-ref/ceed-cuda-ref-qfunctioncontext.c @@ -77,9 +77,11 @@ static inline int CeedQFunctionContextSyncD2H_Cuda(const CeedQFunctionContext ct static inline int CeedQFunctionContextSync_Cuda(const CeedQFunctionContext ctx, CeedMemType mem_type) { switch (mem_type) { case CEED_MEM_HOST: - return CeedQFunctionContextSyncD2H_Cuda(ctx); + CeedCallBackend(CeedQFunctionContextSyncD2H_Cuda(ctx)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedQFunctionContextSyncH2D_Cuda(ctx); + CeedCallBackend(CeedQFunctionContextSyncH2D_Cuda(ctx)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -223,9 +225,11 @@ static int CeedQFunctionContextSetData_Cuda(const CeedQFunctionContext ctx, cons CeedCallBackend(CeedQFunctionContextSetAllInvalid_Cuda(ctx)); switch (mem_type) { case CEED_MEM_HOST: - return CeedQFunctionContextSetDataHost_Cuda(ctx, copy_mode, data); + CeedCallBackend(CeedQFunctionContextSetDataHost_Cuda(ctx, copy_mode, data)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedQFunctionContextSetDataDevice_Cuda(ctx, copy_mode, data); + CeedCallBackend(CeedQFunctionContextSetDataDevice_Cuda(ctx, copy_mode, data)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -291,7 +295,8 @@ static int CeedQFunctionContextGetDataCore_Cuda(const CeedQFunctionContext ctx, // Get read-only access to the data //------------------------------------------------------------------------------ static int CeedQFunctionContextGetDataRead_Cuda(const CeedQFunctionContext ctx, const CeedMemType mem_type, void *data) { - return CeedQFunctionContextGetDataCore_Cuda(ctx, mem_type, data); + CeedCallBackend(CeedQFunctionContextGetDataCore_Cuda(ctx, mem_type, data)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/cuda-ref/ceed-cuda-ref-restriction.c b/backends/cuda-ref/ceed-cuda-ref-restriction.c index ae53a9628f..6a0dc9c137 100644 --- a/backends/cuda-ref/ceed-cuda-ref-restriction.c +++ b/backends/cuda-ref/ceed-cuda-ref-restriction.c @@ -294,7 +294,8 @@ static inline int CeedElemRestrictionApply_Cuda_Core(CeedElemRestriction rstr, C // Apply restriction //------------------------------------------------------------------------------ static int CeedElemRestrictionApply_Cuda(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Cuda_Core(rstr, t_mode, true, true, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Cuda_Core(rstr, t_mode, true, true, u, v, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -302,7 +303,8 @@ static int CeedElemRestrictionApply_Cuda(CeedElemRestriction rstr, CeedTranspose //------------------------------------------------------------------------------ static int CeedElemRestrictionApplyUnsigned_Cuda(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Cuda_Core(rstr, t_mode, false, true, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Cuda_Core(rstr, t_mode, false, true, u, v, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -310,7 +312,8 @@ static int CeedElemRestrictionApplyUnsigned_Cuda(CeedElemRestriction rstr, CeedT //------------------------------------------------------------------------------ static int CeedElemRestrictionApplyUnoriented_Cuda(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Cuda_Core(rstr, t_mode, false, false, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Cuda_Core(rstr, t_mode, false, false, u, v, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/cuda-ref/ceed-cuda-ref-vector.c b/backends/cuda-ref/ceed-cuda-ref-vector.c index 783afd0a27..ee64f5acf2 100644 --- a/backends/cuda-ref/ceed-cuda-ref-vector.c +++ b/backends/cuda-ref/ceed-cuda-ref-vector.c @@ -103,9 +103,11 @@ static int CeedVectorSyncArray_Cuda(const CeedVector vec, CeedMemType mem_type) switch (mem_type) { case CEED_MEM_HOST: - return CeedVectorSyncD2H_Cuda(vec); + CeedCallBackend(CeedVectorSyncD2H_Cuda(vec)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedVectorSyncH2D_Cuda(vec); + CeedCallBackend(CeedVectorSyncH2D_Cuda(vec)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -215,9 +217,11 @@ static int CeedVectorSetArray_Cuda(const CeedVector vec, const CeedMemType mem_t CeedCallBackend(CeedVectorSetAllInvalid_Cuda(vec)); switch (mem_type) { case CEED_MEM_HOST: - return CeedVectorSetArrayHost_Cuda(vec, copy_mode, array); + CeedCallBackend(CeedVectorSetArrayHost_Cuda(vec, copy_mode, array)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedVectorSetArrayDevice_Cuda(vec, copy_mode, array); + CeedCallBackend(CeedVectorSetArrayDevice_Cuda(vec, copy_mode, array)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -425,7 +429,8 @@ static int CeedVectorGetArrayCore_Cuda(const CeedVector vec, const CeedMemType m // Get read-only access to a vector via the specified mem_type //------------------------------------------------------------------------------ static int CeedVectorGetArrayRead_Cuda(const CeedVector vec, const CeedMemType mem_type, const CeedScalar **array) { - return CeedVectorGetArrayCore_Cuda(vec, mem_type, (CeedScalar **)array); + CeedCallBackend(CeedVectorGetArrayCore_Cuda(vec, mem_type, (CeedScalar **)array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -478,7 +483,8 @@ static int CeedVectorGetArrayWrite_Cuda(const CeedVector vec, const CeedMemType } } } - return CeedVectorGetArray_Cuda(vec, mem_type, array); + CeedCallBackend(CeedVectorGetArray_Cuda(vec, mem_type, array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/hip-gen/ceed-hip-gen-operator-build.cpp b/backends/hip-gen/ceed-hip-gen-operator-build.cpp index d826879618..7547da80ac 100644 --- a/backends/hip-gen/ceed-hip-gen-operator-build.cpp +++ b/backends/hip-gen/ceed-hip-gen-operator-build.cpp @@ -2149,11 +2149,13 @@ static int CeedOperatorBuildKernelAssemblyAtPoints_Hip_gen(CeedOperator op, bool } extern "C" int CeedOperatorBuildKernelDiagonalAssemblyAtPoints_Hip_gen(CeedOperator op, bool *is_good_build) { - return CeedOperatorBuildKernelAssemblyAtPoints_Hip_gen(op, false, is_good_build); + CeedCallBackend(CeedOperatorBuildKernelAssemblyAtPoints_Hip_gen(op, false, is_good_build)); + return CEED_ERROR_SUCCESS; } extern "C" int CeedOperatorBuildKernelFullAssemblyAtPoints_Hip_gen(CeedOperator op, bool *is_good_build) { - return CeedOperatorBuildKernelAssemblyAtPoints_Hip_gen(op, true, is_good_build); + CeedCallBackend(CeedOperatorBuildKernelAssemblyAtPoints_Hip_gen(op, true, is_good_build)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ // Build QFunction assembly operator kernel diff --git a/backends/hip-gen/ceed-hip-gen-operator.c b/backends/hip-gen/ceed-hip-gen-operator.c index 89f084225f..4d32124b67 100644 --- a/backends/hip-gen/ceed-hip-gen-operator.c +++ b/backends/hip-gen/ceed-hip-gen-operator.c @@ -523,11 +523,13 @@ static int CeedOperatorLinearAssembleQFunctionCore_Hip_gen(CeedOperator op, bool } static int CeedOperatorLinearAssembleQFunction_Hip_gen(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Hip_gen(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Hip_gen(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } static int CeedOperatorLinearAssembleQFunctionUpdate_Hip_gen(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Hip_gen(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Hip_gen(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/hip-ref/ceed-hip-ref-operator.c b/backends/hip-ref/ceed-hip-ref-operator.c index e8d827d4cd..e901a6e7b3 100644 --- a/backends/hip-ref/ceed-hip-ref-operator.c +++ b/backends/hip-ref/ceed-hip-ref-operator.c @@ -1128,14 +1128,16 @@ static inline int CeedOperatorLinearAssembleQFunctionCore_Hip(CeedOperator op, b // Assemble Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunction_Hip(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Hip(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Hip(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ // Update Assembled Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionUpdate_Hip(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Hip(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Hip(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/hip-ref/ceed-hip-ref-qfunctioncontext.c b/backends/hip-ref/ceed-hip-ref-qfunctioncontext.c index a223fa91d8..57491c9e9b 100644 --- a/backends/hip-ref/ceed-hip-ref-qfunctioncontext.c +++ b/backends/hip-ref/ceed-hip-ref-qfunctioncontext.c @@ -74,9 +74,11 @@ static inline int CeedQFunctionContextSyncD2H_Hip(const CeedQFunctionContext ctx static inline int CeedQFunctionContextSync_Hip(const CeedQFunctionContext ctx, CeedMemType mem_type) { switch (mem_type) { case CEED_MEM_HOST: - return CeedQFunctionContextSyncD2H_Hip(ctx); + CeedCallBackend(CeedQFunctionContextSyncD2H_Hip(ctx)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedQFunctionContextSyncH2D_Hip(ctx); + CeedCallBackend(CeedQFunctionContextSyncH2D_Hip(ctx)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -220,9 +222,11 @@ static int CeedQFunctionContextSetData_Hip(const CeedQFunctionContext ctx, const CeedCallBackend(CeedQFunctionContextSetAllInvalid_Hip(ctx)); switch (mem_type) { case CEED_MEM_HOST: - return CeedQFunctionContextSetDataHost_Hip(ctx, copy_mode, data); + CeedCallBackend(CeedQFunctionContextSetDataHost_Hip(ctx, copy_mode, data)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedQFunctionContextSetDataDevice_Hip(ctx, copy_mode, data); + CeedCallBackend(CeedQFunctionContextSetDataDevice_Hip(ctx, copy_mode, data)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -288,7 +292,8 @@ static int CeedQFunctionContextGetDataCore_Hip(const CeedQFunctionContext ctx, c // Get read-only access to the data //------------------------------------------------------------------------------ static int CeedQFunctionContextGetDataRead_Hip(const CeedQFunctionContext ctx, const CeedMemType mem_type, void *data) { - return CeedQFunctionContextGetDataCore_Hip(ctx, mem_type, data); + CeedCallBackend(CeedQFunctionContextGetDataCore_Hip(ctx, mem_type, data)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/hip-ref/ceed-hip-ref-restriction.c b/backends/hip-ref/ceed-hip-ref-restriction.c index bc374c01a3..06bcf0ea52 100644 --- a/backends/hip-ref/ceed-hip-ref-restriction.c +++ b/backends/hip-ref/ceed-hip-ref-restriction.c @@ -295,7 +295,8 @@ static inline int CeedElemRestrictionApply_Hip_Core(CeedElemRestriction rstr, Ce // Apply restriction //------------------------------------------------------------------------------ static int CeedElemRestrictionApply_Hip(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Hip_Core(rstr, t_mode, true, true, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Hip_Core(rstr, t_mode, true, true, u, v, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -303,7 +304,8 @@ static int CeedElemRestrictionApply_Hip(CeedElemRestriction rstr, CeedTransposeM //------------------------------------------------------------------------------ static int CeedElemRestrictionApplyUnsigned_Hip(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Hip_Core(rstr, t_mode, false, true, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Hip_Core(rstr, t_mode, false, true, u, v, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -311,7 +313,8 @@ static int CeedElemRestrictionApplyUnsigned_Hip(CeedElemRestriction rstr, CeedTr //------------------------------------------------------------------------------ static int CeedElemRestrictionApplyUnoriented_Hip(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Hip_Core(rstr, t_mode, false, false, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Hip_Core(rstr, t_mode, false, false, u, v, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/hip-ref/ceed-hip-ref-vector.c b/backends/hip-ref/ceed-hip-ref-vector.c index e444b0c5a8..f009678a7d 100644 --- a/backends/hip-ref/ceed-hip-ref-vector.c +++ b/backends/hip-ref/ceed-hip-ref-vector.c @@ -111,9 +111,11 @@ static int CeedVectorSyncArray_Hip(const CeedVector vec, CeedMemType mem_type) { switch (mem_type) { case CEED_MEM_HOST: - return CeedVectorSyncD2H_Hip(vec); + CeedCallBackend(CeedVectorSyncD2H_Hip(vec)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedVectorSyncH2D_Hip(vec); + CeedCallBackend(CeedVectorSyncH2D_Hip(vec)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -265,12 +267,15 @@ static int CeedVectorSetArray_Hip(const CeedVector vec, const CeedMemType mem_ty switch (mem_type) { case CEED_MEM_HOST: if (impl->has_unified_addressing) { - return CeedVectorSetArrayUnifiedHostToDevice_Hip(vec, copy_mode, array); + CeedCallBackend(CeedVectorSetArrayUnifiedHostToDevice_Hip(vec, copy_mode, array)); + return CEED_ERROR_SUCCESS; } else { - return CeedVectorSetArrayHost_Hip(vec, copy_mode, array); + CeedCallBackend(CeedVectorSetArrayHost_Hip(vec, copy_mode, array)); + return CEED_ERROR_SUCCESS; } case CEED_MEM_DEVICE: - return CeedVectorSetArrayDevice_Hip(vec, copy_mode, array); + CeedCallBackend(CeedVectorSetArrayDevice_Hip(vec, copy_mode, array)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -489,7 +494,8 @@ static int CeedVectorGetArrayCore_Hip(const CeedVector vec, CeedMemType mem_type // Get read-only access to a vector via the specified mem_type //------------------------------------------------------------------------------ static int CeedVectorGetArrayRead_Hip(const CeedVector vec, const CeedMemType mem_type, const CeedScalar **array) { - return CeedVectorGetArrayCore_Hip(vec, mem_type, (CeedScalar **)array); + CeedCallBackend(CeedVectorGetArrayCore_Hip(vec, mem_type, (CeedScalar **)array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -554,7 +560,8 @@ static int CeedVectorGetArrayWrite_Hip(const CeedVector vec, CeedMemType mem_typ } } } - return CeedVectorGetArray_Hip(vec, mem_type, array); + CeedCallBackend(CeedVectorGetArray_Hip(vec, mem_type, array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/opt/ceed-opt-operator.c b/backends/opt/ceed-opt-operator.c index 0c160b1b57..8abceab8e1 100644 --- a/backends/opt/ceed-opt-operator.c +++ b/backends/opt/ceed-opt-operator.c @@ -742,14 +742,16 @@ static inline int CeedOperatorLinearAssembleQFunctionCore_Opt(CeedOperator op, b // Assemble Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunction_Opt(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Opt(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Opt(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ // Update Assembled Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionUpdate_Opt(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Opt(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Opt(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/opt/ceed-opt-tensor.c b/backends/opt/ceed-opt-tensor.c index d3562caf4e..b032558172 100644 --- a/backends/opt/ceed-opt-tensor.c +++ b/backends/opt/ceed-opt-tensor.c @@ -44,9 +44,11 @@ static int CeedTensorContractApply_Opt(CeedTensorContract contract, CeedInt A, C } if (C == 1) { - return CeedTensorContractApply_Core_Opt(contract, A, B, 1, J, t, t_mode, add, u, v); + CeedCallBackend(CeedTensorContractApply_Core_Opt(contract, A, B, 1, J, t, t_mode, add, u, v)); + return CEED_ERROR_SUCCESS; } else { - return CeedTensorContractApply_Core_Opt(contract, A, B, C, J, t, t_mode, add, u, v); + CeedCallBackend(CeedTensorContractApply_Core_Opt(contract, A, B, C, J, t, t_mode, add, u, v)); + return CEED_ERROR_SUCCESS; } return CEED_ERROR_SUCCESS; } diff --git a/backends/ref/ceed-ref-operator.c b/backends/ref/ceed-ref-operator.c index a9e0303cbd..5bdd80d0b3 100644 --- a/backends/ref/ceed-ref-operator.c +++ b/backends/ref/ceed-ref-operator.c @@ -669,14 +669,16 @@ static inline int CeedOperatorLinearAssembleQFunctionCore_Ref(CeedOperator op, b // Assemble Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunction_Ref(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Ref(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Ref(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ // Update Assembled Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionUpdate_Ref(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Ref(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Ref(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -1335,7 +1337,8 @@ static inline int CeedOperatorLinearAssembleQFunctionAtPointsCore_Ref(CeedOperat // Assemble Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionAtPoints_Ref(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionAtPointsCore_Ref(op, true, assembled, rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionAtPointsCore_Ref(op, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -1343,7 +1346,8 @@ static int CeedOperatorLinearAssembleQFunctionAtPoints_Ref(CeedOperator op, Ceed //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionAtPointsUpdate_Ref(CeedOperator op, CeedVector assembled, CeedElemRestriction rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionAtPointsCore_Ref(op, false, &assembled, &rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionAtPointsCore_Ref(op, false, &assembled, &rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/ref/ceed-ref-restriction.c b/backends/ref/ceed-ref-restriction.c index de65e5854b..29cfa038cc 100644 --- a/backends/ref/ceed-ref-restriction.c +++ b/backends/ref/ceed-ref-restriction.c @@ -508,101 +508,117 @@ static inline int CeedElemRestrictionApply_Ref_Core(CeedElemRestriction rstr, co static int CeedElemRestrictionApply_Ref_110(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 1, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 1, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_111(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 1, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 1, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_180(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 1, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 1, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_181(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 1, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 1, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_310(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 3, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 3, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_311(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 3, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 3, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_380(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 3, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 3, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_381(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 3, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 3, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START static int CeedElemRestrictionApply_Ref_410(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 4, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 4, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_411(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 4, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 4, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_480(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 4, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 4, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_481(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 4, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 4, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } static int CeedElemRestrictionApply_Ref_510(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 5, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 5, 1, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_STOP static int CeedElemRestrictionApply_Ref_511(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 5, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 5, 1, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START static int CeedElemRestrictionApply_Ref_580(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 5, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 5, 8, comp_stride, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_STOP static int CeedElemRestrictionApply_Ref_581(CeedElemRestriction rstr, const CeedInt num_comp, const CeedInt block_size, const CeedInt comp_stride, CeedInt start, CeedInt stop, CeedTransposeMode t_mode, bool use_signs, bool use_orients, CeedVector u, CeedVector v, CeedRequest *request) { - return CeedElemRestrictionApply_Ref_Core(rstr, 5, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request); + CeedCallBackend(CeedElemRestrictionApply_Ref_Core(rstr, 5, 8, 1, start, stop, t_mode, use_signs, use_orients, u, v, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/ref/ceed-ref-vector.c b/backends/ref/ceed-ref-vector.c index 520afdd61a..55a2e761f1 100644 --- a/backends/ref/ceed-ref-vector.c +++ b/backends/ref/ceed-ref-vector.c @@ -87,14 +87,16 @@ static int CeedVectorGetArrayCore_Ref(CeedVector vec, CeedMemType mem_type, Ceed // Vector Get Array Read //------------------------------------------------------------------------------ static int CeedVectorGetArrayRead_Ref(CeedVector vec, CeedMemType mem_type, const CeedScalar **array) { - return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); + CeedCallBackend(CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ // Vector Get Array //------------------------------------------------------------------------------ static int CeedVectorGetArray_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { - return CeedVectorGetArrayCore_Ref(vec, mem_type, array); + CeedCallBackend(CeedVectorGetArrayCore_Ref(vec, mem_type, array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -106,7 +108,8 @@ static int CeedVectorGetArrayWrite_Ref(CeedVector vec, CeedMemType mem_type, Cee CeedCallBackend(CeedVectorGetData(vec, &impl)); if (!impl->array) CeedCallBackend(CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL)); - return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); + CeedCallBackend(CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp b/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp index e1d2052eb9..ff293826b8 100644 --- a/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp +++ b/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp @@ -619,7 +619,8 @@ static inline int CeedOperatorLinearAssembleQFunctionCore_Sycl(CeedOperator op, // Assemble Linear QFunction //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunction_Sycl(CeedOperator op, CeedVector *assembled, CeedElemRestriction *elem_rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Sycl(op, true, assembled, elem_rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Sycl(op, true, assembled, elem_rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -627,7 +628,8 @@ static int CeedOperatorLinearAssembleQFunction_Sycl(CeedOperator op, CeedVector //------------------------------------------------------------------------------ static int CeedOperatorLinearAssembleQFunctionUpdate_Sycl(CeedOperator op, CeedVector assembled, CeedElemRestriction elem_rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionCore_Sycl(op, false, &assembled, &elem_rstr, request); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionCore_Sycl(op, false, &assembled, &elem_rstr, request)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/sycl-ref/ceed-sycl-ref-qfunctioncontext.sycl.cpp b/backends/sycl-ref/ceed-sycl-ref-qfunctioncontext.sycl.cpp index 1a08c26cb5..a1a837c34c 100644 --- a/backends/sycl-ref/ceed-sycl-ref-qfunctioncontext.sycl.cpp +++ b/backends/sycl-ref/ceed-sycl-ref-qfunctioncontext.sycl.cpp @@ -86,9 +86,11 @@ static inline int CeedQFunctionContextSyncD2H_Sycl(const CeedQFunctionContext ct static inline int CeedQFunctionContextSync_Sycl(const CeedQFunctionContext ctx, CeedMemType mem_type) { switch (mem_type) { case CEED_MEM_HOST: - return CeedQFunctionContextSyncD2H_Sycl(ctx); + CeedCallBackend(CeedQFunctionContextSyncD2H_Sycl(ctx)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedQFunctionContextSyncH2D_Sycl(ctx); + CeedCallBackend(CeedQFunctionContextSyncH2D_Sycl(ctx)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -245,9 +247,11 @@ static int CeedQFunctionContextSetData_Sycl(const CeedQFunctionContext ctx, cons CeedCallBackend(CeedQFunctionContextSetAllInvalid_Sycl(ctx)); switch (mem_type) { case CEED_MEM_HOST: - return CeedQFunctionContextSetDataHost_Sycl(ctx, copy_mode, data); + CeedCallBackend(CeedQFunctionContextSetDataHost_Sycl(ctx, copy_mode, data)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedQFunctionContextSetDataDevice_Sycl(ctx, copy_mode, data); + CeedCallBackend(CeedQFunctionContextSetDataDevice_Sycl(ctx, copy_mode, data)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -321,7 +325,8 @@ static int CeedQFunctionContextGetDataCore_Sycl(const CeedQFunctionContext ctx, // Get read-only access to the data //------------------------------------------------------------------------------ static int CeedQFunctionContextGetDataRead_Sycl(const CeedQFunctionContext ctx, const CeedMemType mem_type, void *data) { - return CeedQFunctionContextGetDataCore_Sycl(ctx, mem_type, data); + CeedCallBackend(CeedQFunctionContextGetDataCore_Sycl(ctx, mem_type, data)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/sycl-ref/ceed-sycl-vector.sycl.cpp b/backends/sycl-ref/ceed-sycl-vector.sycl.cpp index 9ceb252436..f84f4d5c1c 100644 --- a/backends/sycl-ref/ceed-sycl-vector.sycl.cpp +++ b/backends/sycl-ref/ceed-sycl-vector.sycl.cpp @@ -114,9 +114,11 @@ static int CeedVectorSyncArray_Sycl(const CeedVector vec, CeedMemType mem_type) switch (mem_type) { case CEED_MEM_HOST: - return CeedVectorSyncD2H_Sycl(vec); + CeedCallBackend(CeedVectorSyncD2H_Sycl(vec)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedVectorSyncH2D_Sycl(vec); + CeedCallBackend(CeedVectorSyncH2D_Sycl(vec)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -265,9 +267,11 @@ static int CeedVectorSetArray_Sycl(const CeedVector vec, const CeedMemType mem_t CeedCallBackend(CeedVectorSetAllInvalid_Sycl(vec)); switch (mem_type) { case CEED_MEM_HOST: - return CeedVectorSetArrayHost_Sycl(vec, copy_mode, array); + CeedCallBackend(CeedVectorSetArrayHost_Sycl(vec, copy_mode, array)); + return CEED_ERROR_SUCCESS; case CEED_MEM_DEVICE: - return CeedVectorSetArrayDevice_Sycl(vec, copy_mode, array); + CeedCallBackend(CeedVectorSetArrayDevice_Sycl(vec, copy_mode, array)); + return CEED_ERROR_SUCCESS; } // LCOV_EXCL_START return CEED_ERROR_UNSUPPORTED; @@ -397,7 +401,8 @@ static int CeedVectorGetArrayCore_Sycl(const CeedVector vec, const CeedMemType m // Get read-only access to a vector via the specified mem_type //------------------------------------------------------------------------------ static int CeedVectorGetArrayRead_Sycl(const CeedVector vec, const CeedMemType mem_type, const CeedScalar **array) { - return CeedVectorGetArrayCore_Sycl(vec, mem_type, (CeedScalar **)array); + CeedCallBackend(CeedVectorGetArrayCore_Sycl(vec, mem_type, (CeedScalar **)array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ @@ -448,7 +453,8 @@ static int CeedVectorGetArrayWrite_Sycl(const CeedVector vec, const CeedMemType impl->d_array = impl->d_array_owned; } } - return CeedVectorGetArray_Sycl(vec, mem_type, array); + CeedCallBackend(CeedVectorGetArray_Sycl(vec, mem_type, array)); + return CEED_ERROR_SUCCESS; } //------------------------------------------------------------------------------ diff --git a/backends/sycl/ceed-sycl-common.hpp b/backends/sycl/ceed-sycl-common.hpp index f087f8c29a..a83802d157 100644 --- a/backends/sycl/ceed-sycl-common.hpp +++ b/backends/sycl/ceed-sycl-common.hpp @@ -28,7 +28,8 @@ int CeedSetBackendFunctionCpp(Ceed ceed, const char *type, void *object, const c static_assert(std::is_same_v, "Ceed backend functions must return int"); // Kris: this is potentially undefined behavior by C++ standards auto *bf = reinterpret_cast(f); - return CeedSetBackendFunction(ceed, type, object, fname, bf); + CeedCallBackend(CeedSetBackendFunction(ceed, type, object, fname, bf)); + return CEED_ERROR_SUCCESS; } typedef struct { diff --git a/interface/ceed-elemrestriction.c b/interface/ceed-elemrestriction.c index aa835fbb23..f41e253afc 100644 --- a/interface/ceed-elemrestriction.c +++ b/interface/ceed-elemrestriction.c @@ -1615,7 +1615,8 @@ int CeedElemRestrictionGetMinMaxPointsInElement(CeedElemRestriction rstr, CeedIn @see CeedElemRestrictionGetMinMaxPointsInElement() **/ int CeedElemRestrictionGetMaxPointsInElement(CeedElemRestriction rstr, CeedInt *max_points) { - return CeedElemRestrictionGetMinMaxPointsInElement(rstr, NULL, max_points); + CeedCall(CeedElemRestrictionGetMinMaxPointsInElement(rstr, NULL, max_points)); + return CEED_ERROR_SUCCESS; } /** @@ -1631,7 +1632,8 @@ int CeedElemRestrictionGetMaxPointsInElement(CeedElemRestriction rstr, CeedInt * @see CeedElemRestrictionGetMinMaxPointsInElement() **/ int CeedElemRestrictionGetMinPointsInElement(CeedElemRestriction rstr, CeedInt *min_points) { - return CeedElemRestrictionGetMinMaxPointsInElement(rstr, min_points, NULL); + CeedCall(CeedElemRestrictionGetMinMaxPointsInElement(rstr, min_points, NULL)); + return CEED_ERROR_SUCCESS; } /** diff --git a/interface/ceed-operator.c b/interface/ceed-operator.c index e54bf667a0..8e093464eb 100644 --- a/interface/ceed-operator.c +++ b/interface/ceed-operator.c @@ -2115,7 +2115,8 @@ int CeedOperatorGetContextFieldLabel(CeedOperator op, const char *field_name, Ce @ref User **/ int CeedOperatorSetContextDouble(CeedOperator op, CeedContextFieldLabel field_label, double *values) { - return CeedOperatorContextSetGeneric(op, field_label, CEED_CONTEXT_FIELD_DOUBLE, values); + CeedCall(CeedOperatorContextSetGeneric(op, field_label, CEED_CONTEXT_FIELD_DOUBLE, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2133,7 +2134,8 @@ int CeedOperatorSetContextDouble(CeedOperator op, CeedContextFieldLabel field_la @ref User **/ int CeedOperatorGetContextDoubleRead(CeedOperator op, CeedContextFieldLabel field_label, size_t *num_values, const double **values) { - return CeedOperatorContextGetGenericRead(op, field_label, CEED_CONTEXT_FIELD_DOUBLE, num_values, values); + CeedCall(CeedOperatorContextGetGenericRead(op, field_label, CEED_CONTEXT_FIELD_DOUBLE, num_values, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2148,7 +2150,8 @@ int CeedOperatorGetContextDoubleRead(CeedOperator op, CeedContextFieldLabel fiel @ref User **/ int CeedOperatorRestoreContextDoubleRead(CeedOperator op, CeedContextFieldLabel field_label, const double **values) { - return CeedOperatorContextRestoreGenericRead(op, field_label, CEED_CONTEXT_FIELD_DOUBLE, values); + CeedCall(CeedOperatorContextRestoreGenericRead(op, field_label, CEED_CONTEXT_FIELD_DOUBLE, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2165,7 +2168,8 @@ int CeedOperatorRestoreContextDoubleRead(CeedOperator op, CeedContextFieldLabel @ref User **/ int CeedOperatorSetContextInt32(CeedOperator op, CeedContextFieldLabel field_label, int32_t *values) { - return CeedOperatorContextSetGeneric(op, field_label, CEED_CONTEXT_FIELD_INT32, values); + CeedCall(CeedOperatorContextSetGeneric(op, field_label, CEED_CONTEXT_FIELD_INT32, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2183,7 +2187,8 @@ int CeedOperatorSetContextInt32(CeedOperator op, CeedContextFieldLabel field_lab @ref User **/ int CeedOperatorGetContextInt32Read(CeedOperator op, CeedContextFieldLabel field_label, size_t *num_values, const int32_t **values) { - return CeedOperatorContextGetGenericRead(op, field_label, CEED_CONTEXT_FIELD_INT32, num_values, values); + CeedCall(CeedOperatorContextGetGenericRead(op, field_label, CEED_CONTEXT_FIELD_INT32, num_values, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2198,7 +2203,8 @@ int CeedOperatorGetContextInt32Read(CeedOperator op, CeedContextFieldLabel field @ref User **/ int CeedOperatorRestoreContextInt32Read(CeedOperator op, CeedContextFieldLabel field_label, const int32_t **values) { - return CeedOperatorContextRestoreGenericRead(op, field_label, CEED_CONTEXT_FIELD_INT32, values); + CeedCall(CeedOperatorContextRestoreGenericRead(op, field_label, CEED_CONTEXT_FIELD_INT32, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2215,7 +2221,8 @@ int CeedOperatorRestoreContextInt32Read(CeedOperator op, CeedContextFieldLabel f @ref User **/ int CeedOperatorSetContextBoolean(CeedOperator op, CeedContextFieldLabel field_label, bool *values) { - return CeedOperatorContextSetGeneric(op, field_label, CEED_CONTEXT_FIELD_BOOL, values); + CeedCall(CeedOperatorContextSetGeneric(op, field_label, CEED_CONTEXT_FIELD_BOOL, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2233,7 +2240,8 @@ int CeedOperatorSetContextBoolean(CeedOperator op, CeedContextFieldLabel field_l @ref User **/ int CeedOperatorGetContextBooleanRead(CeedOperator op, CeedContextFieldLabel field_label, size_t *num_values, const bool **values) { - return CeedOperatorContextGetGenericRead(op, field_label, CEED_CONTEXT_FIELD_BOOL, num_values, values); + CeedCall(CeedOperatorContextGetGenericRead(op, field_label, CEED_CONTEXT_FIELD_BOOL, num_values, values)); + return CEED_ERROR_SUCCESS; } /** @@ -2248,7 +2256,8 @@ int CeedOperatorGetContextBooleanRead(CeedOperator op, CeedContextFieldLabel fie @ref User **/ int CeedOperatorRestoreContextBooleanRead(CeedOperator op, CeedContextFieldLabel field_label, const bool **values) { - return CeedOperatorContextRestoreGenericRead(op, field_label, CEED_CONTEXT_FIELD_BOOL, values); + CeedCall(CeedOperatorContextRestoreGenericRead(op, field_label, CEED_CONTEXT_FIELD_BOOL, values)); + return CEED_ERROR_SUCCESS; } /** diff --git a/interface/ceed-preconditioning.c b/interface/ceed-preconditioning.c index d3376aec0f..ebc6d0db36 100644 --- a/interface/ceed-preconditioning.c +++ b/interface/ceed-preconditioning.c @@ -823,7 +823,8 @@ static int CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(CeedOperator op **/ int CeedOperatorLinearAssembleQFunctionBuildOrUpdateFallback(CeedOperator op, bool build_objects, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { - return CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(op, build_objects, false, assembled, rstr, request); + CeedCall(CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(op, build_objects, false, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } /** @@ -2372,7 +2373,8 @@ int CeedOperatorLinearAssembleQFunction(CeedOperator op, CeedVector *assembled, **/ int CeedOperatorLinearAssembleQFunctionBuildOrUpdate(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { assert(assembled); - return CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(op, *assembled == NULL, true, assembled, rstr, request); + CeedCall(CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(op, *assembled == NULL, true, assembled, rstr, request)); + return CEED_ERROR_SUCCESS; } /** diff --git a/interface/ceed-qfunctioncontext.c b/interface/ceed-qfunctioncontext.c index 48563a9999..ed47978c2d 100644 --- a/interface/ceed-qfunctioncontext.c +++ b/interface/ceed-qfunctioncontext.c @@ -813,7 +813,8 @@ int CeedQFunctionContextRestoreDataRead(CeedQFunctionContext ctx, void *data) { **/ int CeedQFunctionContextRegisterDouble(CeedQFunctionContext ctx, const char *field_name, size_t field_offset, size_t num_values, const char *field_description) { - return CeedQFunctionContextRegisterGeneric(ctx, field_name, field_offset, field_description, CEED_CONTEXT_FIELD_DOUBLE, num_values); + CeedCall(CeedQFunctionContextRegisterGeneric(ctx, field_name, field_offset, field_description, CEED_CONTEXT_FIELD_DOUBLE, num_values)); + return CEED_ERROR_SUCCESS; } /** @@ -831,7 +832,8 @@ int CeedQFunctionContextRegisterDouble(CeedQFunctionContext ctx, const char *fie **/ int CeedQFunctionContextRegisterInt32(CeedQFunctionContext ctx, const char *field_name, size_t field_offset, size_t num_values, const char *field_description) { - return CeedQFunctionContextRegisterGeneric(ctx, field_name, field_offset, field_description, CEED_CONTEXT_FIELD_INT32, num_values); + CeedCall(CeedQFunctionContextRegisterGeneric(ctx, field_name, field_offset, field_description, CEED_CONTEXT_FIELD_INT32, num_values)); + return CEED_ERROR_SUCCESS; } /** @@ -849,7 +851,8 @@ int CeedQFunctionContextRegisterInt32(CeedQFunctionContext ctx, const char *fiel **/ int CeedQFunctionContextRegisterBoolean(CeedQFunctionContext ctx, const char *field_name, size_t field_offset, size_t num_values, const char *field_description) { - return CeedQFunctionContextRegisterGeneric(ctx, field_name, field_offset, field_description, CEED_CONTEXT_FIELD_BOOL, num_values); + CeedCall(CeedQFunctionContextRegisterGeneric(ctx, field_name, field_offset, field_description, CEED_CONTEXT_FIELD_BOOL, num_values)); + return CEED_ERROR_SUCCESS; } /**