1 // Copyright (c) 2017-2025, Lawrence Livermore National Security, LLC and other CEED contributors. 2 // All Rights Reserved. See the top-level LICENSE and NOTICE files for details. 3 // 4 // SPDX-License-Identifier: BSD-2-Clause 5 // 6 // This file is part of CEED: http://github.com/ceed 7 8 #include <ceed.h> 9 #include <ceed/backend.h> 10 #include <stdbool.h> 11 #include <string.h> 12 13 #include "ceed-ref.h" 14 15 //------------------------------------------------------------------------------ 16 // Has Valid Array 17 //------------------------------------------------------------------------------ 18 static int CeedVectorHasValidArray_Ref(CeedVector vec, bool *has_valid_array) { 19 CeedVector_Ref *impl; 20 21 CeedCallBackend(CeedVectorGetData(vec, &impl)); 22 23 *has_valid_array = impl->array; 24 return CEED_ERROR_SUCCESS; 25 } 26 27 //------------------------------------------------------------------------------ 28 // Check if has borrowed array of given type 29 //------------------------------------------------------------------------------ 30 static inline int CeedVectorHasBorrowedArrayOfType_Ref(const CeedVector vec, CeedMemType mem_type, bool *has_borrowed_array_of_type) { 31 CeedVector_Ref *impl; 32 33 CeedCallBackend(CeedVectorGetData(vec, &impl)); 34 CeedCheck(mem_type == CEED_MEM_HOST, CeedVectorReturnCeed(vec), CEED_ERROR_BACKEND, "Can only set HOST memory for this backend"); 35 *has_borrowed_array_of_type = impl->array_borrowed; 36 return CEED_ERROR_SUCCESS; 37 } 38 39 //------------------------------------------------------------------------------ 40 // Vector Set Array 41 //------------------------------------------------------------------------------ 42 static int CeedVectorSetArray_Ref(CeedVector vec, CeedMemType mem_type, CeedCopyMode copy_mode, CeedScalar *array) { 43 CeedSize length; 44 CeedVector_Ref *impl; 45 46 CeedCallBackend(CeedVectorGetData(vec, &impl)); 47 CeedCallBackend(CeedVectorGetLength(vec, &length)); 48 49 CeedCheck(mem_type == CEED_MEM_HOST, CeedVectorReturnCeed(vec), CEED_ERROR_BACKEND, "Can only set HOST memory for this backend"); 50 51 CeedCallBackend(CeedSetHostCeedScalarArray(array, copy_mode, length, (const CeedScalar **)&impl->array_owned, 52 (const CeedScalar **)&impl->array_borrowed, (const CeedScalar **)&impl->array)); 53 return CEED_ERROR_SUCCESS; 54 } 55 56 //------------------------------------------------------------------------------ 57 // Vector Take Array 58 //------------------------------------------------------------------------------ 59 static int CeedVectorTakeArray_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 60 CeedVector_Ref *impl; 61 62 CeedCallBackend(CeedVectorGetData(vec, &impl)); 63 64 CeedCheck(mem_type == CEED_MEM_HOST, CeedVectorReturnCeed(vec), CEED_ERROR_BACKEND, "Can only provide HOST memory for this backend"); 65 66 (*array) = impl->array_borrowed; 67 impl->array_borrowed = NULL; 68 impl->array = NULL; 69 return CEED_ERROR_SUCCESS; 70 } 71 72 //------------------------------------------------------------------------------ 73 // Vector Get Array 74 //------------------------------------------------------------------------------ 75 static int CeedVectorGetArrayCore_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 76 CeedVector_Ref *impl; 77 78 CeedCallBackend(CeedVectorGetData(vec, &impl)); 79 80 CeedCheck(mem_type == CEED_MEM_HOST, CeedVectorReturnCeed(vec), CEED_ERROR_BACKEND, "Can only provide HOST memory for this backend"); 81 82 *array = impl->array; 83 return CEED_ERROR_SUCCESS; 84 } 85 86 //------------------------------------------------------------------------------ 87 // Vector Get Array Read 88 //------------------------------------------------------------------------------ 89 static int CeedVectorGetArrayRead_Ref(CeedVector vec, CeedMemType mem_type, const CeedScalar **array) { 90 return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); 91 } 92 93 //------------------------------------------------------------------------------ 94 // Vector Get Array 95 //------------------------------------------------------------------------------ 96 static int CeedVectorGetArray_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 97 return CeedVectorGetArrayCore_Ref(vec, mem_type, array); 98 } 99 100 //------------------------------------------------------------------------------ 101 // Vector Get Array Write 102 //------------------------------------------------------------------------------ 103 static int CeedVectorGetArrayWrite_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 104 CeedVector_Ref *impl; 105 106 CeedCallBackend(CeedVectorGetData(vec, &impl)); 107 108 if (!impl->array) CeedCallBackend(CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL)); 109 return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); 110 } 111 112 //------------------------------------------------------------------------------ 113 // Vector Restore Array 114 //------------------------------------------------------------------------------ 115 static int CeedVectorRestoreArray_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 116 117 //------------------------------------------------------------------------------ 118 // Vector Restore Array Read 119 //------------------------------------------------------------------------------ 120 static int CeedVectorRestoreArrayRead_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 121 122 //------------------------------------------------------------------------------ 123 // Vector Destroy 124 //------------------------------------------------------------------------------ 125 static int CeedVectorDestroy_Ref(CeedVector vec) { 126 CeedVector_Ref *impl; 127 128 CeedCallBackend(CeedVectorGetData(vec, &impl)); 129 CeedCallBackend(CeedFree(&impl->array_owned)); 130 CeedCallBackend(CeedFree(&impl)); 131 return CEED_ERROR_SUCCESS; 132 } 133 134 //------------------------------------------------------------------------------ 135 // Vector Create 136 //------------------------------------------------------------------------------ 137 int CeedVectorCreate_Ref(CeedSize n, CeedVector vec) { 138 Ceed ceed; 139 CeedVector_Ref *impl; 140 141 CeedCallBackend(CeedVectorGetCeed(vec, &ceed)); 142 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasValidArray", CeedVectorHasValidArray_Ref)); 143 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasBorrowedArrayOfType", CeedVectorHasBorrowedArrayOfType_Ref)); 144 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "SetArray", CeedVectorSetArray_Ref)); 145 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "TakeArray", CeedVectorTakeArray_Ref)); 146 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArray", CeedVectorGetArray_Ref)); 147 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayRead", CeedVectorGetArrayRead_Ref)); 148 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayWrite", CeedVectorGetArrayWrite_Ref)); 149 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArray", CeedVectorRestoreArray_Ref)); 150 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArrayRead", CeedVectorRestoreArrayRead_Ref)); 151 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "Destroy", CeedVectorDestroy_Ref)); 152 CeedCallBackend(CeedDestroy(&ceed)); 153 CeedCallBackend(CeedCalloc(1, &impl)); 154 CeedCallBackend(CeedVectorSetData(vec, impl)); 155 return CEED_ERROR_SUCCESS; 156 } 157 158 //------------------------------------------------------------------------------ 159