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) CeedCallBackend(CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL)); 127 return CeedVectorGetArrayCore_Ref(vec, mem_type, (CeedScalar **)array); 128 } 129 130 //------------------------------------------------------------------------------ 131 // Vector Restore Array 132 //------------------------------------------------------------------------------ 133 static int CeedVectorRestoreArray_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 134 135 //------------------------------------------------------------------------------ 136 // Vector Restore Array Read 137 //------------------------------------------------------------------------------ 138 static int CeedVectorRestoreArrayRead_Ref(CeedVector vec) { return CEED_ERROR_SUCCESS; } 139 140 //------------------------------------------------------------------------------ 141 // Vector Destroy 142 //------------------------------------------------------------------------------ 143 static int CeedVectorDestroy_Ref(CeedVector vec) { 144 CeedVector_Ref *impl; 145 146 CeedCallBackend(CeedVectorGetData(vec, &impl)); 147 CeedCallBackend(CeedFree(&impl->array_owned)); 148 CeedCallBackend(CeedFree(&impl)); 149 return CEED_ERROR_SUCCESS; 150 } 151 152 //------------------------------------------------------------------------------ 153 // Vector Create 154 //------------------------------------------------------------------------------ 155 int CeedVectorCreate_Ref(CeedSize n, CeedVector vec) { 156 Ceed ceed; 157 CeedVector_Ref *impl; 158 159 CeedCallBackend(CeedVectorGetCeed(vec, &ceed)); 160 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasValidArray", CeedVectorHasValidArray_Ref)); 161 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "HasBorrowedArrayOfType", CeedVectorHasBorrowedArrayOfType_Ref)); 162 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "SetArray", CeedVectorSetArray_Ref)); 163 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "TakeArray", CeedVectorTakeArray_Ref)); 164 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArray", CeedVectorGetArray_Ref)); 165 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayRead", CeedVectorGetArrayRead_Ref)); 166 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayWrite", CeedVectorGetArrayWrite_Ref)); 167 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArray", CeedVectorRestoreArray_Ref)); 168 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArrayRead", CeedVectorRestoreArrayRead_Ref)); 169 CeedCallBackend(CeedSetBackendFunction(ceed, "Vector", vec, "Destroy", CeedVectorDestroy_Ref)); 170 CeedCallBackend(CeedCalloc(1, &impl)); 171 CeedCallBackend(CeedVectorSetData(vec, impl)); 172 return CEED_ERROR_SUCCESS; 173 } 174 175 //------------------------------------------------------------------------------ 176