1 // Copyright (c) 2017-2018, Lawrence Livermore National Security, LLC. 2 // Produced at the Lawrence Livermore National Laboratory. LLNL-CODE-734707. 3 // All Rights reserved. See files LICENSE and NOTICE for details. 4 // 5 // This file is part of CEED, a collection of benchmarks, miniapps, software 6 // libraries and APIs for efficient high-order finite element and spectral 7 // element discretizations for exascale applications. For more information and 8 // source code availability see http://github.com/ceed. 9 // 10 // The CEED research is supported by the Exascale Computing Project 17-SC-20-SC, 11 // a collaborative effort of two U.S. Department of Energy organizations (Office 12 // of Science and the National Nuclear Security Administration) responsible for 13 // the planning and preparation of a capable exascale ecosystem, including 14 // software, applications, hardware, advanced system engineering and early 15 // testbed platforms, in support of the nation's exascale computing imperative. 16 17 #include "ceed-ref.h" 18 19 //------------------------------------------------------------------------------ 20 // Vector Set Array 21 //------------------------------------------------------------------------------ 22 static int CeedVectorSetArray_Ref(CeedVector vec, CeedMemType mtype, 23 CeedCopyMode cmode, CeedScalar *array) { 24 int ierr; 25 CeedVector_Ref *impl; 26 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 27 CeedInt length; 28 ierr = CeedVectorGetLength(vec, &length); CeedChk(ierr); 29 Ceed ceed; 30 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 31 32 if (mtype != CEED_MEM_HOST) 33 // LCOV_EXCL_START 34 return CeedError(ceed, 1, "Only MemType = HOST supported"); 35 // LCOV_EXCL_STOP 36 ierr = CeedFree(&impl->array_allocated); CeedChk(ierr); 37 switch (cmode) { 38 case CEED_COPY_VALUES: 39 ierr = CeedMalloc(length, &impl->array_allocated); CeedChk(ierr); 40 impl->array = impl->array_allocated; 41 if (array) memcpy(impl->array, array, length * sizeof(array[0])); 42 break; 43 case CEED_OWN_POINTER: 44 impl->array_allocated = array; 45 impl->array = array; 46 break; 47 case CEED_USE_POINTER: 48 impl->array = array; 49 } 50 return 0; 51 } 52 53 //------------------------------------------------------------------------------ 54 // Vector Take Array 55 //------------------------------------------------------------------------------ 56 static int CeedVectorTakeArray_Ref(CeedVector vec, CeedMemType mtype, 57 CeedScalar **array) { 58 int ierr; 59 CeedVector_Ref *impl; 60 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 61 Ceed ceed; 62 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 63 64 if (mtype != CEED_MEM_HOST) 65 // LCOV_EXCL_START 66 return CeedError(ceed, 1, "Only MemType = HOST supported"); 67 // LCOV_EXCL_STOP 68 69 (*array) = impl->array; 70 impl->array = NULL; 71 impl->array_allocated = NULL; 72 73 return 0; 74 } 75 76 //------------------------------------------------------------------------------ 77 // Vector Get Array 78 //------------------------------------------------------------------------------ 79 static int CeedVectorGetArray_Ref(CeedVector vec, CeedMemType mtype, 80 CeedScalar **array) { 81 int ierr; 82 CeedVector_Ref *impl; 83 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 84 Ceed ceed; 85 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 86 87 if (mtype != CEED_MEM_HOST) 88 // LCOV_EXCL_START 89 return CeedError(ceed, 1, "Can only provide to HOST memory"); 90 // LCOV_EXCL_STOP 91 if (!impl->array) { // Allocate if array is not yet allocated 92 ierr = CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL); 93 CeedChk(ierr); 94 } 95 *array = impl->array; 96 return 0; 97 } 98 99 //------------------------------------------------------------------------------ 100 // Vector Get Array Read 101 //------------------------------------------------------------------------------ 102 static int CeedVectorGetArrayRead_Ref(CeedVector vec, CeedMemType mtype, 103 const CeedScalar **array) { 104 int ierr; 105 CeedVector_Ref *impl; 106 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 107 Ceed ceed; 108 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 109 110 if (mtype != CEED_MEM_HOST) 111 // LCOV_EXCL_START 112 return CeedError(ceed, 1, "Can only provide to HOST memory"); 113 // LCOV_EXCL_STOP 114 if (!impl->array) { // Allocate if array is not yet allocated 115 ierr = CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL); 116 CeedChk(ierr); 117 } 118 *array = impl->array; 119 return 0; 120 } 121 122 //------------------------------------------------------------------------------ 123 // Vector Restore Array 124 //------------------------------------------------------------------------------ 125 static int CeedVectorRestoreArray_Ref(CeedVector vec) { 126 return 0; 127 } 128 129 static int CeedVectorRestoreArrayRead_Ref(CeedVector vec) { 130 return 0; 131 } 132 133 //------------------------------------------------------------------------------ 134 // Vector Destroy 135 //------------------------------------------------------------------------------ 136 static int CeedVectorDestroy_Ref(CeedVector vec) { 137 int ierr; 138 CeedVector_Ref *impl; 139 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 140 141 ierr = CeedFree(&impl->array_allocated); CeedChk(ierr); 142 ierr = CeedFree(&impl); CeedChk(ierr); 143 return 0; 144 } 145 146 //------------------------------------------------------------------------------ 147 // Vector Create 148 //------------------------------------------------------------------------------ 149 int CeedVectorCreate_Ref(CeedInt n, CeedVector vec) { 150 int ierr; 151 CeedVector_Ref *impl; 152 Ceed ceed; 153 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 154 155 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "SetArray", 156 CeedVectorSetArray_Ref); CeedChk(ierr); 157 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "TakeArray", 158 CeedVectorTakeArray_Ref); CeedChk(ierr); 159 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "GetArray", 160 CeedVectorGetArray_Ref); CeedChk(ierr); 161 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayRead", 162 CeedVectorGetArrayRead_Ref); CeedChk(ierr); 163 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArray", 164 CeedVectorRestoreArray_Ref); CeedChk(ierr); 165 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArrayRead", 166 CeedVectorRestoreArrayRead_Ref); CeedChk(ierr); 167 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "Destroy", 168 CeedVectorDestroy_Ref); CeedChk(ierr); 169 ierr = CeedCalloc(1,&impl); CeedChk(ierr); 170 ierr = CeedVectorSetData(vec, impl); CeedChk(ierr); 171 return 0; 172 } 173 //------------------------------------------------------------------------------ 174