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) { 54 CeedCallBackend(CeedCalloc(length, &impl->array_owned)); 55 } 56 impl->array_borrowed = NULL; 57 impl->array = impl->array_owned; 58 if (array) memcpy(impl->array, array, length * sizeof(array[0])); 59 break; 60 case CEED_OWN_POINTER: 61 CeedCallBackend(CeedFree(&impl->array_owned)); 62 impl->array_owned = array; 63 impl->array_borrowed = NULL; 64 impl->array = array; 65 break; 66 case CEED_USE_POINTER: 67 CeedCallBackend(CeedFree(&impl->array_owned)); 68 impl->array_borrowed = array; 69 impl->array = array; 70 } 71 return CEED_ERROR_SUCCESS; 72 } 73 74 //------------------------------------------------------------------------------ 75 // Vector Take Array 76 //------------------------------------------------------------------------------ 77 static int CeedVectorTakeArray_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 78 CeedVector_Ref *impl; 79 80 CeedCallBackend(CeedVectorGetData(vec, &impl)); 81 82 CeedCheck(mem_type == CEED_MEM_HOST, CeedVectorReturnCeed(vec), CEED_ERROR_BACKEND, "Can only provide HOST memory for this backend"); 83 84 (*array) = impl->array_borrowed; 85 impl->array_borrowed = NULL; 86 impl->array = NULL; 87 return CEED_ERROR_SUCCESS; 88 } 89 90 //------------------------------------------------------------------------------ 91 // Vector Get Array 92 //------------------------------------------------------------------------------ 93 static int CeedVectorGetArrayCore_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 94 CeedVector_Ref *impl; 95 96 CeedCallBackend(CeedVectorGetData(vec, &impl)); 97 98 CeedCheck(mem_type == CEED_MEM_HOST, CeedVectorReturnCeed(vec), CEED_ERROR_BACKEND, "Can only provide HOST memory for this backend"); 99 100 *array = impl->array; 101 return CEED_ERROR_SUCCESS; 102 } 103 104 //------------------------------------------------------------------------------ 105 // Vector Get Array Read 106 //------------------------------------------------------------------------------ 107 static int CeedVectorGetArrayRead_Ref(CeedVector vec, CeedMemType mem_type, const CeedScalar **array) { 108 return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); 109 } 110 111 //------------------------------------------------------------------------------ 112 // Vector Get Array 113 //------------------------------------------------------------------------------ 114 static int CeedVectorGetArray_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 115 return CeedVectorGetArrayCore_Ref(vec, mem_type, array); 116 } 117 118 //------------------------------------------------------------------------------ 119 // Vector Get Array Write 120 //------------------------------------------------------------------------------ 121 static int CeedVectorGetArrayWrite_Ref(CeedVector vec, CeedMemType mem_type, CeedScalar **array) { 122 CeedVector_Ref *impl; 123 124 CeedCallBackend(CeedVectorGetData(vec, &impl)); 125 126 if (!impl->array) { 127 if (!impl->array_owned && !impl->array_borrowed) { 128 // Allocate if array is not yet allocated 129 CeedCallBackend(CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL)); 130 } else { 131 // Select dirty array for GetArrayWrite 132 if (impl->array_borrowed) impl->array = impl->array_borrowed; 133 else impl->array = impl->array_owned; 134 } 135 } 136 return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); 137 } 138 139 //------------------------------------------------------------------------------ 140 // Vector Restore Array 141 //------------------------------------------------------------------------------ 142 static int CeedVectorRestoreArray_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 143 144 //------------------------------------------------------------------------------ 145 // Vector Restore Array Read 146 //------------------------------------------------------------------------------ 147 static int CeedVectorRestoreArrayRead_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 148 149 //------------------------------------------------------------------------------ 150 // Vector Destroy 151 //------------------------------------------------------------------------------ 152 static int CeedVectorDestroy_Ref(CeedVector vec) { 153 CeedVector_Ref *impl; 154 155 CeedCallBackend(CeedVectorGetData(vec, &impl)); 156 CeedCallBackend(CeedFree(&impl->array_owned)); 157 CeedCallBackend(CeedFree(&impl)); 158 return CEED_ERROR_SUCCESS; 159 } 160 161 //------------------------------------------------------------------------------ 162 // Vector Create 163 //------------------------------------------------------------------------------ 164 int CeedVectorCreate_Ref(CeedSize n, CeedVector vec) { 165 Ceed ceed; 166 CeedVector_Ref *impl; 167 168 CeedCallBackend(CeedVectorGetCeed(vec, &ceed)); 169 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasValidArray", CeedVectorHasValidArray_Ref)); 170 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasBorrowedArrayOfType", CeedVectorHasBorrowedArrayOfType_Ref)); 171 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "SetArray", CeedVectorSetArray_Ref)); 172 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "TakeArray", CeedVectorTakeArray_Ref)); 173 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArray", CeedVectorGetArray_Ref)); 174 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayRead", CeedVectorGetArrayRead_Ref)); 175 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayWrite", CeedVectorGetArrayWrite_Ref)); 176 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArray", CeedVectorRestoreArray_Ref)); 177 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArrayRead", CeedVectorRestoreArrayRead_Ref)); 178 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "Destroy", CeedVectorDestroy_Ref)); 179 CeedCallBackend(CeedCalloc(1, &impl)); 180 CeedCallBackend(CeedVectorSetData(vec, impl)); 181 return CEED_ERROR_SUCCESS; 182 } 183 184 //------------------------------------------------------------------------------ 185