Added optional inlined iterators. They are disabled by default because they do not...
authorIsaac Dooley <idooley2@illinois.edu>
Wed, 25 Mar 2009 21:46:59 +0000 (21:46 +0000)
committerIsaac Dooley <idooley2@illinois.edu>
Wed, 25 Mar 2009 21:46:59 +0000 (21:46 +0000)
src/libs/ck-libs/ParFUM-Tops/Makefile
src/libs/ck-libs/ParFUM-Tops/ParFUM_TOPS.h
src/libs/ck-libs/ParFUM-Tops/ParFUM_TOPS_Iterators.cc

index fa91544053e3520d04d0d16304b8ed66121eb4e6..9ed9ef5ee349cda80837403fd3a5d047260db26c 100644 (file)
@@ -4,13 +4,13 @@ CUDADIR = /usr/local/cuda
 CUDASDK = $(HOME)/TOPS-Tesla/NVIDIA_CUDA_SDK
 CUDAC = $(CUDADIR)/bin/nvcc 
 CUDAINC = -I$(CUDASDK)/common/inc -I$(CUDADIR)/include
-CCFLAGS = -DCUDA -DFP_TYPE_FLOAT -g
+CCFLAGS = -DCUDA -DFP_TYPE_FLOAT  -O2 -DSHARED_NODES_ONLY_NEIGHBOR
 
 #Headers to be copied to include directory so application users can see them
 HEADERS= ParFUM_TOPS.h ParFUM_TOPS_CUDA.h ParFUM_TOPS_Types.h $(INTERNALHEADERS)
 
 #Headers generated from .ci files
-GENHEADERS= ParFUM_TOPS.def.h ParFUM_TOPS.decl.h 
+GENHEADERS= ParFUM_TOPS.decl.h 
 
 HEADDEP= $(GENHEADERS) $(HEADERS) $(INTERNALHEADERS)
 
@@ -28,8 +28,6 @@ all: $(DEST)
 
 ParFUM_TOPS.decl.h: ParFUM_TOPS.ci
        $(CHARMC) ParFUM_TOPS.ci
-ParFUM_TOPS.def.h: ParFUM_TOPS.ci
-       $(CHARMC) ParFUM_TOPS.ci
 
 # Build libmoduleParFUM
 $(DEST): $(OBJS) headers $(HEADDEP)
index a1b8bb147da84cc14342c08f1acd22d29847a529..b8d5c03b3d78700ad05d8b48def898f0274ef2f2 100644 (file)
@@ -21,7 +21,6 @@
 #include "ParFUM_TOPS_CUDA.h"
 
 
-
 /** The attributes used within the PTOPS layer */
 #define ATT_ELEM_ID (FEM_DATA+0)
 #define ATT_ELEM_N2E_CONN (FEM_DATA+1)
@@ -65,8 +64,7 @@ class TopModel{
 #ifdef CUDA
     TopModelDevice device_model;
 #endif
-
-
+    
     TopModel(){
       nodeIDHash = NULL;
       elemIDHash = NULL;
@@ -207,48 +205,6 @@ bool topElement_IsCohesive(TopModel* m, TopElement e);
 void topNode_GetPosition(TopModel*model, TopNode node,float*x,float*y,float*z);
 void topNode_GetPosition(TopModel*model, TopNode node,double*x,double*y,double*z);
 
-/** Create Iterator for nodes */
-TopNodeItr*  topModel_CreateNodeItr(TopModel*);
-
-/** Destroy Iterator */
-void topNodeItr_Destroy(TopNodeItr*);
-
-/** Initialize Iterator */
-void topNodeItr_Begin(TopNodeItr*);
-
-/** Determine if Iterator is valid or if it has iterated past last Node */
-bool topNodeItr_IsValid(TopNodeItr*);
-
-/** Increment iterator */
-void topNodeItr_Next(TopNodeItr*);
-
-/** Get TopNode associated with the iterator */
-TopNode topNodeItr_GetCurr(TopNodeItr*);
-
-/** Get total number of elements */
-int topModel_GetNElem (TopModel* m);
-
-/** Create Iterator for elements */
-TopElemItr*  topModel_CreateElemItr(TopModel*);
-
-/** Destroy Iterator */
-void topElemItr_Destroy(TopElemItr*);
-
-/** Initialize Iterator */
-void topElemItr_Begin(TopElemItr*);
-
-/** Determine if Iterator is valid or if it has iterated past last Element */
-bool topElemItr_IsValid(TopElemItr*);
-
-/** Increment iterator */
-void topElemItr_Next(TopElemItr*);
-
-/** Get TopElement associated with the iterator */
-TopElement topElemItr_GetCurr(TopElemItr*);
-
-/** Perform sanity check on iterators. This checks to make sure that the count of the itereated elements and nodes matches that returned by ParFUM's countValid() */
-void topModel_TestIterators(TopModel*m);
-
 
 void top_retrieve_elem_data(TopModel* m);
 void top_retrieve_node_data(TopModel* m);
@@ -261,11 +217,6 @@ void top_put_data(TopModel* m);
 //==============================================================
 //   New functions that have been implemented
 
-TopNodeElemItr* topModel_CreateNodeElemItr (TopModel* m, TopNode n);
-bool topNodeElemItr_IsValid (TopNodeElemItr* neitr);
-void topNodeElemItr_Next (TopNodeElemItr* neitr);
-TopElement topNodeElemItr_GetCurr (TopNodeElemItr* neitr);
-void topNodeElemItr_Destroy (TopNodeElemItr* neitr);
 
 
 int topFacet_GetNNodes (TopModel* m, TopFacet f);
@@ -278,16 +229,6 @@ bool topVertex_IsBoundary (TopModel* m, TopVertex v);
 
 TopVertex topNode_GetVertex (TopModel* m, TopNode n);
 
-
-
-TopFacetItr* topModel_CreateFacetItr (TopModel* m);
-void topFacetItr_Begin(TopFacetItr* itr);
-bool topFacetItr_IsValid(TopFacetItr* itr);
-void topFacetItr_Next(TopFacetItr* itr);
-TopFacet topFacetItr_GetCurr (TopFacetItr* itr);
-void topFacetItr_Destroy (TopFacetItr* itr);
-
-
 TopElement topModel_InsertCohesiveAtFacet (TopModel* m, int ElemType, TopFacet f);
 
 
@@ -301,4 +242,391 @@ bool isPartitionGPU(int partition);
 
 
 
+
+#ifndef INLINE_ITERATORS
+
+
+ /** Create Iterator for nodes */
+ TopNodeItr*  topModel_CreateNodeItr(TopModel*);
+ /** Destroy Iterator */
+ void topNodeItr_Destroy(TopNodeItr*);
+ /** Initialize Iterator */
+ void topNodeItr_Begin(TopNodeItr*);
+ /** Determine if Iterator is valid or if it has iterated past last Node */
+ bool topNodeItr_IsValid(TopNodeItr*);
+ /** Increment iterator */
+ void topNodeItr_Next(TopNodeItr*);
+ /** Get TopNode associated with the iterator */
+ TopNode topNodeItr_GetCurr(TopNodeItr*);
+ /** Get total number of elements */
+ int topModel_GetNElem (TopModel* m);
+ /** Create Iterator for elements */
+ TopElemItr*  topModel_CreateElemItr(TopModel*);
+ /** Destroy Iterator */
+ void topElemItr_Destroy(TopElemItr*);
+ /** Initialize Iterator */
+ void topElemItr_Begin(TopElemItr*);
+ /** Determine if Iterator is valid or if it has iterated past last Element */
+ bool topElemItr_IsValid(TopElemItr*);
+ /** Increment iterator */
+ void topElemItr_Next(TopElemItr*);
+ /** Get TopElement associated with the iterator */
+ TopElement topElemItr_GetCurr(TopElemItr*);
+ /** Perform sanity check on iterators. This checks to make sure that the count of the itereated elements and nodes matches that returned by ParFUM's countValid() */
+ void topModel_TestIterators(TopModel*m);
+ TopNodeElemItr* topModel_CreateNodeElemItr (TopModel* m, TopNode n);
+ bool topNodeElemItr_IsValid (TopNodeElemItr* neitr);
+ void topNodeElemItr_Next (TopNodeElemItr* neitr);
+ TopElement topNodeElemItr_GetCurr (TopNodeElemItr* neitr);
+ void topNodeElemItr_Destroy (TopNodeElemItr* neitr);
+
+ TopFacetItr* topModel_CreateFacetItr (TopModel* m);
+ void topFacetItr_Begin(TopFacetItr* itr);
+ bool topFacetItr_IsValid(TopFacetItr* itr);
+ void topFacetItr_Next(TopFacetItr* itr);
+ TopFacet topFacetItr_GetCurr (TopFacetItr* itr);
+ void topFacetItr_Destroy (TopFacetItr* itr);
+
+#else 
+
+/**************************************************************************
+ **************************************************************************
+ **************************************************************************
+ *   Inlined versions of iterators
+ */
+
+
+/**************************************************************************
+ *     Iterator for nodes
+ */
+
+inline TopNodeItr*  topModel_CreateNodeItr(TopModel* model){
+    TopNodeItr *itr = new TopNodeItr;
+    itr->model = model;
+    return itr;
+}
+
+inline void topNodeItr_Destroy(TopNodeItr* itr){
+    delete itr;
+}
+
+inline void topNodeItr_Begin(TopNodeItr* itr){
+  if(itr->model->mesh->node.ghost != NULL){
+       itr->parfum_index =  FEM_To_ghost_index(itr->model->mesh->node.ghost->size());
+  }
+  else{
+       itr->parfum_index =  0;
+  }
+
+  // Make sure we start with a valid one:
+  while((!itr->model->mesh->node.is_valid_any_idx(itr->parfum_index)) &&
+               (itr->parfum_index < itr->model->mesh->node.size()))
+       itr->parfum_index++;
+
+  if(itr->parfum_index==itr->model->mesh->node.size()){
+       itr->parfum_index = itr->model->mesh->node.size()+1000; // way past the end
+  }
+
+#ifdef PTOPS_ITERATOR_PRINT
+  CkPrintf("Initializing Node Iterator to %d\n", itr->parfum_index);
+#endif
+}
+
+inline bool topNodeItr_IsValid(TopNodeItr*itr){
+       return itr->model->mesh->node.is_valid_any_idx(itr->parfum_index);
+}
+
+inline void topNodeItr_Next(TopNodeItr* itr){
+  CkAssert(topNodeItr_IsValid(itr));
+
+  // advance index until we hit a valid index
+  itr->parfum_index++;
+
+  while((!itr->model->mesh->node.is_valid_any_idx(itr->parfum_index)) &&
+               (itr->parfum_index < itr->model->mesh->node.size()))
+       itr->parfum_index++;
+
+  if(itr->parfum_index==itr->model->mesh->node.size()){
+       itr->parfum_index = itr->model->mesh->node.size()+1000; // way past the end
+  }
+
+#ifdef PTOPS_ITERATOR_PRINT
+  CkPrintf("Advancing Node Iterator to %d\n", itr->parfum_index);
+#endif
+}
+
+
+inline TopNode topNodeItr_GetCurr(TopNodeItr*itr){
+       CkAssert(topNodeItr_IsValid(itr));
+       return itr->parfum_index;
+}
+
+
+/**************************************************************************
+ *     Iterator for elements
+ * 
+ *  TODO: Iterate through both cohesives & bulk elements ?
+ * 
+ */
+
+inline TopElemItr*  topModel_CreateElemItr(TopModel* model){
+    TopElemItr *itr = new TopElemItr;
+    itr->model = model;
+    itr->type = TOP_ELEMENT_TET4;
+    return itr;
+}
+
+inline void topElemItr_Destroy(TopElemItr* itr){
+    delete itr;
+}
+
+inline void topElemItr_Begin(TopElemItr* itr){
+       itr->done = false;
+
+       if(itr->model->mesh->elem[itr->type].ghost != NULL){
+               itr->parfum_index =  FEM_To_ghost_index(itr->model->mesh->elem[itr->type].ghost->size());
+       }
+       else{
+               itr->parfum_index =  0;
+       }
+
+       // Make sure we start with a valid one:
+       while((!itr->model->mesh->elem[itr->type].is_valid_any_idx(itr->parfum_index)) &&
+                       (itr->parfum_index < itr->model->mesh->elem[itr->type].size()))
+               itr->parfum_index++;
+
+       if(itr->parfum_index==itr->model->mesh->elem[itr->type].size()){
+               itr->done = true;
+       }
+
+#ifdef PTOPS_ITERATOR_PRINT
+       CkPrintf("Initializing elem[itr->type] Iterator to %d\n", itr->parfum_index);
+#endif
+
+}
+
+inline bool topElemItr_IsValid(TopElemItr*itr){
+  return ! itr->done;
+}
+
+inline void topElemItr_Next(TopElemItr* itr){
+       CkAssert(topElemItr_IsValid(itr));
+
+       // advance index until we hit a valid index
+       itr->parfum_index++;
+
+       while((!itr->model->mesh->elem[TOP_ELEMENT_TET4].is_valid_any_idx(itr->parfum_index)) &&
+                       (itr->parfum_index < itr->model->mesh->elem[TOP_ELEMENT_TET4].size()))
+               itr->parfum_index++;
+
+
+       if(itr->parfum_index==itr->model->mesh->elem[TOP_ELEMENT_TET4].size()){
+               itr->done = true;
+       }
+
+#ifdef PTOPS_ITERATOR_PRINT
+       CkPrintf("Advancing Elem Iterator to %d\n", itr->parfum_index);
+#endif
+}
+
+
+inline TopElement topElemItr_GetCurr(TopElemItr*itr){  
+       CkAssert(topElemItr_IsValid(itr));
+       TopElement e;
+       e.id = itr->parfum_index; 
+       e.type = itr->type;
+       return e;
+}
+
+
+
+/**************************************************************************
+ *     Iterator for elements adjacent to a node
+ * 
+ *  TODO: Iterate through both cohesives & bulk elements ?
+ * 
+ */
+
+inline TopNodeElemItr* topModel_CreateNodeElemItr (TopModel* model, TopNode n){
+       TopNodeElemItr *itr = new TopNodeElemItr;
+       
+       itr->model = model;
+       itr->node = n;
+       itr->current_index=0;
+       
+       if( itr->model->mesh->node.is_valid_any_idx(n) ){
+               itr->numAdjElem = model->mesh->n2e_getLength(n);        
+       } else {
+               itr->numAdjElem = -1;
+       }
+       
+       return itr;
+}
+
+
+inline bool topNodeElemItr_IsValid (TopNodeElemItr* itr){
+    return (itr->current_index < itr->numAdjElem);
+}
+
+inline void topNodeElemItr_Next (TopNodeElemItr* itr){
+       itr->current_index ++;
+}
+
+
+inline TopElement topNodeElemItr_GetCurr (TopNodeElemItr* itr){
+       CkAssert(topNodeElemItr_IsValid(itr));
+       TopElement e;
+       // TODO Make this a const reference
+       ElemID elem = itr->model->mesh->n2e_getElem(itr->node, itr->current_index);
+       e.id = elem.getSignedId();
+       e.type = elem.getUnsignedType();
+       return e;
+}
+
+
+inline void topNodeElemItr_Destroy (TopNodeElemItr* itr){
+       delete itr;
+}
+
+
+/**************************************************************************
+ *     Iterator for Facets
+ * 
+ *  TODO : verify that we are counting the facets correctly. 
+ *               Should interior facets be found twice?
+ *                               Should boundary facets be found at all?
+ * 
+ */
+
+inline TopFacetItr* topModel_CreateFacetItr (TopModel* m){
+       TopFacetItr* itr = new TopFacetItr();
+       itr->model = m;
+       return itr;
+}
+
+
+/** Iterate to the next facet */
+inline void topFacetItr_Next(TopFacetItr* itr){
+       bool found = false;
+       
+       // Scan through all the faces on some elements until we get to the end, or we 
+       while( !found && topElemItr_IsValid(itr->elemItr) ){
+               
+               itr->whichFacet++;
+               if(itr->whichFacet > 3){
+                       topElemItr_Next(itr->elemItr);
+                       itr->whichFacet=0;
+               }
+
+               if( ! topElemItr_IsValid(itr->elemItr) ){
+                       break;
+               }
+
+               TopElement currElem = topElemItr_GetCurr(itr->elemItr);
+               ElemID e = itr->model->mesh->e2e_getElem(currElem.id, itr->whichFacet, currElem.type);
+               
+               if (e < currElem) {
+                       found = true;
+//                     CkPrintf("e.id=%d currElem.id=%d\n", e.id, currElem.id);
+               } 
+               
+       }
+       
+}
+
+
+inline void topFacetItr_Begin(TopFacetItr* itr){
+       itr->elemItr = topModel_CreateElemItr(itr->model);
+       topElemItr_Begin(itr->elemItr);
+       itr->whichFacet = 0;
+       
+       // We break the ties between two copies of a facet by looking at the two adjacent elements
+       // We must ensure that the first facet we just found is actually a valid one
+       // If it is not valid, then we go to the next one
+
+       TopElement currElem = topElemItr_GetCurr(itr->elemItr);
+       ElemID e = itr->model->mesh->e2e_getElem(currElem.id, itr->whichFacet, currElem.type);
+       if (e < currElem) {
+               // Good, this facet is valid
+       } else {
+               topFacetItr_Next(itr);
+       }
+
+}
+
+inline bool topFacetItr_IsValid(TopFacetItr* itr){
+       return topElemItr_IsValid(itr->elemItr);
+}
+
+
+
+
+
+inline TopFacet topFacetItr_GetCurr (TopFacetItr* itr){
+       TopFacet f;
+       
+       TopElement el = topElemItr_GetCurr(itr->elemItr);
+       f.elem[0] = el;
+       
+       int p1 = el.id;
+       int p2 =  itr->whichFacet;
+       int p3 =  el.type;
+
+       TopElement e = itr->model->mesh->e2e_getElem(p1,p2, p3);
+       
+       f.elem[1] = e;
+       
+       // TODO adapt this to work with cohesives
+
+       // face 0 is nodes 0,1,3
+       if(itr->whichFacet==0){
+               f.node[0] = f.node[3] = itr->model->mesh->elem[el.type].connFor(el.id)[0];
+               f.node[1] = f.node[4] = itr->model->mesh->elem[el.type].connFor(el.id)[1];
+               f.node[2] = f.node[5] = itr->model->mesh->elem[el.type].connFor(el.id)[3];
+       }
+       // face 1 is nodes 0,2,1
+       else if(itr->whichFacet==1){
+               f.node[0] = f.node[3] = itr->model->mesh->elem[el.type].connFor(el.id)[0];
+               f.node[1] = f.node[4] = itr->model->mesh->elem[el.type].connFor(el.id)[2];
+               f.node[2] = f.node[5] = itr->model->mesh->elem[el.type].connFor(el.id)[1];
+       }
+       // face 2 is nodes 1,2,3
+       else if(itr->whichFacet==2){
+               f.node[0] = f.node[3] = itr->model->mesh->elem[el.type].connFor(el.id)[1];
+               f.node[1] = f.node[4] = itr->model->mesh->elem[el.type].connFor(el.id)[2];
+               f.node[2] = f.node[5] = itr->model->mesh->elem[el.type].connFor(el.id)[3];              
+       }
+       // face 3 is nodes 0,3,2
+       else if(itr->whichFacet==3){
+               f.node[0] = f.node[3] = itr->model->mesh->elem[el.type].connFor(el.id)[0];
+               f.node[1] = f.node[4] = itr->model->mesh->elem[el.type].connFor(el.id)[3];
+               f.node[2] = f.node[5] = itr->model->mesh->elem[el.type].connFor(el.id)[2];
+       }       
+       
+       return f;
+}
+
+
+inline void topFacetItr_Destroy (TopFacetItr* itr){
+       delete itr;
+}
+
+// End of Inline Iterator Section
+#endif
+
+
 #endif
index 75306e31c34b75811f5c3ba6665553c301beaaae..4971974824dec8da15cdf18b30234aa495e64bab 100644 (file)
@@ -1,7 +1,7 @@
 #include "ParFUM_TOPS.h"
 
 
-
+#ifndef INLINE_ITERATORS
 
 /**************************************************************************
  *     Iterator for nodes
@@ -318,3 +318,4 @@ void topFacetItr_Destroy (TopFacetItr* itr){
 }
 
 
+#endif