1 // Copyright (c) 2017-2022, Lawrence Livermore National Security, LLC and other CEED contributors. 2 // All Rights Reserved. See the top-level LICENSE and NOTICE files for details. 3 // 4 // SPDX-License-Identifier: BSD-2-Clause 5 // 6 // This file is part of CEED: http://github.com/ceed 7 8 #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 switch (copy_mode) { 52 case CEED_COPY_VALUES: 53 if (!impl->array_owned) CeedCallBackend(CeedCalloc(length, &impl->array_owned)); 54 if (array) memcpy(impl->array_owned, array, length * sizeof(array[0])); 55 impl->array_borrowed = NULL; 56 impl->array = impl->array_owned; 57 break; 58 case CEED_OWN_POINTER: 59 CeedCallBackend(CeedFree(&impl->array_owned)); 60 impl->array_owned = array; 61 impl->array_borrowed = NULL; 62 impl->array = array; 63 break; 64 case CEED_USE_POINTER: 65 CeedCallBackend(CeedFree(&impl->array_owned)); 66 impl->array_borrowed = array; 67 impl->array = array; 68 } 69 return CEED_ERROR_SUCCESS; 70 } 71 72 //------------------------------------------------------------------------------ 73 // Vector Take Array 74 //------------------------------------------------------------------------------ 75 static int CeedVectorTakeArray_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_borrowed; 83 impl->array_borrowed = NULL; 84 impl->array = NULL; 85 return CEED_ERROR_SUCCESS; 86 } 87 88 //------------------------------------------------------------------------------ 89 // Vector Get Array 90 //------------------------------------------------------------------------------ 91 static int CeedVectorGetArrayCore_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 92 CeedVector_Ref *impl; 93 94 CeedCallBackend(CeedVectorGetData(vec, &impl)); 95 96 CeedCheck(mem_type == CEED_MEM_HOST, CeedVectorReturnCeed(vec), CEED_ERROR_BACKEND, "Can only provide HOST memory for this backend"); 97 98 *array = impl->array; 99 return CEED_ERROR_SUCCESS; 100 } 101 102 //------------------------------------------------------------------------------ 103 // Vector Get Array Read 104 //------------------------------------------------------------------------------ 105 static int CeedVectorGetArrayRead_Ref(CeedVector vec, CeedMemType mem_type, const CeedScalar **array) { 106 return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); 107 } 108 109 //------------------------------------------------------------------------------ 110 // Vector Get Array 111 //------------------------------------------------------------------------------ 112 static int CeedVectorGetArray_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 113 return CeedVectorGetArrayCore_Ref(vec, mem_type, array); 114 } 115 116 //------------------------------------------------------------------------------ 117 // Vector Get Array Write 118 //------------------------------------------------------------------------------ 119 static int CeedVectorGetArrayWrite_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 120 CeedVector_Ref *impl; 121 122 CeedCallBackend(CeedVectorGetData(vec, &impl)); 123 124 if (!impl->array) CeedCallBackend(CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL)); 125 return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); 126 } 127 128 //------------------------------------------------------------------------------ 129 // Vector Restore Array 130 //------------------------------------------------------------------------------ 131 static int CeedVectorRestoreArray_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 132 133 //------------------------------------------------------------------------------ 134 // Vector Restore Array Read 135 //------------------------------------------------------------------------------ 136 static int CeedVectorRestoreArrayRead_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 137 138 //------------------------------------------------------------------------------ 139 // Vector Destroy 140 //------------------------------------------------------------------------------ 141 static int CeedVectorDestroy_Ref(CeedVector vec) { 142 CeedVector_Ref *impl; 143 144 CeedCallBackend(CeedVectorGetData(vec, &impl)); 145 CeedCallBackend(CeedFree(&impl->array_owned)); 146 CeedCallBackend(CeedFree(&impl)); 147 return CEED_ERROR_SUCCESS; 148 } 149 150 //------------------------------------------------------------------------------ 151 // Vector Create 152 //------------------------------------------------------------------------------ 153 int CeedVectorCreate_Ref(CeedSize n, CeedVector vec) { 154 Ceed ceed; 155 CeedVector_Ref *impl; 156 157 CeedCallBackend(CeedVectorGetCeed(vec, &ceed)); 158 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasValidArray", CeedVectorHasValidArray_Ref)); 159 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasBorrowedArrayOfType", CeedVectorHasBorrowedArrayOfType_Ref)); 160 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "SetArray", CeedVectorSetArray_Ref)); 161 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "TakeArray", CeedVectorTakeArray_Ref)); 162 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArray", CeedVectorGetArray_Ref)); 163 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayRead", CeedVectorGetArrayRead_Ref)); 164 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayWrite", CeedVectorGetArrayWrite_Ref)); 165 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArray", CeedVectorRestoreArray_Ref)); 166 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArrayRead", CeedVectorRestoreArrayRead_Ref)); 167 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "Destroy", CeedVectorDestroy_Ref)); 168 CeedCallBackend(CeedCalloc(1, &impl)); 169 CeedCallBackend(CeedVectorSetData(vec, impl)); 170 return CEED_ERROR_SUCCESS; 171 } 172 173 //------------------------------------------------------------------------------ 174