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.h> 18 #include <ceed-backend.h> 19 #include <string.h> 20 #include "ceed-ref.h" 21 22 //------------------------------------------------------------------------------ 23 // Vector Set Array 24 //------------------------------------------------------------------------------ 25 static int CeedVectorSetArray_Ref(CeedVector vec, CeedMemType mtype, 26 CeedCopyMode cmode, CeedScalar *array) { 27 int ierr; 28 CeedVector_Ref *impl; 29 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 30 CeedInt length; 31 ierr = CeedVectorGetLength(vec, &length); CeedChk(ierr); 32 Ceed ceed; 33 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 34 35 if (mtype != CEED_MEM_HOST) 36 // LCOV_EXCL_START 37 return CeedError(ceed, 1, "Only MemType = HOST supported"); 38 // LCOV_EXCL_STOP 39 ierr = CeedFree(&impl->array_allocated); CeedChk(ierr); 40 switch (cmode) { 41 case CEED_COPY_VALUES: 42 ierr = CeedMalloc(length, &impl->array_allocated); CeedChk(ierr); 43 impl->array = impl->array_allocated; 44 if (array) memcpy(impl->array, array, length * sizeof(array[0])); 45 break; 46 case CEED_OWN_POINTER: 47 impl->array_allocated = array; 48 impl->array = array; 49 break; 50 case CEED_USE_POINTER: 51 impl->array = array; 52 } 53 return 0; 54 } 55 56 //------------------------------------------------------------------------------ 57 // Vector Take Array 58 //------------------------------------------------------------------------------ 59 static int CeedVectorTakeArray_Ref(CeedVector vec, CeedMemType mtype, 60 CeedScalar **array) { 61 int ierr; 62 CeedVector_Ref *impl; 63 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 64 Ceed ceed; 65 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 66 67 if (mtype != CEED_MEM_HOST) 68 // LCOV_EXCL_START 69 return CeedError(ceed, 1, "Only MemType = HOST supported"); 70 // LCOV_EXCL_STOP 71 72 (*array) = impl->array; 73 impl->array = NULL; 74 impl->array_allocated = NULL; 75 76 return 0; 77 } 78 79 //------------------------------------------------------------------------------ 80 // Vector Get Array 81 //------------------------------------------------------------------------------ 82 static int CeedVectorGetArray_Ref(CeedVector vec, CeedMemType mtype, 83 CeedScalar **array) { 84 int ierr; 85 CeedVector_Ref *impl; 86 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 87 Ceed ceed; 88 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 89 90 if (mtype != CEED_MEM_HOST) 91 // LCOV_EXCL_START 92 return CeedError(ceed, 1, "Can only provide to HOST memory"); 93 // LCOV_EXCL_STOP 94 if (!impl->array) { // Allocate if array is not yet allocated 95 ierr = CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL); 96 CeedChk(ierr); 97 } 98 *array = impl->array; 99 return 0; 100 } 101 102 //------------------------------------------------------------------------------ 103 // Vector Get Array Read 104 //------------------------------------------------------------------------------ 105 static int CeedVectorGetArrayRead_Ref(CeedVector vec, CeedMemType mtype, 106 const CeedScalar **array) { 107 int ierr; 108 CeedVector_Ref *impl; 109 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 110 Ceed ceed; 111 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 112 113 if (mtype != CEED_MEM_HOST) 114 // LCOV_EXCL_START 115 return CeedError(ceed, 1, "Can only provide to HOST memory"); 116 // LCOV_EXCL_STOP 117 if (!impl->array) { // Allocate if array is not yet allocated 118 ierr = CeedVectorSetArray(vec, CEED_MEM_HOST, CEED_COPY_VALUES, NULL); 119 CeedChk(ierr); 120 } 121 *array = impl->array; 122 return 0; 123 } 124 125 //------------------------------------------------------------------------------ 126 // Vector Restore Array 127 //------------------------------------------------------------------------------ 128 static int CeedVectorRestoreArray_Ref(CeedVector vec) { 129 return 0; 130 } 131 132 static int CeedVectorRestoreArrayRead_Ref(CeedVector vec) { 133 return 0; 134 } 135 136 //------------------------------------------------------------------------------ 137 // Vector Destroy 138 //------------------------------------------------------------------------------ 139 static int CeedVectorDestroy_Ref(CeedVector vec) { 140 int ierr; 141 CeedVector_Ref *impl; 142 ierr = CeedVectorGetData(vec, &impl); CeedChk(ierr); 143 144 ierr = CeedFree(&impl->array_allocated); CeedChk(ierr); 145 ierr = CeedFree(&impl); CeedChk(ierr); 146 return 0; 147 } 148 149 //------------------------------------------------------------------------------ 150 // Vector Create 151 //------------------------------------------------------------------------------ 152 int CeedVectorCreate_Ref(CeedInt n, CeedVector vec) { 153 int ierr; 154 CeedVector_Ref *impl; 155 Ceed ceed; 156 ierr = CeedVectorGetCeed(vec, &ceed); CeedChk(ierr); 157 158 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "SetArray", 159 CeedVectorSetArray_Ref); CeedChk(ierr); 160 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "TakeArray", 161 CeedVectorTakeArray_Ref); CeedChk(ierr); 162 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "GetArray", 163 CeedVectorGetArray_Ref); CeedChk(ierr); 164 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "GetArrayRead", 165 CeedVectorGetArrayRead_Ref); CeedChk(ierr); 166 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArray", 167 CeedVectorRestoreArray_Ref); CeedChk(ierr); 168 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "RestoreArrayRead", 169 CeedVectorRestoreArrayRead_Ref); CeedChk(ierr); 170 ierr = CeedSetBackendFunction(ceed, "Vector", vec, "Destroy", 171 CeedVectorDestroy_Ref); CeedChk(ierr); 172 ierr = CeedCalloc(1,&impl); CeedChk(ierr); 173 ierr = CeedVectorSetData(vec, impl); CeedChk(ierr); 174 return 0; 175 } 176 //------------------------------------------------------------------------------ 177