rstr - add CeedElemRestrictionCreateUnsignedCopy

include/ceed-impl.h

@@ -149,7 +149,8 @@ struct CeedVector_private {
 };
 
 struct CeedElemRestriction_private {
-  Ceed ceed;
+  Ceed                ceed;
+  CeedElemRestriction rstr_signed;
   int (*Apply)(CeedElemRestriction, CeedTransposeMode, CeedVector, CeedVector, CeedRequest *);
   int (*ApplyUnsigned)(CeedElemRestriction, CeedTransposeMode, CeedVector, CeedVector, CeedRequest *);
   int (*ApplyBlock)(CeedElemRestriction, CeedInt, CeedTransposeMode, CeedVector, CeedVector, CeedRequest *);

include/ceed/ceed.h

@@ -240,6 +240,7 @@ CEED_EXTERN int CeedElemRestrictionCreateBlocked(Ceed ceed, CeedInt num_elem, Ce
                                                  const CeedInt *offsets, CeedElemRestriction *rstr);
 CEED_EXTERN int CeedElemRestrictionCreateBlockedStrided(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt blk_size, CeedInt num_comp,
                                                         CeedSize l_size, const CeedInt strides[3], CeedElemRestriction *rstr);
+CEED_EXTERN int CeedElemRestrictionCreateUnsignedCopy(CeedElemRestriction rstr, CeedElemRestriction *rstr_unsigned);
 CEED_EXTERN int CeedElemRestrictionReferenceCopy(CeedElemRestriction rstr, CeedElemRestriction *rstr_copy);
 CEED_EXTERN int CeedElemRestrictionCreateVector(CeedElemRestriction rstr, CeedVector *lvec, CeedVector *evec);
 CEED_EXTERN int CeedElemRestrictionApply(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector ru, CeedRequest *request);

interface/ceed-elemrestriction.c

@@ -10,6 +10,7 @@
 #include <ceed/backend.h>
 #include <stdbool.h>
 #include <stdio.h>
+#include <string.h>
 
 /// @file
 /// Implementation of CeedElemRestriction interfaces
@@ -85,9 +86,13 @@ int CeedElemRestrictionGetStrides(CeedElemRestriction rstr, CeedInt (*strides)[3
   @ref User
 **/
 int CeedElemRestrictionGetOffsets(CeedElemRestriction rstr, CeedMemType mem_type, const CeedInt **offsets) {
-  CeedCheck(rstr->GetOffsets, rstr->ceed, CEED_ERROR_UNSUPPORTED, "Backend does not support GetOffsets");
-  CeedCall(rstr->GetOffsets(rstr, mem_type, offsets));
-  rstr->num_readers++;
+  if (rstr->rstr_signed) {
+    CeedCall(CeedElemRestrictionGetOffsets(rstr->rstr_signed, mem_type, offsets));
+  } else {
+    CeedCheck(rstr->GetOffsets, rstr->ceed, CEED_ERROR_UNSUPPORTED, "Backend does not support GetOffsets");
+    CeedCall(rstr->GetOffsets(rstr, mem_type, offsets));
+    rstr->num_readers++;
+  }
   return CEED_ERROR_SUCCESS;
 }
 
@@ -102,8 +107,12 @@ int CeedElemRestrictionGetOffsets(CeedElemRestriction rstr, CeedMemType mem_type
   @ref User
 **/
 int CeedElemRestrictionRestoreOffsets(CeedElemRestriction rstr, const CeedInt **offsets) {
-  *offsets = NULL;
-  rstr->num_readers--;
+  if (rstr->rstr_signed) {
+    CeedCall(CeedElemRestrictionRestoreOffsets(rstr->rstr_signed, offsets));
+  } else {
+    *offsets = NULL;
+    rstr->num_readers--;
+  }
   return CEED_ERROR_SUCCESS;
 }
 
@@ -558,6 +567,38 @@ int CeedElemRestrictionCreateBlockedStrided(Ceed ceed, CeedInt num_elem, CeedInt
   return CEED_ERROR_SUCCESS;
 }
 
+/**
+  @brief Copy the pointer to a CeedElemRestriction and set `CeedElemRestrictionApply()` implementation to `CeedElemRestrictionApplyUnsigned()`.
+
+  Both pointers should be destroyed with `CeedElemRestrictionDestroy()`.
+
+  @param[in]     rstr          CeedElemRestriction to create unsigned reference to
+  @param[in,out] rstr_unsigned Variable to store unsigned CeedElemRestriction
+
+  @return An error code: 0 - success, otherwise - failure
+
+  @ref User
+**/
+int CeedElemRestrictionCreateUnsignedCopy(CeedElemRestriction rstr, CeedElemRestriction *rstr_unsigned) {
+  CeedCall(CeedCalloc(1, rstr_unsigned));
+
+  // Copy old rstr
+  memcpy(*rstr_unsigned, rstr, sizeof(struct CeedElemRestriction_private));
+  (*rstr_unsigned)->ceed = NULL;
+  CeedCall(CeedReferenceCopy(rstr->ceed, &(*rstr_unsigned)->ceed));
+  (*rstr_unsigned)->strides = NULL;
+  if (rstr->strides) {
+    CeedCall(CeedMalloc(3, &(*rstr_unsigned)->strides));
+    for (CeedInt i = 0; i < 3; i++) (*rstr_unsigned)->strides[i] = rstr->strides[i];
+  }
+  CeedCall(CeedElemRestrictionReferenceCopy(rstr, &(*rstr_unsigned)->rstr_signed));
+
+  // Override Apply
+  (*rstr_unsigned)->Apply = rstr->ApplyUnsigned;
+
+  return CEED_ERROR_SUCCESS;
+}
+
 /**
   @brief Copy the pointer to a CeedElemRestriction.
 
@@ -894,7 +935,11 @@ int CeedElemRestrictionDestroy(CeedElemRestriction *rstr) {
   }
   CeedCheck((*rstr)->num_readers == 0, (*rstr)->ceed, CEED_ERROR_ACCESS,
             "Cannot destroy CeedElemRestriction, a process has read access to the offset data");
-  if ((*rstr)->Destroy) CeedCall((*rstr)->Destroy(*rstr));
+
+  // Only destroy backend data once between rstr and unsigned copy
+  if ((*rstr)->rstr_signed) CeedCall(CeedElemRestrictionDestroy(&(*rstr)->rstr_signed));
+  else if ((*rstr)->Destroy) CeedCall((*rstr)->Destroy(*rstr));
+
   CeedCall(CeedFree(&(*rstr)->strides));
   CeedCall(CeedDestroy(&(*rstr)->ceed));
   CeedCall(CeedFree(rstr));

interface/ceed-preconditioning.c

@@ -702,8 +702,9 @@ static int CeedSingleOperatorAssemblyCountEntries(CeedOperator op, CeedInt *num_
 **/
 static int CeedSingleOperatorMultigridLevel(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse, CeedBasis basis_coarse,
                                             CeedBasis basis_c_to_f, CeedOperator *op_coarse, CeedOperator *op_prolong, CeedOperator *op_restrict) {
-  Ceed       ceed;
-  CeedVector mult_vec = NULL;
+  Ceed                ceed;
+  CeedVector          mult_vec         = NULL;
+  CeedElemRestriction rstr_p_mult_fine = NULL;
   CeedCall(CeedOperatorGetCeed(op_fine, &ceed));
 
   // Check for composite operator
@@ -740,12 +741,13 @@ static int CeedSingleOperatorMultigridLevel(CeedOperator op_fine, CeedVector p_m
   if (op_restrict || op_prolong) {
     CeedVector mult_e_vec;
 
+    CeedCall(CeedElemRestrictionCreateUnsignedCopy(rstr_fine, &rstr_p_mult_fine));
     CeedCheck(p_mult_fine, ceed, CEED_ERROR_INCOMPATIBLE, "Prolongation or restriction operator creation requires fine grid multiplicity vector");
     CeedCall(CeedElemRestrictionCreateVector(rstr_fine, &mult_vec, &mult_e_vec));
     CeedCall(CeedVectorSetValue(mult_e_vec, 0.0));
-    CeedCall(CeedElemRestrictionApply(rstr_fine, CEED_NOTRANSPOSE, p_mult_fine, mult_e_vec, CEED_REQUEST_IMMEDIATE));
+    CeedCall(CeedElemRestrictionApply(rstr_p_mult_fine, CEED_NOTRANSPOSE, p_mult_fine, mult_e_vec, CEED_REQUEST_IMMEDIATE));
     CeedCall(CeedVectorSetValue(mult_vec, 0.0));
-    CeedCall(CeedElemRestrictionApply(rstr_fine, CEED_TRANSPOSE, mult_e_vec, mult_vec, CEED_REQUEST_IMMEDIATE));
+    CeedCall(CeedElemRestrictionApply(rstr_p_mult_fine, CEED_TRANSPOSE, mult_e_vec, mult_vec, CEED_REQUEST_IMMEDIATE));
     CeedCall(CeedVectorDestroy(&mult_e_vec));
     CeedCall(CeedVectorReciprocal(mult_vec));
   }
@@ -783,7 +785,7 @@ static int CeedSingleOperatorMultigridLevel(CeedOperator op_fine, CeedVector p_m
 
     CeedCall(CeedOperatorCreate(ceed, qf_restrict, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, op_restrict));
     CeedCall(CeedOperatorSetField(*op_restrict, "input", rstr_fine, CEED_BASIS_COLLOCATED, CEED_VECTOR_ACTIVE));
-    CeedCall(CeedOperatorSetField(*op_restrict, "scale", rstr_fine, CEED_BASIS_COLLOCATED, mult_vec));
+    CeedCall(CeedOperatorSetField(*op_restrict, "scale", rstr_p_mult_fine, CEED_BASIS_COLLOCATED, mult_vec));
     CeedCall(CeedOperatorSetField(*op_restrict, "output", rstr_coarse, basis_c_to_f, CEED_VECTOR_ACTIVE));
 
     // Set name
@@ -820,7 +822,7 @@ static int CeedSingleOperatorMultigridLevel(CeedOperator op_fine, CeedVector p_m
 
     CeedCall(CeedOperatorCreate(ceed, qf_prolong, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, op_prolong));
     CeedCall(CeedOperatorSetField(*op_prolong, "input", rstr_coarse, basis_c_to_f, CEED_VECTOR_ACTIVE));
-    CeedCall(CeedOperatorSetField(*op_prolong, "scale", rstr_fine, CEED_BASIS_COLLOCATED, mult_vec));
+    CeedCall(CeedOperatorSetField(*op_prolong, "scale", rstr_p_mult_fine, CEED_BASIS_COLLOCATED, mult_vec));
     CeedCall(CeedOperatorSetField(*op_prolong, "output", rstr_fine, CEED_BASIS_COLLOCATED, CEED_VECTOR_ACTIVE));
 
     // Set name
@@ -842,6 +844,7 @@ static int CeedSingleOperatorMultigridLevel(CeedOperator op_fine, CeedVector p_m
 
   // Cleanup
   CeedCall(CeedVectorDestroy(&mult_vec));
+  CeedCall(CeedElemRestrictionDestroy(&rstr_p_mult_fine));
   CeedCall(CeedBasisDestroy(&basis_c_to_f));
 
   return CEED_ERROR_SUCCESS;