ceed-vector.c (38d0029a08e84b16bbdde77c27446234f5f09cf2) ceed-vector.c (7a982d89c751e293e39d23a7c44a161cef1fcd06)
1// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
2// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
3// 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.

--- 4 unchanged lines hidden (view full) ---

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-impl.h>
18#include <ceed-backend.h>
19#include <math.h>
20
1// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
2// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
3// 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.

--- 4 unchanged lines hidden (view full) ---

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-impl.h>
18#include <ceed-backend.h>
19#include <math.h>
20
21/// @file
22/// Implementation of public CeedVector interfaces
23
21/// @cond DOXYGEN_SKIP
22static struct CeedVector_private ceed_vector_active;
23static struct CeedVector_private ceed_vector_none;
24/// @endcond
25
24/// @cond DOXYGEN_SKIP
25static struct CeedVector_private ceed_vector_active;
26static struct CeedVector_private ceed_vector_none;
27/// @endcond
28
26/// @file
27/// Implementation of public CeedVector interfaces
28///
29/// @addtogroup CeedVector
29/// @addtogroup CeedVectorUser
30/// @{
31
30/// @{
31
32/// Indicate that vector will be provided as an explicit argument to
33/// CeedOperatorApply().
34const CeedVector CEED_VECTOR_ACTIVE = &ceed_vector_active;
35
36/// Indicate that no vector is applicable (i.e., for CEED_EVAL_WEIGHTS).
37const CeedVector CEED_VECTOR_NONE = &ceed_vector_none;
38
39/// @}
40
41/// ----------------------------------------------------------------------------
42/// CeedVector Backend API
43/// ----------------------------------------------------------------------------
44/// @addtogroup CeedVectorBackend
45/// @{
46
32/**
47/**
48 @brief Get the Ceed associated with a CeedVector
49
50 @param vec CeedVector to retrieve state
51 @param[out] ceed Variable to store ceed
52
53 @return An error code: 0 - success, otherwise - failure
54
55 @ref Backend
56**/
57int CeedVectorGetCeed(CeedVector vec, Ceed *ceed) {
58 *ceed = vec->ceed;
59 return 0;
60}
61
62/**
63 @brief Get the state of a CeedVector
64
65 @param vec CeedVector to retrieve state
66 @param[out] state Variable to store state
67
68 @return An error code: 0 - success, otherwise - failure
69
70 @ref Backend
71**/
72int CeedVectorGetState(CeedVector vec, uint64_t *state) {
73 *state = vec->state;
74 return 0;
75}
76
77/**
78 @brief Add a refrence to a CeedVector
79
80 @param[out] vec CeedVector to increment refrence counter
81
82 @return An error code: 0 - success, otherwise - failure
83
84 @ref Backend
85**/
86int CeedVectorAddReference(CeedVector vec) {
87 vec->refcount++;
88 return 0;
89}
90
91/**
92 @brief Get the backend data of a CeedVector
93
94 @param vec CeedVector to retrieve state
95 @param[out] data Variable to store data
96
97 @return An error code: 0 - success, otherwise - failure
98
99 @ref Backend
100**/
101int CeedVectorGetData(CeedVector vec, void **data) {
102 *data = vec->data;
103 return 0;
104}
105
106/**
107 @brief Set the backend data of a CeedVector
108
109 @param[out] vec CeedVector to retrieve state
110 @param data Data to set
111
112 @return An error code: 0 - success, otherwise - failure
113
114 @ref Backend
115**/
116int CeedVectorSetData(CeedVector vec, void **data) {
117 vec->data = *data;
118 return 0;
119}
120
121/// @}
122
123/// ----------------------------------------------------------------------------
124/// CeedVector Public API
125/// ----------------------------------------------------------------------------
126/// @addtogroup CeedVectorUser
127/// @{
128
129/**
33 @brief Create a CeedVector of the specified length (does not allocate memory)
34
35 @param ceed Ceed object where the CeedVector will be created
36 @param length Length of vector
37 @param[out] vec Address of the variable where the newly created
38 CeedVector will be stored
39
40 @return An error code: 0 - success, otherwise - failure
41
130 @brief Create a CeedVector of the specified length (does not allocate memory)
131
132 @param ceed Ceed object where the CeedVector will be created
133 @param length Length of vector
134 @param[out] vec Address of the variable where the newly created
135 CeedVector will be stored
136
137 @return An error code: 0 - success, otherwise - failure
138
42 @ref Basic
139 @ref User
43**/
44int CeedVectorCreate(Ceed ceed, CeedInt length, CeedVector *vec) {
45 int ierr;
46
47 if (!ceed->VectorCreate) {
48 Ceed delegate;
49 ierr = CeedGetObjectDelegate(ceed, &delegate, "Vector"); CeedChk(ierr);
50

--- 23 unchanged lines hidden (view full) ---

74 @param vec CeedVector
75 @param mtype Memory type of the array being passed
76 @param cmode Copy mode for the array
77 @param array Array to be used, or NULL with CEED_COPY_VALUES to have the
78 library allocate
79
80 @return An error code: 0 - success, otherwise - failure
81
140**/
141int CeedVectorCreate(Ceed ceed, CeedInt length, CeedVector *vec) {
142 int ierr;
143
144 if (!ceed->VectorCreate) {
145 Ceed delegate;
146 ierr = CeedGetObjectDelegate(ceed, &delegate, "Vector"); CeedChk(ierr);
147

--- 23 unchanged lines hidden (view full) ---

171 @param vec CeedVector
172 @param mtype Memory type of the array being passed
173 @param cmode Copy mode for the array
174 @param array Array to be used, or NULL with CEED_COPY_VALUES to have the
175 library allocate
176
177 @return An error code: 0 - success, otherwise - failure
178
82 @ref Basic
179 @ref User
83**/
84int CeedVectorSetArray(CeedVector vec, CeedMemType mtype, CeedCopyMode cmode,
85 CeedScalar *array) {
86 int ierr;
87
88 if (!vec->SetArray)
89 // LCOV_EXCL_START
90 return CeedError(vec->ceed, 1, "Backend does not support VectorSetArray");

--- 16 unchanged lines hidden (view full) ---

107/**
108 @brief Set the CeedVector to a constant value
109
110 @param vec CeedVector
111 @param[in] value Value to be used
112
113 @return An error code: 0 - success, otherwise - failure
114
180**/
181int CeedVectorSetArray(CeedVector vec, CeedMemType mtype, CeedCopyMode cmode,
182 CeedScalar *array) {
183 int ierr;
184
185 if (!vec->SetArray)
186 // LCOV_EXCL_START
187 return CeedError(vec->ceed, 1, "Backend does not support VectorSetArray");

--- 16 unchanged lines hidden (view full) ---

204/**
205 @brief Set the CeedVector to a constant value
206
207 @param vec CeedVector
208 @param[in] value Value to be used
209
210 @return An error code: 0 - success, otherwise - failure
211
115 @ref Basic
212 @ref User
116**/
117int CeedVectorSetValue(CeedVector vec, CeedScalar value) {
118 int ierr;
119
120 if (vec->state % 2 == 1)
121 return CeedError(vec->ceed, 1, "Cannot grant CeedVector array access, the "
122 "access lock is already in use");
123

--- 14 unchanged lines hidden (view full) ---

138/**
139 @brief Sync the CeedVector to a specified memtype
140
141 @param vec CeedVector
142 @param mtype Memtype to be synced
143
144 @return An error code: 0 - success, otherwise - failure
145
213**/
214int CeedVectorSetValue(CeedVector vec, CeedScalar value) {
215 int ierr;
216
217 if (vec->state % 2 == 1)
218 return CeedError(vec->ceed, 1, "Cannot grant CeedVector array access, the "
219 "access lock is already in use");
220

--- 14 unchanged lines hidden (view full) ---

235/**
236 @brief Sync the CeedVector to a specified memtype
237
238 @param vec CeedVector
239 @param mtype Memtype to be synced
240
241 @return An error code: 0 - success, otherwise - failure
242
146 @ref Basic
243 @ref User
147**/
148int CeedVectorSyncArray(CeedVector vec, CeedMemType mtype) {
149 int ierr;
150
151 if (vec->state % 2 == 1)
152 return CeedError(vec->ceed, 1, "Cannot sync CeedVector, the access lock is "
153 "already in use");
154

--- 19 unchanged lines hidden (view full) ---

174
175 @note The CeedVectorGetArray* and CeedVectorRestoreArray* functions provide
176 access to array pointers in the desired memory space. Pairing get/restore
177 allows the Vector to track access, thus knowing if norms or other
178 operations may need to be recomputed.
179
180 @return An error code: 0 - success, otherwise - failure
181
244**/
245int CeedVectorSyncArray(CeedVector vec, CeedMemType mtype) {
246 int ierr;
247
248 if (vec->state % 2 == 1)
249 return CeedError(vec->ceed, 1, "Cannot sync CeedVector, the access lock is "
250 "already in use");
251

--- 19 unchanged lines hidden (view full) ---

271
272 @note The CeedVectorGetArray* and CeedVectorRestoreArray* functions provide
273 access to array pointers in the desired memory space. Pairing get/restore
274 allows the Vector to track access, thus knowing if norms or other
275 operations may need to be recomputed.
276
277 @return An error code: 0 - success, otherwise - failure
278
182 @ref Basic
279 @ref User
183**/
184int CeedVectorGetArray(CeedVector vec, CeedMemType mtype, CeedScalar **array) {
185 int ierr;
186
187 if (!vec->GetArray)
188 // LCOV_EXCL_START
189 return CeedError(vec->ceed, 1, "Backend does not support GetArray");
190 // LCOV_EXCL_STOP

--- 18 unchanged lines hidden (view full) ---

209 @param vec CeedVector to access
210 @param mtype Memory type on which to access the array. If the backend
211 uses a different memory type, this will perform a copy
212 (possibly cached).
213 @param[out] array Array on memory type mtype
214
215 @return An error code: 0 - success, otherwise - failure
216
280**/
281int CeedVectorGetArray(CeedVector vec, CeedMemType mtype, CeedScalar **array) {
282 int ierr;
283
284 if (!vec->GetArray)
285 // LCOV_EXCL_START
286 return CeedError(vec->ceed, 1, "Backend does not support GetArray");
287 // LCOV_EXCL_STOP

--- 18 unchanged lines hidden (view full) ---

306 @param vec CeedVector to access
307 @param mtype Memory type on which to access the array. If the backend
308 uses a different memory type, this will perform a copy
309 (possibly cached).
310 @param[out] array Array on memory type mtype
311
312 @return An error code: 0 - success, otherwise - failure
313
217 @ref Basic
314 @ref User
218**/
219int CeedVectorGetArrayRead(CeedVector vec, CeedMemType mtype,
220 const CeedScalar **array) {
221 int ierr;
222
223 if (!vec->GetArrayRead)
224 // LCOV_EXCL_START
225 return CeedError(vec->ceed, 1, "Backend does not support GetArrayRead");

--- 12 unchanged lines hidden (view full) ---

238/**
239 @brief Restore an array obtained using CeedVectorGetArray()
240
241 @param vec CeedVector to restore
242 @param array Array of vector data
243
244 @return An error code: 0 - success, otherwise - failure
245
315**/
316int CeedVectorGetArrayRead(CeedVector vec, CeedMemType mtype,
317 const CeedScalar **array) {
318 int ierr;
319
320 if (!vec->GetArrayRead)
321 // LCOV_EXCL_START
322 return CeedError(vec->ceed, 1, "Backend does not support GetArrayRead");

--- 12 unchanged lines hidden (view full) ---

335/**
336 @brief Restore an array obtained using CeedVectorGetArray()
337
338 @param vec CeedVector to restore
339 @param array Array of vector data
340
341 @return An error code: 0 - success, otherwise - failure
342
246 @ref Basic
343 @ref User
247**/
248int CeedVectorRestoreArray(CeedVector vec, CeedScalar **array) {
249 int ierr;
250
251 if (!vec->RestoreArray)
252 // LCOV_EXCL_START
253 return CeedError(vec->ceed, 1, "Backend does not support RestoreArray");
254 // LCOV_EXCL_STOP

--- 12 unchanged lines hidden (view full) ---

267/**
268 @brief Restore an array obtained using CeedVectorGetArrayRead()
269
270 @param vec CeedVector to restore
271 @param array Array of vector data
272
273 @return An error code: 0 - success, otherwise - failure
274
344**/
345int CeedVectorRestoreArray(CeedVector vec, CeedScalar **array) {
346 int ierr;
347
348 if (!vec->RestoreArray)
349 // LCOV_EXCL_START
350 return CeedError(vec->ceed, 1, "Backend does not support RestoreArray");
351 // LCOV_EXCL_STOP

--- 12 unchanged lines hidden (view full) ---

364/**
365 @brief Restore an array obtained using CeedVectorGetArrayRead()
366
367 @param vec CeedVector to restore
368 @param array Array of vector data
369
370 @return An error code: 0 - success, otherwise - failure
371
275 @ref Basic
372 @ref User
276**/
277int CeedVectorRestoreArrayRead(CeedVector vec, const CeedScalar **array) {
278 int ierr;
279
280 if (!vec->RestoreArrayRead)
281 // LCOV_EXCL_START
282 return CeedError(vec->ceed, 1, "Backend does not support RestoreArrayRead");
283 // LCOV_EXCL_STOP
284
285 ierr = vec->RestoreArrayRead(vec); CeedChk(ierr);
286 *array = NULL;
287 vec->numreaders--;
288
289 return 0;
290}
291
292/**
373**/
374int CeedVectorRestoreArrayRead(CeedVector vec, const CeedScalar **array) {
375 int ierr;
376
377 if (!vec->RestoreArrayRead)
378 // LCOV_EXCL_START
379 return CeedError(vec->ceed, 1, "Backend does not support RestoreArrayRead");
380 // LCOV_EXCL_STOP
381
382 ierr = vec->RestoreArrayRead(vec); CeedChk(ierr);
383 *array = NULL;
384 vec->numreaders--;
385
386 return 0;
387}
388
389/**
293 @brief View a CeedVector
294
295 @return An error code: 0 - success, otherwise - failure
296
297 @ref Utility
298**/
299int CeedVectorView(CeedVector vec, const char *fpfmt, FILE *stream) {
300 const CeedScalar *x;
301
302 int ierr = CeedVectorGetArrayRead(vec, CEED_MEM_HOST, &x); CeedChk(ierr);
303
304 char fmt[1024];
305 fprintf(stream, "CeedVector length %ld\n", (long)vec->length);
306 snprintf(fmt, sizeof fmt, " %s\n", fpfmt ? fpfmt : "%g");
307 for (CeedInt i=0; i<vec->length; i++)
308 fprintf(stream, fmt, x[i]);
309
310 ierr = CeedVectorRestoreArrayRead(vec, &x); CeedChk(ierr);
311
312 return 0;
313}
314
315/**
316 @brief Get the Ceed associated with a CeedVector
317
318 @param vec CeedVector to retrieve state
319 @param[out] ceed Variable to store ceed
320
321 @return An error code: 0 - success, otherwise - failure
322
323 @ref Advanced
324**/
325int CeedVectorGetCeed(CeedVector vec, Ceed *ceed) {
326 *ceed = vec->ceed;
327 return 0;
328}
329
330/**
331 @brief Get the length of a CeedVector
332
333 @param vec CeedVector to retrieve length
334 @param[out] length Variable to store length
335
336 @return An error code: 0 - success, otherwise - failure
337
338 @ref Advanced
339**/
340int CeedVectorGetLength(CeedVector vec, CeedInt *length) {
341 *length = vec->length;
342 return 0;
343}
344
345/**
346 @brief Get the norm of a CeedVector.
347
348 Note: This operation is local to the CeedVector. This function will likely
349 not provide the desired results for the norm of the libCEED portion
350 of a parallel vector or a CeedVector with duplicated or hanging nodes.
351
352 @param vec CeedVector to retrieve maximum value
353 @param type Norm type CEED_NORM_1, CEED_NORM_2, or CEED_NORM_MAX
354 @param[out] norm Variable to store norm value
355
356 @return An error code: 0 - success, otherwise - failure
357
390 @brief Get the norm of a CeedVector.
391
392 Note: This operation is local to the CeedVector. This function will likely
393 not provide the desired results for the norm of the libCEED portion
394 of a parallel vector or a CeedVector with duplicated or hanging nodes.
395
396 @param vec CeedVector to retrieve maximum value
397 @param type Norm type CEED_NORM_1, CEED_NORM_2, or CEED_NORM_MAX
398 @param[out] norm Variable to store norm value
399
400 @return An error code: 0 - success, otherwise - failure
401
358 @ref Advanced
402 @ref User
359**/
360int CeedVectorNorm(CeedVector vec, CeedNormType type, CeedScalar *norm) {
361 int ierr;
362
363 // Backend impl for GPU, if added
364 if (vec->Norm) {
365 ierr = vec->Norm(vec, type, norm); CeedChk(ierr);
366 return 0;

--- 24 unchanged lines hidden (view full) ---

391 *norm = sqrt(*norm);
392
393 ierr = CeedVectorRestoreArrayRead(vec, &array); CeedChk(ierr);
394
395 return 0;
396}
397
398/**
403**/
404int CeedVectorNorm(CeedVector vec, CeedNormType type, CeedScalar *norm) {
405 int ierr;
406
407 // Backend impl for GPU, if added
408 if (vec->Norm) {
409 ierr = vec->Norm(vec, type, norm); CeedChk(ierr);
410 return 0;

--- 24 unchanged lines hidden (view full) ---

435 *norm = sqrt(*norm);
436
437 ierr = CeedVectorRestoreArrayRead(vec, &array); CeedChk(ierr);
438
439 return 0;
440}
441
442/**
399 @brief Get the state of a CeedVector
443 @brief View a CeedVector
400
444
401 @param vec CeedVector to retrieve state
402 @param[out] state Variable to store state
403
404 @return An error code: 0 - success, otherwise - failure
405
445 @return An error code: 0 - success, otherwise - failure
446
406 @ref Advanced
447 @ref User
407**/
448**/
408int CeedVectorGetState(CeedVector vec, uint64_t *state) {
409 *state = vec->state;
410 return 0;
411}
449int CeedVectorView(CeedVector vec, const char *fpfmt, FILE *stream) {
450 const CeedScalar *x;
412
451
413/**
414 @brief Get the backend data of a CeedVector
452 int ierr = CeedVectorGetArrayRead(vec, CEED_MEM_HOST, &x); CeedChk(ierr);
415
453
416 @param vec CeedVector to retrieve state
417 @param[out] data Variable to store data
454 char fmt[1024];
455 fprintf(stream, "CeedVector length %ld\n", (long)vec->length);
456 snprintf(fmt, sizeof fmt, " %s\n", fpfmt ? fpfmt : "%g");
457 for (CeedInt i=0; i<vec->length; i++)
458 fprintf(stream, fmt, x[i]);
418
459
419 @return An error code: 0 - success, otherwise - failure
460 ierr = CeedVectorRestoreArrayRead(vec, &x); CeedChk(ierr);
420
461
421 @ref Advanced
422**/
423int CeedVectorGetData(CeedVector vec, void **data) {
424 *data = vec->data;
425 return 0;
426}
427
428/**
462 return 0;
463}
464
465/**
429 @brief Set the backend data of a CeedVector
466 @brief Get the length of a CeedVector
430
467
431 @param[out] vec CeedVector to retrieve state
432 @param data Data to set
468 @param vec CeedVector to retrieve length
469 @param[out] length Variable to store length
433
434 @return An error code: 0 - success, otherwise - failure
435
470
471 @return An error code: 0 - success, otherwise - failure
472
436 @ref Advanced
473 @ref User
437**/
474**/
438int CeedVectorSetData(CeedVector vec, void **data) {
439 vec->data = *data;
475int CeedVectorGetLength(CeedVector vec, CeedInt *length) {
476 *length = vec->length;
440 return 0;
441}
442
443/**
477 return 0;
478}
479
480/**
444 @brief Add a refrence to a CeedVector
445
446 @param[out] vec CeedVector to increment refrence counter
447
448 @return An error code: 0 - success, otherwise - failure
449
450 @ref Advanced
451**/
452int CeedVectorAddReference(CeedVector vec) {
453 vec->refcount++;
454 return 0;
455}
456
457/**
458 @brief Destroy a CeedVector
459
460 @param vec CeedVector to destroy
461
462 @return An error code: 0 - success, otherwise - failure
463
481 @brief Destroy a CeedVector
482
483 @param vec CeedVector to destroy
484
485 @return An error code: 0 - success, otherwise - failure
486
464 @ref Basic
487 @ref User
465**/
466int CeedVectorDestroy(CeedVector *vec) {
467 int ierr;
468
469 if (!*vec || --(*vec)->refcount > 0)
470 return 0;
471
472 if ((*vec) && ((*vec)->state % 2) == 1)

--- 5 unchanged lines hidden (view full) ---

478 }
479
480 ierr = CeedDestroy(&(*vec)->ceed); CeedChk(ierr);
481 ierr = CeedFree(vec); CeedChk(ierr);
482
483 return 0;
484}
485
488**/
489int CeedVectorDestroy(CeedVector *vec) {
490 int ierr;
491
492 if (!*vec || --(*vec)->refcount > 0)
493 return 0;
494
495 if ((*vec) && ((*vec)->state % 2) == 1)

--- 5 unchanged lines hidden (view full) ---

501 }
502
503 ierr = CeedDestroy(&(*vec)->ceed); CeedChk(ierr);
504 ierr = CeedFree(vec); CeedChk(ierr);
505
506 return 0;
507}
508
486/// @cond DOXYGEN_SKIP
487// Indicate that vector will be provided as an explicit argument to
488// CeedOperatorApply().
489const CeedVector CEED_VECTOR_ACTIVE = &ceed_vector_active;
490
491// Indicate that no vector is applicable (i.e., for CEED_EVAL_WEIGHTS).
492const CeedVector CEED_VECTOR_NONE = &ceed_vector_none;
493/// @endcond
494/// @}
509/// @}