Made TCharm and FEM routine names consistent with each other
authorOrion Lawlor <olawlor@acm.org>
Mon, 9 Sep 2002 17:53:20 +0000 (17:53 +0000)
committerOrion Lawlor <olawlor@acm.org>
Mon, 9 Sep 2002 17:53:20 +0000 (17:53 +0000)
and AMPI/Mblock: module name in caps, underscore, one initial
capital, then everything else underscore-separated lowercase:
LIBRARY_Foo_bar

16 files changed:
examples/fem/crack2D/README
src/libs/ck-libs/ampi/ampi.C
src/libs/ck-libs/armci/armci.h
src/libs/ck-libs/armci/armci_setup.C
src/libs/ck-libs/fem/fem.C
src/libs/ck-libs/fem/fem.h
src/libs/ck-libs/fem/symmetries.C
src/libs/ck-libs/mblock/mblock.C
src/libs/ck-libs/tcharm/compat_uns.c
src/libs/ck-libs/tcharm/compat_us.c
src/libs/ck-libs/tcharm/tcharm.C
src/libs/ck-libs/tcharm/tcharm.h
src/libs/ck-libs/tcharm/tcharmc.h
src/libs/ck-libs/tcharm/tcharmf.h
tests/fem/femtest/fpgm.f90
tests/fem/femtest/pgm.C

index fe90acc1b08a5877a900872c4a23d2be22fa340f..0a456e040ce3d282b336ccbd46a9495a41a9b650 100644 (file)
@@ -1,10 +1,7 @@
 This is a 2D crack propagation application built on top of the
-FEM framework. Note that one needs to use migratable threads of
-converse in order to compile and run this application.
+FEM framework.  This program is now OBSOLETE, as it uses an older
+version of the FEM framework.
 
-So, make sure that you invoke super_install as
-
-SUPER_INSTALL ampi {net-sol-cc|mpi-origin} -O -DCMK_THREADS_USE_ISOMALLOC=1
 
 In order to compile the crack2d program, you need to just type "make"
 in this directory. This wll make two programs: pgm and getmesh
index 92c6ed6bcb07536465a2b8891b41fa044f9b264c..148943863d68b836f147bf1f9532b533960287fb 100644 (file)
@@ -56,7 +56,7 @@ static void ampiNodeInit(void)
   {
     MPI_COMM_UNIVERSE[i] = MPI_COMM_WORLD+1+i;
   }
-  TCharmSetFallbackSetup(MPI_Setup_Switch);
+  TCHARM_Set_fallback_setup(MPI_Setup_Switch);
   nodeinit_has_been_called=1;
 }
 
@@ -86,12 +86,12 @@ extern "C" void MPI_threadstart(void *data)
 
 void ampiCreateMain(MPI_MainFn mainFn)
 {
-       int _nchunks=TCharmGetNumChunks();
+       int _nchunks=TCHARM_Get_num_chunks();
        
        //Make a new threads array
        MPI_threadstart_t s(mainFn);
        memBuf b; pupIntoBuf(b,s);
-       TCharmCreateData( _nchunks,MPI_threadstart,
+       TCHARM_Create_data( _nchunks,MPI_threadstart,
                          b.getData(), b.getSize());
 }
 
@@ -569,7 +569,7 @@ static ampi *getAmpiInstance(MPI_Comm comm) {
 CDECL void MPI_Migrate(void)
 {
   AMPIAPI("MPI_Migrate");
-  TCharmMigrate();
+  TCHARM_Migrate();
 }
 
 CDECL int MPI_Init(int *argc, char*** argv)
@@ -609,7 +609,7 @@ int MPI_Comm_size(MPI_Comm comm, int *size)
 CDECL void MPI_Exit(int /*exitCode*/)
 {
        AMPIAPI("MPI_Exit");
-       TCharmDone();
+       TCHARM_Done();
 }
 FDECL void FTN_NAME(MPI_EXIT,mpi_exit)(int *exitCode)
 {
@@ -810,7 +810,7 @@ int MPI_Allreduce(void *inbuf, void *outbuf, int count, int type,
 CDECL
 double MPI_Wtime(void)
 {
-  return TCharmWallTimer();
+  return TCHARM_Wall_timer();
 }
 
 
@@ -1447,14 +1447,14 @@ CDECL
 int MPI_Register(void *d, MPI_PupFn f)
 {
        AMPIAPI("MPI_Register");
-       return TCharmRegister(d,f);
+       return TCHARM_Register(d,f);
 }
 
 CDECL
 void *MPI_Get_userdata(int idx)
 {
        AMPIAPI("MPI_Get_userdata");
-       return TCharmGetUserdata(idx);
+       return TCHARM_Get_userdata(idx);
 }
 
 CDECL void MPI_Register_main(MPI_MainFn mainFn,const char *name)
index 4446134ac0a2df93184e9d28eb30fc12f354bd76..cfe4ab491e9f9f6c7b0073345672904b95252554 100644 (file)
@@ -15,7 +15,7 @@ CDECL void armciStart(int argc, char **argv);
 CDECL void ARMCI_Attach(void);
 
 // redefine global variables used by armci
-#define armci_me TCharmElement()
+#define armci_me TCHARM_Element()
 #define armci_master 0
 // #define armci_nproc CpvAccess(_armci_nproc)
 // #define armci_nproc TCharmGetNumChunks() // not good. A once-only call!
index 879a3d706fa911ef8b2cde28c1cca662dff60c35..fe7a7c7df5aa101bdc92e95dc08508c30edc6db1 100644 (file)
@@ -13,7 +13,7 @@ extern "C" void armciLibStart(void) {
 // in the Node initialization function.
 static void ArmciDefaultSetup(void) {
   // Create the base threads on TCharm using user-defined start routine.
-  TCharmCreate(TCharmGetNumChunks(), armciLibStart);
+  TCHARM_Create(TCHARM_Get_num_chunks(), armciLibStart);
   // Attach the array of TCShmemThreads to the corresponding TCharm threads.
   ARMCI_Attach();
 }
@@ -24,14 +24,14 @@ static void ArmciDefaultSetup(void) {
 // his/her own startup routine and/or employ multi-module programs.
 void ARMCI_Attach(void) {
   CkArrayID _tc_aid;
-  CkArrayOptions opt = TCharmAttachStart(&_tc_aid, NULL);
+  CkArrayOptions opt = TCHARM_Attach_start(&_tc_aid, NULL);
   CkArrayID aid = CProxy_ArmciVirtualProcessor::ckNew(_tc_aid, opt);
   CProxy_ArmciVirtualProcessor vpProxy = CProxy_ArmciVirtualProcessor(aid);
   CkArrayID *clientAid = new CkArrayID;
   *clientAid = aid;
   vpProxy.setReductionClient(mallocClient, (void *)clientAid);
-  TCharmAttachFinish(aid);
-  armci_nproc = TCharmNumElements();
+  TCHARM_Attach_finish(aid);
+  armci_nproc = TCHARM_Num_elements();
 }
 
 
@@ -43,7 +43,7 @@ void armciNodeInit(void) {
   CtvAccess(_armci_ptr) = NULL;
 
   // Register the library's default startup routine to TCharm
-  TCharmSetFallbackSetup(ArmciDefaultSetup);
+  TCHARM_Set_fallback_setup(ArmciDefaultSetup);
 };
 
 #include "armci.def.h"
index 3309504715d8df0fd1ab92a0160fb24156a36090..3bd3905b1aab621fe94b037a67f8509087824b69 100644 (file)
@@ -39,10 +39,10 @@ static int initFlags=0;
 
 static void FEMfallbackSetup(void)
 {
-       int nChunks=TCharmGetNumChunks();
+       int nChunks=TCHARM_Get_num_chunks();
        char **argv=CkGetArgv();
        int initFlags=0;
-       TCharmCreate(nChunks,callDrivers);
+       TCHARM_Create(nChunks,callDrivers);
        if (!(initFlags&FEM_INIT_READ)) {
                fem_impl_call_init(); // init();
                FTN_NAME(INIT,init)();
@@ -58,7 +58,7 @@ PUPable_def(FEM_Sym_Linear);
 void FEMnodeInit(void) {
        PUPable_reg(FEM_Sym_Linear);
        CtvInitialize(FEMchunk*, _femptr);
-       TCharmSetFallbackSetup(FEMfallbackSetup);
+       TCHARM_Set_fallback_setup(FEMfallbackSetup);
        char **argv=CkGetArgv();
        if (CmiGetArgFlag(argv,"-read")) initFlags|=FEM_INIT_READ;
        if (CmiGetArgFlag(argv,"-write")) initFlags|=FEM_INIT_WRITE;    
@@ -163,7 +163,7 @@ CDECL void FEM_Attach(int flags)
 {
        FEMAPI("FEM_Attach");
        CkArrayID threadsAID; int _nchunks;
-       CkArrayOptions opts=TCharmAttachStart(&threadsAID,&_nchunks);
+       CkArrayOptions opts=TCHARM_Attach_start(&threadsAID,&_nchunks);
        
        if (flags&FEM_INIT_WRITE) 
        { //First save the user's globals (if any):
@@ -186,7 +186,7 @@ CDECL void FEM_Attach(int flags)
        CProxy_FEMchunk chunks= CProxy_FEMchunk::ckNew(init,opts);
        chunks.setReductionClient(_allReduceHandler, new CProxy_FEMchunk(chunks));
        coord.setArray(chunks);
-       TCharmAttachFinish(chunks);
+       TCHARM_Attach_finish(chunks);
        
        //Send the mesh out to the chunks
        if (_meshptr!=NULL) 
@@ -314,7 +314,7 @@ public:
     chks[chunkNo]=chk;
   }
   void useChunk(int i) {
-    if (i<0 || i>=nchunks) CkAbort("Invalid index passed to FEM_Serial_Begin!");
+    if (i<0 || i>=nchunks) CkAbort("Invalid index passed to FEM_Serial_begin!");
     FILE *fp=openMeshFile(i,nchunks,false);
     chks[i]->write(fp); /*closes file*/
     _meshptr=&chks[i]->m;
@@ -322,25 +322,25 @@ public:
 };
 
 static MeshChunkOutputStorer *meshChunkStore=NULL;
-CDECL void FEM_Serial_Split(int npieces) {
-  FEMAPI("FEM_Serial_Split");
+CDECL void FEM_Serial_split(int npieces) {
+  FEMAPI("FEM_Serial_split");
   meshChunkStore=new MeshChunkOutputStorer(npieces);
   mesh_split(npieces,meshChunkStore);
   SaveTCharmGlobals(npieces);
 }
 FDECL void FTN_NAME(FEM_SERIAL_SPLIT,fem_serial_split)(int *npieces)
 { 
-  FEM_Serial_Split(*npieces); 
+  FEM_Serial_split(*npieces); 
 }
 
-CDECL void FEM_Serial_Begin(int chunkNo) {
-  FEMAPI("FEM_Serial_Begin");
-  if (!meshChunkStore) CkAbort("Can't call FEM_Serial_Begin before FEM_Serial_Split!");
+CDECL void FEM_Serial_begin(int chunkNo) {
+  FEMAPI("FEM_Serial_begin");
+  if (!meshChunkStore) CkAbort("Can't call FEM_Serial_begin before FEM_Serial_split!");
   meshChunkStore->useChunk(chunkNo);
 }
 FDECL void FTN_NAME(FEM_SERIAL_BEGIN,fem_serial_begin)(int *pieceNo)
 {
-  FEM_Serial_Begin(*pieceNo-1);
+  FEM_Serial_begin(*pieceNo-1);
 }
 
 
@@ -436,11 +436,11 @@ void FEM_Sparse::get(int *n,int idxBase,char *d) const
        data.get(d);
 }
 
-CDECL void FEM_Set_Sparse(int uniqueID,int nTuples,
+CDECL void FEM_Set_sparse(int uniqueID,int nTuples,
        const int *nodes,int nodesPerTuple,
        const void *data,int dataPerTuple,int dataType)
 {
-       FEMAPI("FEM_Set_Sparse");
+       FEMAPI("FEM_Set_sparse");
        int bytesPerTuple=dataPerTuple*DType::type_size(dataType);
        FEM_Sparse *s=new FEM_Sparse(nodesPerTuple,bytesPerTuple);
        s->set(nTuples,nodes,0,(char *)data);
@@ -457,37 +457,37 @@ FDECL void FTN_NAME(FEM_SET_SPARSE,fem_set_sparse)
        s->set(*nTuples,nodes,1,(char *)data);
        setMesh()->setSparse(*uniqueID-1,s);
 }
-CDECL void FEM_Set_Sparse_Elem(int uniqueID,const int *rec2elem)
+CDECL void FEM_Set_sparse_elem(int uniqueID,const int *rec2elem)
 {
-       FEMAPI("FEM_Set_Sparse_Elem");
+       FEMAPI("FEM_Set_sparse_elem");
        FEM_Sparse &s=setMesh()->setSparse(uniqueID);
        s.setElem(CkCopyArray(rec2elem,2*s.size(),0));
 }
 FDECL void FTN_NAME(FEM_SET_SPARSE_ELEM,fem_set_sparse_elem)
        (const int *uniqueID,int *rec2elem)
 {
-       FEMAPI("FEM_Set_Sparse_Elem");
+       FEMAPI("FEM_Set_sparse_elem");
        FEM_Sparse &s=setMesh()->setSparse(*uniqueID-1);
        s.setElem(CkCopyArray(rec2elem,2*s.size(),1));
 }
 
-CDECL int  FEM_Get_Sparse_Length(int uniqueID)
+CDECL int  FEM_Get_sparse_length(int uniqueID)
 {
-       FEMAPI("FEM_Get_Sparse_Length");
+       FEMAPI("FEM_Get_sparse_length");
        return getMesh()->getSparse(uniqueID).size();
 }
-CDECL void FEM_Get_Sparse(int uniqueID,int *tuples,void *data)
+CDECL void FEM_Get_sparse(int uniqueID,int *tuples,void *data)
 {
-       FEMAPI("FEM_Get_Sparse");
+       FEMAPI("FEM_Get_sparse");
        getMesh()->getSparse(uniqueID).get(tuples,0,(char *)data);
 }
 FDECL int  FTN_NAME(FEM_GET_SPARSE_LENGTH,fem_get_sparse_length)(int *uniqueID)
 {
-       return FEM_Get_Sparse_Length(*uniqueID-1);
+       return FEM_Get_sparse_length(*uniqueID-1);
 }
 FDECL void FTN_NAME(FEM_GET_SPARSE,fem_get_sparse)(int *uniqueID,int *tuples,void *data)
 {
-       FEMAPI("FEM_Get_Sparse");
+       FEMAPI("FEM_Get_sparse");
        getMesh()->getSparse(*uniqueID-1).get(tuples,1,(char *)data);
 }
 
@@ -501,8 +501,8 @@ static FEM_Mesh &getRenumber(void) {
 }
 
 //Clear any previous binding for element type elType:
-CDECL void FEM_Composite_Elem(int elType) {
-       FEMAPI("FEM_Composite_Elem");
+CDECL void FEM_Composite_elem(int elType) {
+       FEMAPI("FEM_Composite_elem");
        FEM_Mesh &m=getRenumber();
        if (elType<m.elem.size())
                m.elem.reinit(elType);
@@ -510,7 +510,7 @@ CDECL void FEM_Composite_Elem(int elType) {
                m.elem.makeLonger(elType);
 }
 FDECL void FTN_NAME(FEM_COMPOSITE_ELEM,fem_composite_elem)(int *elType) {
-       FEM_Composite_Elem(*elType-1);
+       FEM_Composite_elem(*elType-1);
 }
 
 
@@ -532,11 +532,11 @@ static void combineList(const FEM_Comm &src,FEM_Comm &dest,
 //Combine the ghost records for srcType and destType,
 //  shifting srcType's interior elements to start at "startInt"
 //  and its ghost elements to start at "startGhost"
-CDECL void FEM_Combine_Elem(
+CDECL void FEM_Combine_elem(
        int srcType,int destType,
        int startInt,int startGhost) 
 {
-       FEMAPI("FEM_Combine_Elem");
+       FEMAPI("FEM_Combine_elem");
        FEM_Mesh &m=getRenumber();
        const FEM_Item &src=m.getCount(srcType);
        FEM_Item &dest=m.setCount(destType);
@@ -550,7 +550,7 @@ CDECL void FEM_Combine_Elem(
 FDECL void FTN_NAME(FEM_COMBINE_ELEM,fem_combine_elem)(
        int *srcType,int *destType,int *startInt,int *startGhost) 
 {
-       FEM_Combine_Elem(*srcType-1,*destType-1,*startInt-1,*startGhost-1);
+       FEM_Combine_elem(*srcType-1,*destType-1,*startInt-1,*startGhost-1);
 }
 
 #endif
@@ -562,8 +562,8 @@ static void Set_Partition(int *elem2chunk,int indexBase) {
 }
 
 //C bindings:
-CDECL void FEM_Set_Partition(int *elem2chunk) {
-       FEMAPI("FEM_Set_Partition");
+CDECL void FEM_Set_partition(int *elem2chunk) {
+       FEMAPI("FEM_Set_partition");
        Set_Partition(elem2chunk,0);
 }
 
@@ -571,65 +571,65 @@ CDECL void FEM_Set_Partition(int *elem2chunk) {
 FDECL void FTN_NAME(FEM_SET_PARTITION,fem_set_partition)
        (int *elem2chunk) 
 {
-       FEMAPI("FEM_Set_Partition");
+       FEMAPI("FEM_Set_partition");
        Set_Partition(elem2chunk,1);
 }
 
 /***** Mesh-Setting API: C bindings*/
-CDECL void FEM_Set_Node(int nNodes,int dataPer) 
+CDECL void FEM_Set_node(int nNodes,int dataPer) 
 {
-       FEMAPI("FEM_Set_Node");
+       FEMAPI("FEM_Set_node");
        setMesh()->node.allocate(nNodes,dataPer);
 }
-CDECL void FEM_Set_Node_Data(const double *data) 
+CDECL void FEM_Set_node_data(const double *data) 
 {
-       FEMAPI("FEM_Set_Node_Data");
+       FEMAPI("FEM_Set_node_data");
        setMesh()->node.setUdata().set(data);
 }
 
-CDECL void FEM_Set_Elem(int elType,int nElem,int dataPer,int nodePer) {
-       FEMAPI("FEM_Set_Elem");
+CDECL void FEM_Set_elem(int elType,int nElem,int dataPer,int nodePer) {
+       FEMAPI("FEM_Set_elem");
        FEM_Mesh *m=setMesh();
        m->elem.makeLonger(elType);
        m->elem[elType].allocate(nElem,dataPer,nodePer);
 }
-CDECL void FEM_Set_Elem_Data(int elType,const double *data) 
+CDECL void FEM_Set_elem_data(int elType,const double *data) 
 {
-       FEMAPI("FEM_Set_Elem_Data");
+       FEMAPI("FEM_Set_elem_data");
        setMesh()->setElem(elType).setUdata().set(data);
 }
-CDECL void FEM_Set_Elem_Conn(int elType,const int *conn) {
-       FEMAPI("FEM_Set_Elem_Conn");
+CDECL void FEM_Set_elem_conn(int elType,const int *conn) {
+       FEMAPI("FEM_Set_elem_conn");
        setMesh()->setElem(elType).setConn().set(conn);
 }
 
 /*Convenience routine: for use when you only have one kind of element
 and no userdata.*/
-CDECL void FEM_Set_Mesh(int nelem, int nnodes, int ctype, int *conn)
+CDECL void FEM_Set_mesh(int nelem, int nnodes, int ctype, int *conn)
 {
-       FEMAPI("FEM_Set_Mesh");
-       FEM_Set_Node(nnodes,0);
-       FEM_Set_Elem(0,nelem,0,ctype);
-       FEM_Set_Elem_Conn(0,conn);
+       FEMAPI("FEM_Set_mesh");
+       FEM_Set_node(nnodes,0);
+       FEM_Set_elem(0,nelem,0,ctype);
+       FEM_Set_elem_conn(0,conn);
 }
 
 FDECL void FTN_NAME(FEM_SET_NODE,fem_set_node)
        (int *nNodes,int *dataPer) 
 {
-       FEMAPI("FEM_Set_Node");
-       FEM_Set_Node(*nNodes,*dataPer);
+       FEMAPI("FEM_Set_node");
+       FEM_Set_node(*nNodes,*dataPer);
 }
 
 FDECL void FTN_NAME(FEM_SET_NODE_DATA_R,fem_set_node_data_r)
        (double *data) 
 {
-       FEMAPI("FEM_Set_Node_Data_r");
+       FEMAPI("FEM_Set_node_data_r");
        setMesh()->node.setUdata().set(data);
 }
 FDECL void FTN_NAME(FEM_SET_NODE_DATA_C,fem_set_node_data_c)
        (double *data) 
 {
-       FEMAPI("FEM_Set_Node_Data_c");
+       FEMAPI("FEM_Set_node_data_c");
        setMesh()->node.setUdata().setTranspose(data);
 }
 
@@ -637,7 +637,7 @@ FDECL void FTN_NAME(FEM_SET_ELEM,fem_set_elem)
        (int *elType,int *nElem,int *dataPer,int *nodePer)  
 {
        FEMAPI("FEM_set_elem");
-       FEM_Set_Elem(*elType-1,*nElem,*dataPer,*nodePer);
+       FEM_Set_elem(*elType-1,*nElem,*dataPer,*nodePer);
 }
 FDECL void FTN_NAME(FEM_SET_ELEM_DATA_R,fem_set_elem_data_r)
        (int *elType,double *data)
@@ -678,35 +678,35 @@ FDECL void FTN_NAME(FEM_SET_MESH,fem_set_mesh)
 
 /***** Mesh-Getting API: C bindings*/
 
-CDECL void FEM_Get_Node(int *nNodes,int *dataPer) 
+CDECL void FEM_Get_node(int *nNodes,int *dataPer) 
 {
-       FEMAPI("FEM_Get_Node");
+       FEMAPI("FEM_Get_node");
        const FEM_Mesh *m=getMesh();
        if (nNodes!=NULL) *nNodes=m->node.size();
        if (dataPer!=NULL) *dataPer=m->node.getDataPer();
 }
-CDECL void FEM_Get_Node_Data(double *data) 
+CDECL void FEM_Get_node_data(double *data) 
 {
-       FEMAPI("FEM_Get_Node_Data");
+       FEMAPI("FEM_Get_node_data");
        getMesh()->node.getUdata().get(data);
 }
 
-CDECL void FEM_Get_Elem(int elType,int *nElem,int *dataPer,int *nodePer) 
+CDECL void FEM_Get_elem(int elType,int *nElem,int *dataPer,int *nodePer) 
 {
-       FEMAPI("FEM_Get_Elem");
+       FEMAPI("FEM_Get_elem");
        const FEM_Mesh *m=getMesh();
        m->chkET(elType);
        if (nElem!=NULL) *nElem=m->elem[elType].size();
        if (dataPer!=NULL) *dataPer=m->elem[elType].getDataPer();
        if (nodePer!=NULL) *nodePer=m->elem[elType].getNodesPer();
 }
-CDECL void FEM_Get_Elem_Data(int elType,double *data) 
+CDECL void FEM_Get_elem_data(int elType,double *data) 
 {
-       FEMAPI("FEM_Get_Elem_Data");
+       FEMAPI("FEM_Get_elem_data");
        getMesh()->getCount(elType).getUdata().get(data);
 }
-CDECL void FEM_Get_Elem_Conn(int elType,int *conn) {
-       FEMAPI("FEM_Get_Elem_Conn");
+CDECL void FEM_Get_elem_conn(int elType,int *conn) {
+       FEMAPI("FEM_Get_elem_conn");
        getMesh()->getElem(elType).getConn().get(conn);
 }
 
@@ -714,7 +714,7 @@ FDECL void FTN_NAME(FEM_GET_NODE,fem_get_node)
        (int *nNodes,int *dataPer) 
 {
        FEMAPI("FEM_Get_node");
-       FEM_Get_Node(nNodes,dataPer);
+       FEM_Get_node(nNodes,dataPer);
 }
 FDECL void FTN_NAME(FEM_GET_NODE_DATA_R,fem_get_node_data_r)
        (double *data) 
@@ -733,7 +733,7 @@ FDECL void FTN_NAME(FEM_GET_ELEM,fem_get_elem)
        (int *elType,int *nElem,int *dataPer,int *nodePer)  
 {
        FEMAPI("FEM_Get_elem");
-       FEM_Get_Elem(*elType-1,nElem,dataPer,nodePer);
+       FEM_Get_elem(*elType-1,nElem,dataPer,nodePer);
 }
 FDECL void FTN_NAME(FEM_GET_ELEM_DATA_R,fem_get_elem_data_r)
        (int *elType,double *data) 
@@ -1426,78 +1426,78 @@ static FEMchunk *getCurChunk(void)
   return cptr;
 }
 
-CDECL void FEM_Update_Mesh(int callMeshUpdated,int doWhat) 
+CDECL void FEM_Update_mesh(int callMeshUpdated,int doWhat) 
 { 
-  FEMAPI("FEM_Update_Mesh");
+  FEMAPI("FEM_Update_mesh");
   getCurChunk()->updateMesh(callMeshUpdated,doWhat); 
 }
 
 CDECL int FEM_Register(void *_ud,FEM_PupFn _pup_ud)
 {
   FEMAPI("FEM_Register");
-  return TCharmRegister(_ud,_pup_ud);
+  return TCHARM_Register(_ud,_pup_ud);
 }
 
-CDECL void *FEM_Get_Userdata(int n)
+CDECL void *FEM_Get_userdata(int n)
 {
-  FEMAPI("FEM_Get_Userdata");
-  return TCharmGetUserdata(n);
+  FEMAPI("FEM_Get_userdata");
+  return TCHARM_Get_userdata(n);
 }
 
-CDECL void FEM_Barrier(void) {TCharmBarrier();}
-FDECL void FTN_NAME(FEM_BARRIER,fem_barrier)(void) {TCharmBarrier();}
+CDECL void FEM_Barrier(void) {TCHARM_Barrier();}
+FDECL void FTN_NAME(FEM_BARRIER,fem_barrier)(void) {TCHARM_Barrier();}
 
 CDECL void
 FEM_Migrate(void)
 {
-  TCharmMigrate();
+  TCHARM_Migrate();
 }
 
 CDECL int *
-FEM_Get_Node_Nums(void)
+FEM_Get_node_nums(void)
 {
-  FEMAPI("FEM_Get_Node_Nums");
+  FEMAPI("FEM_Get_node_nums");
   return getCurChunk()->getNodeNums();
 }
 
 CDECL int *
-FEM_Get_Elem_Nums(void)
+FEM_Get_elem_nums(void)
 {
-  FEMAPI("FEM_Get_Elem_Nums");
+  FEMAPI("FEM_Get_elem_nums");
   return getCurChunk()->getElemNums();
 }
 
 CDECL void 
 FEM_Done(void)
 {
-  TCharmDone();
+  TCHARM_Done();
 }
 
 CDECL int 
-FEM_Create_Simple_Field(int base_type, int vec_len)
+FEM_Create_simple_field(int base_type, int vec_len)
 {
-  FEMAPI("FEM_Create_Field");
+  FEMAPI("FEM_Create_simple_field");
   return getCurChunk()->new_DT(DType(base_type, vec_len));
 }
 
 CDECL int 
-FEM_Create_Field(int base_type, int vec_len, int init_offset, int distance)
+FEM_Create_field(int base_type, int vec_len, int init_offset, int distance)
 {
-  FEMAPI("FEM_Create_Field");
+  FEMAPI("FEM_Create_field");
   return getCurChunk()->new_DT(DType(base_type, vec_len, init_offset, distance));
 }
 
 CDECL void
-FEM_Update_Field(int fid, void *nodes)
+FEM_Update_field(int fid, void *nodes)
 {
-  FEMAPI("FEM_Update_Field");
+  FEMAPI("FEM_Update_field");
   getCurChunk()->update(fid, nodes);
 }
 
 CDECL void
-FEM_Reduce_Field(int fid, const void *nodes, void *outbuf, int op)
+FEM_Reduce_field(int fid, const void *nodes, void *outbuf, int op)
 {
-  FEMAPI("FEM_Reduce_Field");
+  FEMAPI("FEM_Reduce_field");
   getCurChunk()->reduce_field(fid, nodes, outbuf, op);
 }
 
@@ -1509,28 +1509,28 @@ FEM_Reduce(int fid, const void *inbuf, void *outbuf, int op)
 }
 
 CDECL void
-FEM_Read_Field(int fid, void *nodes, const char *fname)
+FEM_Read_field(int fid, void *nodes, const char *fname)
 {
-  FEMAPI("FEM_Read_Field");
+  FEMAPI("FEM_Read_field");
   getCurChunk()->readField(fid, nodes, fname);
 }
 
 CDECL int
-FEM_My_Partition(void)
+FEM_My_partition(void)
 {
-  return TCharmElement();
+  return TCHARM_Element();
 }
 
 CDECL int
-FEM_Num_Partitions(void)
+FEM_Num_partitions(void)
 {
-  return TCharmNumElements();
+  return TCHARM_Num_elements();
 }
 
 CDECL double
 FEM_Timer(void)
 {
-  return TCharmWallTimer();
+  return TCHARM_Wall_timer();
 }
 
 CDECL void 
@@ -1546,7 +1546,7 @@ FEM_Print(const char *str)
 }
 
 CDECL void 
-FEM_Print_Partition(void)
+FEM_Print_partition(void)
 {
   FEMAPI("FEM_Print_Partition");
   if(TCharm::getState()==inDriver) {
@@ -1554,32 +1554,32 @@ FEM_Print_Partition(void)
     cptr->print();
   } else {
     if (_meshptr==NULL)
-      CkPrintf("[%d] No serial mesh available.\n",FEM_My_Partition());
+      CkPrintf("[%d] No serial mesh available.\n",FEM_My_partition());
     else
       _meshptr->print(l2g_t());
   }
 }
 
-CDECL int FEM_Get_Comm_Partners(void)
+CDECL int FEM_Get_comm_partners(void)
 {
        FEMAPI("FEM_Get_Comm_Partners");
        return getCurChunk()->getComm().size();
 }
-CDECL int FEM_Get_Comm_Partner(int partnerNo)
+CDECL int FEM_Get_comm_partner(int partnerNo)
 {
        FEMAPI("FEM_Get_Comm_Partner");
        return getCurChunk()->getComm().getLocalList(partnerNo).getDest();
 }
-CDECL int FEM_Get_Comm_Count(int partnerNo)
+CDECL int FEM_Get_comm_count(int partnerNo)
 {
        FEMAPI("FEM_Get_Comm_Count");
        return getCurChunk()->getComm().getLocalList(partnerNo).size();
 }
-CDECL void FEM_Get_Comm_Nodes(int partnerNo,int *nodeNos)
+CDECL void FEM_Get_comm_nodes(int partnerNo,int *nodeNos)
 {
-       FEMAPI("FEM_Get_Comm_Nodes");
+       FEMAPI("FEM_Get_comm_nodes");
        const int *nNo=getCurChunk()->getComm().getLocalList(partnerNo).getVec();
-       int len=FEM_Get_Comm_Count(partnerNo);
+       int len=FEM_Get_comm_count(partnerNo);
        for (int i=0;i<len;i++)
                nodeNos[i]=nNo[i];
 }
@@ -1588,7 +1588,7 @@ CDECL void FEM_Get_Comm_Nodes(int partnerNo,int *nodeNos)
 FDECL void FTN_NAME(FEM_UPDATE_MESH,fem_update_mesh)
   (int *callMesh, int *repart)
 {
-  FEM_Update_Mesh(*callMesh,*repart);
+  FEM_Update_mesh(*callMesh,*repart);
 }
 
 FDECL int FTN_NAME(FEM_REGISTER,fem_register)
@@ -1606,24 +1606,24 @@ FDECL void FTN_NAME(FEM_MIGRATE,fem_migrate)
 FDECL int FTN_NAME(FEM_CREATE_SIMPLE_FIELD,fem_create_simple_field)
   (int *bt, int *vl)
 {
-  return FEM_Create_Simple_Field(*bt, *vl);
+  return FEM_Create_simple_field(*bt, *vl);
 }
 FDECL int FTN_NAME(FEM_CREATE_FIELD,fem_create_field)
   (int *bt, int *vl, int *io, int *d)
 {
-  return FEM_Create_Field(*bt, *vl, *io, *d);
+  return FEM_Create_field(*bt, *vl, *io, *d);
 }
 
 FDECL void FTN_NAME(FEM_UPDATE_FIELD,fem_update_field)
   (int *fid, void *nodes)
 {
-  FEM_Update_Field(*fid, nodes);
+  FEM_Update_field(*fid, nodes);
 }
 
 FDECL void  FTN_NAME(FEM_REDUCE_FIELD,fem_reduce_field)
   (int *fid, void *nodes, void *outbuf, int *op)
 {
-  FEM_Reduce_Field(*fid, nodes, outbuf, *op);
+  FEM_Reduce_field(*fid, nodes, outbuf, *op);
 }
 
 FDECL void FTN_NAME(FEM_REDUCE,fem_reduce)
@@ -1638,20 +1638,20 @@ FDECL void FTN_NAME(FEM_READ_FIELD,fem_read_field)
   char *tmp = new char[len+1]; CHK(tmp);
   memcpy(tmp, fname, len);
   tmp[len] = '\0';
-  FEM_Read_Field(*fid, nodes, tmp);
+  FEM_Read_field(*fid, nodes, tmp);
   delete[] tmp;
 }
 
 FDECL int FTN_NAME(FEM_MY_PARTITION,fem_my_partition)
   (void)
 {
-  return FEM_My_Partition()+1;
+  return FEM_My_partition()+1;
 }
 
 FDECL int FTN_NAME(FEM_NUM_PARTITIONS,fem_num_partitions)
   (void)
 {
-  return FEM_Num_Partitions();
+  return FEM_Num_partitions();
 }
 
 FDECL double FTN_NAME(FEM_TIMER,fem_timer)
@@ -1682,7 +1682,7 @@ FDECL void FTN_NAME(FEM_PRINT,fem_print)
 FDECL void FTN_NAME(FEM_PRINT_PARTITION,fem_print_partition)
   (void)
 {
-  FEM_Print_Partition();
+  FEM_Print_partition();
 }
 
 FDECL void FTN_NAME(FEM_DONE,fem_done)
@@ -1694,24 +1694,24 @@ FDECL void FTN_NAME(FEM_DONE,fem_done)
 FDECL int FTN_NAME(FEM_GET_COMM_PARTNERS,fem_get_comm_partners)
        (void)
 {
-       return FEM_Get_Comm_Partners();
+       return FEM_Get_comm_partners();
 }
 FDECL int FTN_NAME(FEM_GET_COMM_PARTNER,fem_get_comm_partner)
        (int *partnerNo)
 {
-       return FEM_Get_Comm_Partner(*partnerNo-1)+1;
+       return FEM_Get_comm_partner(*partnerNo-1)+1;
 }
 FDECL int FTN_NAME(FEM_GET_COMM_COUNT,fem_get_comm_count)
        (int *partnerNo)
 {
-       return FEM_Get_Comm_Count(*partnerNo-1);
+       return FEM_Get_comm_count(*partnerNo-1);
 }
 FDECL void FTN_NAME(FEM_GET_COMM_NODES,fem_get_comm_nodes)
        (int *pNo,int *nodeNos)
 {
        int partnerNo=*pNo-1;
        const int *nNo=getCurChunk()->getComm().getLocalList(partnerNo).getVec();
-       int len=FEM_Get_Comm_Count(partnerNo);
+       int len=FEM_Get_comm_count(partnerNo);
        for (int i=0;i<len;i++)
                nodeNos[i]=nNo[i]+1;
 }
@@ -1719,7 +1719,7 @@ FDECL void FTN_NAME(FEM_GET_COMM_NODES,fem_get_comm_nodes)
 FDECL void FTN_NAME(FEM_GET_ELEM_NUMBERS,fem_get_elem_numbers)
        (int *gNo)
 {
-       FEMAPI("FEM_Get_Elem_Numbers");
+       FEMAPI("FEM_Get_elem_Numbers");
        const int *no=getCurChunk()->getElemNums();
        int n=getMesh()->nElems();
        for (int i=0;i<n;i++) gNo[i]=no[i]+1;
@@ -1727,7 +1727,7 @@ FDECL void FTN_NAME(FEM_GET_ELEM_NUMBERS,fem_get_elem_numbers)
 FDECL void FTN_NAME(FEM_GET_NODE_NUMBERS,fem_get_node_numbers)
        (int *gNo)
 {
-       FEMAPI("FEM_Get_Node_Numbers");
+       FEMAPI("FEM_Get_node_Numbers");
        const int *no=getCurChunk()->getNodeNums();
        int n=getMesh()->node.size();
        for (int i=0;i<n;i++) gNo[i]=no[i]+1;
@@ -1740,9 +1740,9 @@ FEM_Ghost &FEM_Set_FEM_Ghost(void) {
        return ghosts;
 }
 
-CDECL void FEM_Add_Ghost_Layer(int nodesPerTuple,int doAddNodes)
+CDECL void FEM_Add_ghost_layer(int nodesPerTuple,int doAddNodes)
 {
-       FEMAPI("FEM_Add_Ghost_Layer");
+       FEMAPI("FEM_Add_ghost_layer");
        curGhostLayer=FEM_Set_FEM_Ghost().addLayer();
        curGhostLayer->nodesPerTuple=nodesPerTuple;
        curGhostLayer->addNodes=(doAddNodes!=0);
@@ -1750,13 +1750,13 @@ CDECL void FEM_Add_Ghost_Layer(int nodesPerTuple,int doAddNodes)
 }
 FDECL void FTN_NAME(FEM_ADD_GHOST_LAYER,fem_add_ghost_layer)
        (int *nodesPerTuple,int *doAddNodes)
-{ FEM_Add_Ghost_Layer(*nodesPerTuple,*doAddNodes); }
+{ FEM_Add_ghost_layer(*nodesPerTuple,*doAddNodes); }
 
-CDECL void FEM_Add_Ghost_Elem(int elType,int tuplesPerElem,const int *elem2tuple)
+CDECL void FEM_Add_ghost_elem(int elType,int tuplesPerElem,const int *elem2tuple)
 {
-       FEMAPI("FEM_Add_Ghost_Elem");
+       FEMAPI("FEM_Add_ghost_elem");
        if (curGhostLayer==NULL)
-               CkAbort("You must call FEM_Add_Ghost_Layer before calling FEM_Add_Ghost_Elem!\n");
+               CkAbort("You must call FEM_Add_Ghost_Layer before calling FEM_Add_Ghost_elem!\n");
        curGhostLayer->elem[elType].add=true;
        curGhostLayer->elem[elType].tuplesPerElem=tuplesPerElem;
        curGhostLayer->elem[elType].elem2tuple=CkCopyArray(elem2tuple,
@@ -1769,7 +1769,7 @@ FDECL void FTN_NAME(FEM_ADD_GHOST_ELEM,fem_add_ghost_elem)
        int elType=*FelType-1;
        int tuplesPerElem=*FtuplesPerElem;
        if (curGhostLayer==NULL)
-               CkAbort("You must call FEM_Add_Ghost_Layer before calling FEM_Add_Ghost_Elem!\n");
+               CkAbort("You must call FEM_Add_Ghost_Layer before calling FEM_Add_Ghost_elem!\n");
        getMesh()->chkET(elType);
        curGhostLayer->elem[elType].add=true;
        curGhostLayer->elem[elType].tuplesPerElem=tuplesPerElem;
@@ -1778,31 +1778,31 @@ FDECL void FTN_NAME(FEM_ADD_GHOST_ELEM,fem_add_ghost_elem)
 }
 
 
-CDECL int FEM_Get_Node_Ghost(void) {
-       FEMAPI("FEM_Get_Node_Ghost");
+CDECL int FEM_Get_node_ghost(void) {
+       FEMAPI("FEM_Get_node_Ghost");
        return getMesh()->node.getGhostStart();
 }
 FDECL int FTN_NAME(FEM_GET_NODE_GHOST,fem_get_node_ghost)(void) {
-       return 1+FEM_Get_Node_Ghost();
+       return 1+FEM_Get_node_ghost();
 }
 
-CDECL int FEM_Get_Elem_Ghost(int elType) {
-       FEMAPI("FEM_Get_Elem_Ghost");
+CDECL int FEM_Get_elem_ghost(int elType) {
+       FEMAPI("FEM_Get_elem_ghost");
        return getMesh()->getCount(elType).getGhostStart();
 }
 CDECL int FTN_NAME(FEM_GET_ELEM_GHOST,fem_get_elem_ghost)(int *elType) {
-       return 1+FEM_Get_Elem_Ghost(*elType-1);
+       return 1+FEM_Get_elem_ghost(*elType-1);
 }
 
-CDECL void FEM_Update_Ghost_Field(int fid, int elemType, void *data)
+CDECL void FEM_Update_ghost_field(int fid, int elemType, void *data)
 {
-       FEMAPI("FEM_Update_Ghost_Field");
+       FEMAPI("FEM_Update_ghost_field");
        getCurChunk()->updateGhost(fid,elemType,data);
 }
 FDECL void FTN_NAME(FEM_UPDATE_GHOST_FIELD,fem_update_ghost_field)
        (int *fid, int *elemType, void *data)
 {
-       FEM_Update_Ghost_Field(*fid,*elemType-1,data);
+       FEM_Update_ghost_field(*fid,*elemType-1,data);
 }
 
 /*********** Mesh modification **********
@@ -1840,9 +1840,9 @@ static void addNode(int localIdx,int nBetween,int *betweenNodes,int idxbase)
        }
 }
 
-CDECL void FEM_Add_Node(int localIdx,int nBetween,int *betweenNodes)
+CDECL void FEM_Add_node(int localIdx,int nBetween,int *betweenNodes)
 {
-       FEMAPI("FEM_Add_Node");
+       FEMAPI("FEM_Add_node");
        addNode(localIdx,nBetween,betweenNodes,0);
 }
 FDECL void FTN_NAME(FEM_ADD_NODE,fem_add_node)
@@ -1914,7 +1914,7 @@ bool FEMchunk::finishListExchange(const FEM_Comm &l)
 }
 
 //List exchange API
-CDECL void FEM_Exchange_Ghost_Lists(int elemType,int nIdx,const int *localIdx)
+CDECL void FEM_Exchange_ghost_lists(int elemType,int nIdx,const int *localIdx)
 {
        FEMAPI("FEM_Exchange_Ghost_Lists");
        getCurChunk()->exchangeGhostLists(elemType,nIdx,localIdx,0);
@@ -1925,18 +1925,18 @@ FDECL void FTN_NAME(FEM_EXCHANGE_GHOST_LISTS,fem_exchange_ghost_lists)
        FEMAPI("FEM_exchange_ghost_lists");
        getCurChunk()->exchangeGhostLists(*elemType-1,*nIdx,localIdx,1);
 }
-CDECL int FEM_Get_Ghost_List_Length(void) 
+CDECL int FEM_Get_ghost_list_length(void) 
 {
        FEMAPI("FEM_Get_Ghost_List_Length");
        return getCurChunk()->getList().size();
 }
 FDECL int FTN_NAME(FEM_GET_GHOST_LIST_LENGTH,fem_get_ghost_list_length)(void)
-{ return FEM_Get_Ghost_List_Length();}
+{ return FEM_Get_ghost_list_length();}
 
-CDECL void FEM_Get_Ghost_List(int *dest)
+CDECL void FEM_Get_ghost_list(int *dest)
 {
        FEMAPI("FEM_Get_Ghost_List");
-       int i,len=FEM_Get_Ghost_List_Length();
+       int i,len=FEM_Get_ghost_list_length();
        const int *src=getCurChunk()->getList().getVec();
        for (i=0;i<len;i++) dest[i]=src[i];
        getCurChunk()->emptyList();
@@ -1945,7 +1945,7 @@ FDECL void FTN_NAME(FEM_GET_GHOST_LIST,fem_get_ghost_list)
        (int *dest)
 {
        FEMAPI("FEM_get_ghost_list");
-       int i,len=FEM_Get_Ghost_List_Length();
+       int i,len=FEM_Get_ghost_list_length();
        const int *src=getCurChunk()->getList().getVec();
        for (i=0;i<len;i++) dest[i]=src[i]+1;
        getCurChunk()->emptyList();
@@ -2249,7 +2249,7 @@ int FEM_Mesh::getGlobalElem(int elType,int elNo) const
        if (elNo<0 || elNo>=elem[elType].size()) {
                CkPrintf("FEM> Element number %d is invalid-- element type %d has only %d elements\n",
                        elNo,elType,elem[elType].size());
-               CkAbort("FEM> Invalid element number, probably passed via FEM_Set_Sparse_Elem");
+               CkAbort("FEM> Invalid element number, probably passed via FEM_Set_Sparse_elem");
        }
 #endif
        return base+elNo;
index 1f450470f73a5a9e54a9388022a53df7f53a889b..a4d65a54574f1e24f5304afe05fef44be081a10c 100644 (file)
@@ -36,90 +36,90 @@ extern "C" {
   void FEM_Attach(int flags);
 
   /*Utility*/
-  int FEM_My_Partition(void);
-  int FEM_Num_Partitions(void);
+  int FEM_My_partition(void);
+  int FEM_Num_partitions(void);
   double FEM_Timer(void);
   void FEM_Done(void);
   void FEM_Print(const char *str);
-  void FEM_Print_Partition(void);
+  void FEM_Print_partition(void);
 
-  int *FEM_Get_Node_Nums(void);
-  int *FEM_Get_Elem_Nums(void);
-  int *FEM_Get_Conn(int elemType);
+  int *FEM_Get_node_nums(void);
+  int *FEM_Get_elem_nums(void);
+  int *FEM_Get_gonn(int elemType);
 
   /*Mesh*/
-  void FEM_Set_Mesh(int nelem, int nnodes, int nodePerElem, int* conn);
+  void FEM_Set_mesh(int nelem, int nnodes, int nodePerElem, int* conn);
   
-  void FEM_Set_Node(int nNodes,int doublePerNode);
-  void FEM_Set_Node_Data(const double *data);
-  void FEM_Set_Elem(int elType,int nElem,int doublePerElem,int nodePerElem);
-  void FEM_Set_Elem_Data(int elType,const double *data);
-  void FEM_Set_Elem_Conn(int elType,const int *conn);
-  void FEM_Set_Sparse(int uniqueIdentifier,int nRecords,
+  void FEM_Set_node(int nNodes,int doublePerNode);
+  void FEM_Set_node_data(const double *data);
+  void FEM_Set_elem(int elType,int nElem,int doublePerElem,int nodePerElem);
+  void FEM_Set_elem_data(int elType,const double *data);
+  void FEM_Set_elem_conn(int elType,const int *conn);
+  void FEM_Set_sparse(int uniqueIdentifier,int nRecords,
        const int *nodes,int nodesPerRec,
        const void *data,int dataPerRec,int dataType);
-  void FEM_Set_Sparse_Elem(int uniqueIdentifier,const int *rec2elem);
-
-  void FEM_Get_Node(int *nNodes,int *doublePerNode);
-  void FEM_Get_Node_Data(double *data);
-  void FEM_Get_Elem(int elType,int *nElem,int *doublePerElem,int *nodePerElem);
-  void FEM_Get_Elem_Data(int elType,double *data);
-  void FEM_Get_Elem_Conn(int elType,int *conn);
-  int  FEM_Get_Sparse_Length(int uniqueIdentifier); //Returns nRecords
-  void FEM_Get_Sparse(int uniqueIdentifier,int *nodes,void *data);
+  void FEM_Set_sparse_elem(int uniqueIdentifier,const int *rec2elem);
+
+  void FEM_Get_node(int *nNodes,int *doublePerNode);
+  void FEM_Get_node_data(double *data);
+  void FEM_Get_elem(int elType,int *nElem,int *doublePerElem,int *nodePerElem);
+  void FEM_Get_elem_data(int elType,double *data);
+  void FEM_Get_elem_conn(int elType,int *conn);
+  int  FEM_Get_sparse_length(int uniqueIdentifier); //Returns nRecords
+  void FEM_Get_sparse(int uniqueIdentifier,int *nodes,void *data);
   
-  void FEM_Add_Linear_Periodicity(int nFaces,int nPer,
+  void FEM_Add_linear_periodicity(int nFaces,int nPer,
        const int *facesA,const int *facesB,
        int nNodes,const double *nodeLocs);
-  void FEM_Sym_Coordinates(int elType,double *d_locs);
+  void FEM_Sym_coordinates(int elType,double *d_locs);
   
-  void FEM_Set_Sym_Nodes(const int *canon,const int *sym);
-  void FEM_Get_Sym(int elTypeOrMinusOne,int *destSym);
+  void FEM_Set_sym_nodes(const int *canon,const int *sym);
+  void FEM_Get_sym(int elTypeOrMinusOne,int *destSym);
   
-  void FEM_Composite_Elem(int newElType);
-  void FEM_Combine_Elem(int srcElType,int destElType,
+  void FEM_Composite_elem(int newElType);
+  void FEM_Combine_elem(int srcElType,int destElType,
        int newInteriorStartIdx,int newGhostStartIdx);
 
-  void FEM_Update_Mesh(int callMeshUpdated,int doRepartition);
+  void FEM_Update_mesh(int callMeshUpdated,int doRepartition);
   
-  void FEM_Set_Partition(int *elem2chunk);
-  void FEM_Serial_Split(int nchunks);
-  void FEM_Serial_Begin(int chunkNo);
+  void FEM_Set_partition(int *elem2chunk);
+  void FEM_Serial_split(int nchunks);
+  void FEM_Serial_begin(int chunkNo);
 
-  void FEM_Add_Ghost_Layer(int nodesPerTuple,int doAddNodes);
-  void FEM_Add_Ghost_Elem(int elType,int tuplesPerElem,const int *elem2tuple);
+  void FEM_Add_ghost_layer(int nodesPerTuple,int doAddNodes);
+  void FEM_Add_ghost_elem(int elType,int tuplesPerElem,const int *elem2tuple);
 
-  int FEM_Get_Node_Ghost(void);
-  int FEM_Get_Elem_Ghost(int elemType);  
+  int FEM_Get_node_ghost(void);
+  int FEM_Get_elem_ghost(int elemType);  
   
-  int FEM_Get_Comm_Partners(void);
-  int FEM_Get_Comm_Partner(int partnerNo);
-  int FEM_Get_Comm_Count(int partnerNo);
-  void FEM_Get_Comm_Nodes(int partnerNo,int *nodeNos);
+  int FEM_Get_comm_partners(void);
+  int FEM_Get_comm_partner(int partnerNo);
+  int FEM_Get_comm_count(int partnerNo);
+  void FEM_Get_comm_nodes(int partnerNo,int *nodeNos);
 
   /*Node update*/
-  int FEM_Create_Simple_Field(int base_type,int vec_len);
-  int FEM_Create_Field(int base_type, int vec_len, int init_offset, 
+  int FEM_Create_simple_field(int base_type,int vec_len);
+  int FEM_Create_field(int base_type, int vec_len, int init_offset, 
                        int distance);
-  void FEM_Update_Field(int fid, void *nodes);
-  void FEM_Update_Ghost_Field(int fid, int elTypeOrMinusOne, void *nodes);
-  void FEM_Reduce_Field(int fid, const void *nodes, void *outbuf, int op);
+  void FEM_Update_field(int fid, void *nodes);
+  void FEM_Update_ghost_field(int fid, int elTypeOrMinusOne, void *nodes);
+  void FEM_Reduce_field(int fid, const void *nodes, void *outbuf, int op);
   void FEM_Reduce(int fid, const void *inbuf, void *outbuf, int op);
-  void FEM_Read_Field(int fid, void *nodes, const char *fname);
+  void FEM_Read_field(int fid, void *nodes, const char *fname);
 
   /*Mesh modification*/
   void FEM_Barrier(void);
 
-  void FEM_Add_Node(int localIdx,int nBetween,int *betweenNodes);  
+  void FEM_Add_node(int localIdx,int nBetween,int *betweenNodes);  
 
-  void FEM_Exchange_Ghost_Lists(int elemType,int nIdx,const int *localIdx);
-  int FEM_Get_Ghost_List_Length(void);
-  void FEM_Get_Ghost_List(int *dest);
+  void FEM_Exchange_ghost_lists(int elemType,int nIdx,const int *localIdx);
+  int FEM_Get_ghost_list_length(void);
+  void FEM_Get_ghost_list(int *dest);
 
   /*Migration */
   int FEM_Register(void *userData,FEM_PupFn _pup_ud);
   void FEM_Migrate(void);
-  void *FEM_Get_Userdata(int n);
+  void *FEM_Get_userdata(int n);
   
   /* to be provided by the application */
   void init(void);
index 73a7d8aa65fe9edb34279ebf918f47f699d51ac6..b0aab938890eec987d1de8e1d2be715035b17a0b 100644 (file)
@@ -390,7 +390,7 @@ void FEM_Sym_Linear::pup(PUP::er &p) {
 }
 
 /********** High-Level (Faces & coordinates) API **********/
-CDECL void FEM_Add_Linear_Periodicity(
+CDECL void FEM_Add_linear_periodicity(
        int nFaces,int nPer,
        const int *facesA,const int *facesB,
        int nNodes,const double *nodeLocs
@@ -411,9 +411,9 @@ FDECL void FTN_NAME(FEM_ADD_LINEAR_PERIODICITY,fem_add_linear_periodicity)(
                facesA,facesB,1,*nNodes,(const CkVector3d *)nodeLocs);
 }
 
-CDECL void FEM_Sym_Coordinates(int elType,double *d_locs)
+CDECL void FEM_Sym_coordinates(int elType,double *d_locs)
 {
-       FEMAPI("FEM_Sym_Coordinates");
+       FEMAPI("FEM_Sym_coordinates");
        
        const FEM_Mesh *m=FEM_Get_FEM_Mesh();
        const FEM_Item &c=m->getCount(elType);
@@ -429,15 +429,15 @@ CDECL void FEM_Sym_Coordinates(int elType,double *d_locs)
 FDECL void FTN_NAME(FEM_SYM_COORDINATES,fem_sym_coordinates)
        (int *elType,double *locs)
 {
-       FEM_Sym_Coordinates(*elType-1,locs);
+       FEM_Sym_coordinates(*elType-1,locs);
 }
 
 
 /********** Low-Level (canonicalization array) API **********/
 
-CDECL void FEM_Set_Sym_Nodes(const int *canon,const int *sym)
+CDECL void FEM_Set_sym_nodes(const int *canon,const int *sym)
 {
-       FEMAPI("FEM_Set_Sym_Nodes");
+       FEMAPI("FEM_Set_sym_nodes");
        int n=FEM_Get_FEM_Mesh()->node.size();
        FEM_Set_FEM_Ghost().setSymmetries(n,CkCopyArray(canon,n,0),sym);
 }
@@ -458,9 +458,9 @@ void FEM_Item::setSymmetries(int r,FEM_Symmetries_t s)
        }
        sym->insert(r,s);
 }
-CDECL void FEM_Get_Sym(int elTypeOrMinusOne,int *destSym)
+CDECL void FEM_Get_sym(int elTypeOrMinusOne,int *destSym)
 {
-       FEMAPI("FEM_Get_Sym");
+       FEMAPI("FEM_Get_sym");
        const FEM_Item &l=FEM_Get_FEM_Mesh()->getCount(elTypeOrMinusOne);
        int n=l.size();
        for (int i=0;i<n;i++) destSym[i]=l.getSymmetries(i);
@@ -468,7 +468,7 @@ CDECL void FEM_Get_Sym(int elTypeOrMinusOne,int *destSym)
 FDECL void FTN_NAME(FEM_GET_SYM,fem_get_sym)
        (int *elTypeOrZero,int *destSym)
 {
-       FEM_Get_Sym(*elTypeOrZero-1,destSym);
+       FEM_Get_sym(*elTypeOrZero-1,destSym);
 }
 
 
index 0e44f0e64532a7c96188e8ad9add25a4666658e5..560695efec243648fa4b4104fc4c4d784e4b3d2c 100644 (file)
@@ -57,7 +57,7 @@ static void callDrivers(void) {
 //Startup routine to use if the user doesn't register one
 static void MBlockFallbackSetup(void)
 {
-       TCharmCreate(TCharmGetNumChunks(),callDrivers);
+       TCHARM_Create(TCHARM_Get_num_chunks(),callDrivers);
         init();
         FTN_NAME(INIT,init)();
         MBLK_Attach();
@@ -67,7 +67,7 @@ static MBlockSetupCookie cookie;
 void MBlockInit(void) 
 {
   CtvInitialize(MBlockChunk *, _mblkptr);
-  TCharmSetFallbackSetup(MBlockFallbackSetup);
+  TCHARM_Set_fallback_setup(MBlockFallbackSetup);
 }
 
 MBlockSetupCookie::MBlockSetupCookie(void)
@@ -546,14 +546,14 @@ MBLK_Set_dim(const int n)
 CDECL int 
 MBLK_Get_nblocks(int *n)
 {
-  *n = TCharmNumElements();
+  *n = TCHARM_Num_elements();
   return MBLK_SUCCESS;
 }
 
 CDECL int 
 MBLK_Get_myblock(int *m)
 {
-  *m = TCharmElement();
+  *m = TCHARM_Element();
   return MBLK_SUCCESS;
 }
 
@@ -575,7 +575,7 @@ MBLK_Get_blocksize(int *dim)
 CDECL double 
 MBLK_Timer(void)
 {
-  return TCharmWallTimer();
+  return TCHARM_Wall_timer();
 }
 
 CDECL void 
@@ -593,14 +593,14 @@ MBLK_Print(const char *str)
 CDECL int 
 MBLK_Register(void *_ud,MBLK_PupFn _pup_ud, int *rid)
 {
-  *rid=TCharmRegister(_ud,_pup_ud);
+  *rid=TCHARM_Register(_ud,_pup_ud);
   return MBLK_SUCCESS;
 }
 
 CDECL int 
 MBLK_Get_registered(int n, void **b)
 {
-  *b=TCharmGetUserdata(n);
+  *b=TCHARM_Get_userdata(n);
   return MBLK_SUCCESS;
 }
 
index 88a8dc4242b6a1d8a4266c4bdef411fdd5687496..3dcafa6702541241f925d6d973c2024a5071ccd5 100644 (file)
@@ -1,3 +1,3 @@
 #include "charm-api.h"
 #include "tcharmc.h"
-CDECL void TCharmUserNodeSetup(void) {}
+CDECL void TCHARM_User_node_setup(void) {}
index 6dde3183cb82f5a124c7bc36104707d0c2d8a22b..ef432f6d48d299ba34ee7da1d26a6dd6aa023f01 100644 (file)
@@ -1,5 +1,5 @@
 #include "charm-api.h"
 #include "tcharmc.h"
-CDECL void TCharmUserSetup(void) {
+CDECL void TCHARM_User_setup(void) {
        TCharmInDefaultSetup();
 }
index 308e5bcd6ea4292342db0aa88d50f39b08812494..09b1071bbd2cbc7a9c38f8f8ab97af063a6dac8a 100644 (file)
@@ -74,12 +74,12 @@ void TCharm::nodeInit(void)
   }
   
   TCharm::setState(inNodeSetup);
-  TCharmUserNodeSetup();
+  TCHARM_User_node_setup();
   FTN_NAME(TCHARM_USER_NODE_SETUP,tcharm_user_node_setup)();
   TCharm::setState(inInit);
 }
 
-void TCharmApiTrace(const char *routineName,const char *libraryName)
+void TCHARM_Api_trace(const char *routineName,const char *libraryName)
 {
        if (!tcharm_tracelibs.isTracing(libraryName)) return;
        TCharm *tc=CtvAccess(_curTCharm);
@@ -301,7 +301,7 @@ static int propMapCreated=0;
 static CkGroupID propMapID;
 CkGroupID CkCreatePropMap(void);
 
-static void TCharmBuildThreads(TCharmInitMsg *msg,TCharmSetupCookie &cook)
+static void TCHARM_Build_threads(TCharmInitMsg *msg,TCharmSetupCookie &cook)
 {
        CkArrayOptions opts(msg->numElements);
        if (!propMapCreated) {
@@ -355,17 +355,17 @@ void TCharmReadonlys::pup(PUP::er &p) {
        pupAllReadonlys(p);
 }
 
-CDECL void TCharmReadonlyGlobals(TCpupReadonlyGlobal fn)
+CDECL void TCHARM_Readonly_globals(TCpupReadonlyGlobal fn)
 {
-       TCHARMAPI("TCharmReadonlyGlobals");
+       TCHARMAPI("TCHARM_Readonly_globals");
        if (TCharm::getState()!=inNodeSetup)
-               CkAbort("Can only call TCharmReadonlyGlobals from in TCharmUserNodeSetup!\n");
+               CkAbort("Can only call TCHARM_ReadonlyGlobals from in TCHARM_UserNodeSetup!\n");
        TCharmReadonlys::add(fn);
 }
 FDECL void FTN_NAME(TCHARM_READONLY_GLOBALS,tcharm_readonly_globals)
        (TCpupReadonlyGlobal fn)
 {
-       TCharmReadonlyGlobals(fn);
+       TCHARM_Readonly_globals(fn);
 }
 
 /************* Startup/Shutdown Coordination Support ************/
@@ -471,8 +471,8 @@ TCharmSetupCookie *TCharmSetupCookie::theCookie;
 
 //Globals used to control setup process
 static int g_numDefaultSetups=0;
-static TCharmFallbackSetupFn g_fallbackSetup=NULL;
-void TCharmSetFallbackSetup(TCharmFallbackSetupFn f)
+static TCHARM_Fallback_setup_fn g_fallbackSetup=NULL;
+void TCHARM_Set_fallback_setup(TCHARM_Fallback_setup_fn f)
 {
        g_fallbackSetup=f;
 }
@@ -494,7 +494,7 @@ public:
     g_numDefaultSetups=0;
     
     /*Call user-overridable C setup*/
-    TCharmUserSetup();
+    TCHARM_User_setup();
     /*Call user-overridable Fortran setup*/
     FTN_NAME(TCHARM_USER_SETUP,tcharm_user_setup)();
     
@@ -541,7 +541,7 @@ TCharmSetupCookie::TCharmSetupCookie(char **argv_)
        stackSize=tcharm_stacksize;
 }
 
-CkArrayOptions TCharmAttachStart(CkArrayID *retTCharmArray,int *retNumElts)
+CkArrayOptions TCHARM_Attach_start(CkArrayID *retTCharmArray,int *retNumElts)
 {
        TCharmSetupCookie *tc=TCharmSetupCookie::get();
        if (!tc->hasThreads())
@@ -553,7 +553,7 @@ CkArrayOptions TCharmAttachStart(CkArrayID *retTCharmArray,int *retNumElts)
        opts.bindTo(tc->getThreads());
        return opts;
 }
-void TCharmAttachFinish(const CkArrayID &libraryArray)
+void TCHARM_Attach_finish(const CkArrayID &libraryArray)
 {
        TCharmSetupCookie *tc=TCharmSetupCookie::get();
        tc->addClient(libraryArray);
@@ -569,37 +569,37 @@ Callable from UserSetup:
 */
 
 /*Set the size of the thread stack*/
-CDECL void TCharmSetStackSize(int newStackSize)
+CDECL void TCHARM_Set_stack_size(int newStackSize)
 {
-       TCHARMAPI("TCharmSetStackSize");
+       TCHARMAPI("TCHARM_Set_stack_size");
        if (TCharm::getState()!=inInit)
                CkAbort("TCharm> Can only set stack size from in init!\n");
        cookie.setStackSize(newStackSize);
 }
 FDECL void FTN_NAME(TCHARM_SET_STACK_SIZE,tcharm_set_stack_size)
        (int *newSize)
-{ TCharmSetStackSize(*newSize); }
+{ TCHARM_Set_stack_size(*newSize); }
 
 
 /*Create a new array of threads, which will be bound to by subsequent libraries*/
-CDECL void TCharmCreate(int nThreads,
-                       TCharmThreadStartFn threadFn)
+CDECL void TCHARM_Create(int nThreads,
+                       TCHARM_Thread_start_fn threadFn)
 {
-       TCHARMAPI("TCharmCreate");
-       TCharmCreateData(nThreads,
-                        (TCharmThreadDataStartFn)threadFn,NULL,0);
+       TCHARMAPI("TCHARM_Create");
+       TCHARM_Create_data(nThreads,
+                        (TCHARM_Thread_data_start_fn)threadFn,NULL,0);
 }
 FDECL void FTN_NAME(TCHARM_CREATE,tcharm_create)
-       (int *nThreads,TCharmThreadStartFn threadFn)
-{ TCharmCreate(*nThreads,threadFn); }
+       (int *nThreads,TCHARM_Thread_start_fn threadFn)
+{ TCHARM_Create(*nThreads,threadFn); }
 
 
 /*As above, but pass along (arbitrary) data to threads*/
-CDECL void TCharmCreateData(int nThreads,
-                 TCharmThreadDataStartFn threadFn,
+CDECL void TCHARM_Create_data(int nThreads,
+                 TCHARM_Thread_data_start_fn threadFn,
                  void *threadData,int threadDataLen)
 {
-       TCHARMAPI("TCharmCreateData");
+       TCHARMAPI("TCHARM_Create_data");
        if (TCharm::getState()!=inInit)
                CkAbort("TCharm> Can only create threads from in init!\n");
        TCharmSetupCookie &cook=cookie;
@@ -607,20 +607,20 @@ CDECL void TCharmCreateData(int nThreads,
                (CthVoidFn)threadFn,cook.getStackSize());
        msg->numElements=nThreads;
        memcpy(msg->data,threadData,threadDataLen);
-       TCharmBuildThreads(msg,cook);
+       TCHARM_Build_threads(msg,cook);
 }
 
 FDECL void FTN_NAME(TCHARM_CREATE_DATA,tcharm_create_data)
        (int *nThreads,
-                 TCharmThreadDataStartFn threadFn,
+                 TCHARM_Thread_data_start_fn threadFn,
                  void *threadData,int *threadDataLen)
-{ TCharmCreateData(*nThreads,threadFn,threadData,*threadDataLen); }
+{ TCHARM_Create_data(*nThreads,threadFn,threadData,*threadDataLen); }
 
 
-CDECL int TCharmGetNumChunks(void)
+CDECL int TCHARM_Get_num_chunks(void)
 {
-       TCHARMAPI("TCharmGetNumChunks");
-       if (CkMyPe()!=0) CkAbort("TCharmGetNumChunks should only be called on PE 0 during setup!");
+       TCHARMAPI("TCHARM_Get_num_chunks");
+       if (CkMyPe()!=0) CkAbort("TCHARM_Get_num_chunks should only be called on PE 0 during setup!");
        int nChunks=CkNumPes();
        char **argv=CkGetArgv();
        CmiGetArgInt(argv,"-vp",&nChunks);
@@ -630,21 +630,21 @@ CDECL int TCharmGetNumChunks(void)
 }
 FDECL int FTN_NAME(TCHARM_GET_NUM_CHUNKS,tcharm_get_num_chunks)(void)
 {
-       return TCharmGetNumChunks();
+       return TCHARM_Get_num_chunks();
 }
 
 
 /***********************************
 Callable from worker thread
 */
-CDECL int TCharmElement(void)
+CDECL int TCHARM_Element(void)
 { 
-       TCHARMAPI("TCharmElement");
+       TCHARMAPI("TCHARM_Element");
        return TCharm::get()->getElement();
 }
-CDECL int TCharmNumElements(void)
+CDECL int TCHARM_Num_elements(void)
 { 
-       TCHARMAPI("TCharmNumElements");
+       TCHARMAPI("TCHARM_Num_elements");
        if (TCharm::getState()==inDriver)
                return TCharm::get()->getNumElements();
        else
@@ -652,9 +652,9 @@ CDECL int TCharmNumElements(void)
 }
 
 FDECL int FTN_NAME(TCHARM_ELEMENT,tcharm_element)(void) 
-{ return TCharmElement();}
+{ return TCHARM_Element();}
 FDECL int FTN_NAME(TCHARM_NUM_ELEMENTS,tcharm_num_elements)(void) 
-{ return TCharmNumElements();}
+{ return TCHARM_Num_elements();}
 
 //Make sure this address will migrate with us when we move:
 static void checkAddress(void *data)
@@ -664,32 +664,32 @@ static void checkAddress(void *data)
            CkAbort("The UserData you register must be allocated on the stack!\n");
 }
 
-CDECL int TCharmRegister(void *data,TCharmPupFn pfn)
+CDECL int TCHARM_Register(void *data,TCHARM_Pup_fn pfn)
 { 
-       TCHARMAPI("TCharmRegister");
+       TCHARMAPI("TCHARM_Register");
        checkAddress(data);
        return TCharm::get()->add(TCharm::UserData(pfn,data));
 }
 FDECL int FTN_NAME(TCHARM_REGISTER,tcharm_register)
        (void *data,TCpupUserDataF pfn)
 { 
-       TCHARMAPI("TCharm_Register");
+       TCHARMAPI("TCHARM_Register");
        checkAddress(data);
        return TCharm::get()->add(TCharm::UserData(
                pfn,data,TCharm::UserData::isFortran()));
 }
 
-CDECL void *TCharmGetUserdata(int id)
+CDECL void *TCHARM_Get_userdata(int id)
 {
-       TCHARMAPI("TCharmGetUserdata");
+       TCHARMAPI("TCHARM_Get_userdata");
        return TCharm::get()->lookupUserData(id);
 }
 FDECL void *FTN_NAME(TCHARM_GET_USERDATA,tcharm_get_userdata)(int *id)
-{ return TCharmGetUserdata(*id); }
+{ return TCHARM_Get_userdata(*id); }
 
-CDECL void TCharmSetGlobal(int globalID,void *new_value,TCharmPupGlobalFn pup_or_NULL)
+CDECL void TCHARM_Set_global(int globalID,void *new_value,TCHARM_Pup_global_fn pup_or_NULL)
 {
-       TCHARMAPI("TCharmSetGlobal");
+       TCHARMAPI("TCHARM_Set_global");
        TCharm *tc=TCharm::get();
        if (tc->sud.length()<=globalID) 
        { //We don't have room for this ID yet: make room
@@ -697,52 +697,52 @@ CDECL void TCharmSetGlobal(int globalID,void *new_value,TCharmPupGlobalFn pup_or
                tc->sud.setSize(newLen);
                tc->sud.length()=newLen;
        }
-       tc->sud[globalID]=TCharm::UserData((TCharmPupFn) pup_or_NULL,new_value);
+       tc->sud[globalID]=TCharm::UserData((TCHARM_Pup_fn) pup_or_NULL,new_value);
 }
-CDECL void *TCharmGetGlobal(int globalID)
+CDECL void *TCHARM_Get_global(int globalID)
 {
-       //Skip TCHARMAPI("TCharmGetGlobal") because there's no dynamic allocation here,
+       //Skip TCHARMAPI("TCHARM_Get_global") because there's no dynamic allocation here,
        // and this routine should be as fast as possible.
        CkVec<TCharm::UserData> &v=TCharm::get()->sud;
        if (v.length()<=globalID) return NULL; //Uninitialized global
        return v[globalID].getData();
 }
 
-CDECL void TCharmMigrate(void)
+CDECL void TCHARM_Migrate(void)
 {
-       TCHARMAPI("TCharmMigrate");
+       TCHARMAPI("TCHARM_Migrate");
        TCharm::get()->migrate();
 }
 FDECL void FTN_NAME(TCHARM_MIGRATE,tcharm_migrate)(void)
 {
-       TCHARMAPI("TCharmMigrate");
+       TCHARMAPI("TCHARM_Migrate");
        TCharm::get()->migrate();
 }
 
-CDECL void TCharmBarrier(void)
+CDECL void TCHARM_Barrier(void)
 {
-       TCHARMAPI("TCharmBarrier");
+       TCHARMAPI("TCHARM_Barrier");
        TCharm::get()->barrier();
 }
 FDECL void FTN_NAME(TCHARM_BARRIER,tcharm_barrier)(void)
 {
-       TCharmBarrier();
+       TCHARM_Barrier();
 }
 
-CDECL void TCharmDone(void)
+CDECL void TCHARM_Done(void)
 {
-       TCHARMAPI("TCharmDone");
+       TCHARMAPI("TCHARM_Done");
        if (TCharm::getState()!=inDriver) CkExit();
        else TCharm::get()->done();
 }
 FDECL void FTN_NAME(TCHARM_DONE,tcharm_done)(void)
 {
-       TCharmDone();
+       TCHARM_Done();
 }
 
-CDECL double TCharmWallTimer(void) 
+CDECL double TCHARM_Wall_timer(void) 
 {
-  TCHARMAPI("TCharmWallTimer");
+  TCHARMAPI("TCHARM_Wall_timer");
   if(TCharm::getState()!=inDriver) return CkWallTimer();
   else { //Have to apply current thread's time offset
     return CkWallTimer()+TCharm::get()->getTimeOffset();
@@ -774,7 +774,7 @@ FDECL void FTN_NAME(TCHARM_GETARG,tcharm_getarg)
 
 //These silly routines are used for serial startup:
 extern void _initCharm(int argc, char **argv);
-CDECL void TCharmInit(int *argc,char ***argv) {
+CDECL void TCHARM_Init(int *argc,char ***argv) {
        ConverseInit(*argc, *argv, (CmiStartFn) _initCharm,1,1);
        _initCharm(*argc,*argv);
 }
index f2f2f6b568b74e1e48a068218c41424cb06df1a3..ddbd7bfbc1c2d3068491f97545e40fdbb3a7eaf2 100644 (file)
@@ -14,18 +14,18 @@ Orion Sky Lawlor, olawlor@acm.org, 7/17/2002
 /*
 Library "fallback setup" routine.
 From an initcall, you register one of your routines 
-here in case the user doesn't write a TCharmUserSetup
+here in case the user doesn't write a TCHARM_User_setup
 routine.  Your fallback version sets up (only) your 
 library by creating some TCharm threads and attaching to them,
 like:
 
 void myLibFallbackSetupFn(void) {
-       TCharmCreate(TCharmGetNumChunks(),myLibUserStart);
+       TCHARM_Create(TCHARM_Get_num_chunks(),myLibUserStart);
         myLib_Attach();
 }
 */
-typedef void (*TCharmFallbackSetupFn)(void);
-void TCharmSetFallbackSetup(TCharmFallbackSetupFn f);
+typedef void (*TCHARM_Fallback_setup_fn)(void);
+void TCHARM_Set_fallback_setup(TCHARM_Fallback_setup_fn f);
 
 
 /*
@@ -37,8 +37,8 @@ object to your array's ckNew.
 The "finish" call registers your newly-created array as a
 client of this set of TCharm threads.
 */
-CkArrayOptions TCharmAttachStart(CkArrayID *retTCharmArray,int *retNumElts=0);
-void TCharmAttachFinish(const CkArrayID &libraryArray);
+CkArrayOptions TCHARM_Attach_start(CkArrayID *retTCharmArray,int *retNumElts=0);
+void TCHARM_Attach_finish(const CkArrayID &libraryArray);
 
 
 /*
@@ -98,12 +98,12 @@ tracing (once tracing is generalized).
 #ifndef CMK_OPTIMIZE
 #  define TCHARM_API_TRACE(routineName,libraryName) \
        TCharmAPIRoutine apiRoutineSentry;\
-       TCharmApiTrace(routineName,libraryName)
+       TCHARM_Api_trace(routineName,libraryName)
 #else
 #  define TCHARM_API_TRACE(routineName,libraryName) \
        TCharmAPIRoutine apiRoutineSentry
 #endif
-void TCharmApiTrace(const char *routineName,const char *libraryName);
+void TCHARM_Api_trace(const char *routineName,const char *libraryName);
 
 
 #endif /*def(thisHeader)*/
index ce21fbe88c54748dd3c85d333050a9135b521efb..b7969b814cc295f6737dd4b42051f73010d2a50f 100644 (file)
@@ -1,5 +1,5 @@
 /*
-User-callable C API for TCharm library
+User-callable C API for TCHARM library
 Orion Sky Lawlor, olawlor@acm.org, 11/20/2001
 */
 #ifndef __TCHARM_H
@@ -13,8 +13,8 @@ extern "C" {
 
 
 /*User callbacks: you define these functions*/
-void TCharmUserNodeSetup(void);
-void TCharmUserSetup(void);
+void TCHARM_User_node_setup(void);
+void TCHARM_User_setup(void);
 
 
 /**** Routines you can call from UserNodeSetup: ****/
@@ -22,55 +22,55 @@ void TCharmUserSetup(void);
 /*Register readonly global variables-- these will be broadcast
 after init and available in driver.*/
 typedef void (*TCpupReadonlyGlobal)(pup_er p);
-void TCharmReadonlyGlobals(TCpupReadonlyGlobal fn);
+void TCHARM_Readonly_globals(TCpupReadonlyGlobal fn);
 
 /**** Routines you can call from UserSetup: ****/
 
 /*Set the size of the thread stack*/
-void TCharmSetStackSize(int newStackSize);
+void TCHARM_Set_stack_size(int newStackSize);
 
 /*Create a new array of threads, which will be bound to by subsequent libraries*/
-typedef void (*TCharmThreadStartFn)(void);
-void TCharmCreate(int nThreads,TCharmThreadStartFn threadFn);
+typedef void (*TCHARM_Thread_start_fn)(void);
+void TCHARM_Create(int nThreads,TCHARM_Thread_start_fn threadFn);
 
 /*As above, but pass along (arbitrary) data to thread*/
-typedef void (*TCharmThreadDataStartFn)(void *threadData);
-void TCharmCreateData(int nThreads,TCharmThreadDataStartFn threadFn,
+typedef void (*TCHARM_Thread_data_start_fn)(void *threadData);
+void TCHARM_Create_data(int nThreads,TCHARM_Thread_data_start_fn threadFn,
                  void *threadData,int threadDataLen);
 
 /*Get the number of chunks we expect based on the command line*/
-int TCharmGetNumChunks(void);
+int TCHARM_Get_num_chunks(void);
 
 
 /**** Routines you can call from the thread (driver) ****/
-int TCharmElement(void);
-int TCharmNumElements(void);
-void TCharmBarrier(void);
-void TCharmMigrate(void);
-void TCharmDone(void);
+int TCHARM_Element(void);
+int TCHARM_Num_elements(void);
+void TCHARM_Barrier(void);
+void TCHARM_Migrate(void);
+void TCHARM_Done(void);
 
 /* Set/get thread-private ("thread global") data. */
-typedef void (*TCharmPupFn)(pup_er p,void *data);
-int TCharmRegister(void *data,TCharmPupFn pfn);
-void *TCharmGetUserdata(int id);
+typedef void (*TCHARM_Pup_fn)(pup_er p,void *data);
+int TCHARM_Register(void *data,TCHARM_Pup_fn pfn);
+void *TCHARM_Get_userdata(int id);
 
 /* Alternate API for Set/get thread-private ("thread global") data. */
-typedef void (*TCharmPupGlobalFn)(pup_er p);
-void TCharmSetGlobal(int globalID,void *new_value,TCharmPupGlobalFn pup_or_NULL);
-void *TCharmGetGlobal(int globalID);
+typedef void (*TCHARM_Pup_global_fn)(pup_er p);
+void TCHARM_Set_global(int globalID,void *new_value,TCHARM_Pup_global_fn pup_or_NULL);
+void *TCHARM_Get_global(int globalID);
 
 
 /*Get the local wall clock.  Unlike CkWalltimer, is
   monotonically increasing, even with migration and 
   unsynchronized clocks. */
-double TCharmWallTimer(void);
+double TCHARM_Wall_timer(void);
 
 
 /*Standalone startup routine*/
-void TCharmInit(int *argc,char ***argv);
+void TCHARM_Init(int *argc,char ***argv);
 
 /*Internal library routine*/
-void TCharmInUserSetup(void);
+void TCHARM_In_user_setup(void);
 
 #ifdef __cplusplus
 };
index f319658d33803f6708755bef7d1d7608c3920b97..d27b7c88cb6b40655afa4976470ab486b9a62d31 100644 (file)
@@ -1,19 +1,19 @@
-       external tcharm_set_stack_size
-       external tcharm_create
-       external tcharm_create_data
+       external TCHARM_Set_stack_size
+       external TCHARM_Create
+       external TCHARM_Create_data
        
-       integer, external :: tcharm_get_num_chunks
-       integer, external :: tcharm_element
-       integer, external :: tcharm_num_elements
+       integer, external :: TCHARM_Get_num_chunks
+       integer, external :: TCHARM_Element
+       integer, external :: TCHARM_Num_elements
        
-       external tcharm_barrier
+       external TCHARM_Barrier
 
-       external tcharm_register
-       external tcharm_migrate
-       external tcharm_done
+       external TCHARM_Register
+       external TCHARM_Migrate
+       external TCHARM_Done
 
-       external tcharm_readonly_globals
-       external tcharm_init
+       external TCHARM_Readonly_globals
+       external TCHARM_Init
 
-       integer, external :: tcharm_iargc
-       external tcharm_getarg
+       integer, external :: TCHARM_Iargc
+       external TCHARM_Getarg
index b8bd6f42ef5806a0c789412b1d5a20e2218a3968..8797dd4250a5acf72c471ccb208092905ca3fb07 100644 (file)
@@ -14,8 +14,8 @@ include 'femf.h'
     read(20,*) (conn(i,j),j=1,esize)
   enddo
   close(20)
-  call FEM_Set_Elem(1,nelems,0,esize)
-  call FEM_Set_Elem_Conn_c(1,conn)
+  call FEM_Set_elem(1,nelems,0,esize)
+  call FEM_Set_elem_conn_c(1,conn)
   
   allocate(nodeData(nnodes,2))
   do i=1,nnodes
@@ -27,8 +27,8 @@ include 'femf.h'
   nodeData(2,2)=0.25
   nodeData(4,2)=0.25
   nodeData(5,2)=0.25
-  call FEM_Set_Node(nnodes,2)
-  call FEM_Set_Node_Data_c(nodeData)
+  call FEM_Set_node(nnodes,2)
+  call FEM_Set_node_data_c(nodeData)
 end subroutine init
 
 subroutine driver()
@@ -45,25 +45,25 @@ include 'femf.h'
   double precision, dimension(:), allocatable:: elements
 
 
-  call FEM_Get_Elem(1,nelems,elemData,npere)
-  call FEM_Get_Node(nnodes,nodeDataP)
+  call FEM_Get_elem(1,nelems,elemData,npere)
+  call FEM_Get_node(nnodes,nodeDataP)
 
   allocate(conn(nelems, npere))
-  call FEM_Get_Elem_Conn_c(1,conn)
+  call FEM_Get_elem_conn_c(1,conn)
   allocate(nodeData(nnodes,nodeDataP))
-  call FEM_Get_Node_Data_c(nodeData);
+  call FEM_Get_node_data_c(nodeData);
 
   allocate(nodes(nnodes))
   allocate(elements(nelems))
 
-  call FEM_Print_Partition()
+  call FEM_Print_partition()
 
   nodes = 0.0
   elements = 0.0
   do i=1,nnodes
      nodes(i)=nodeData(i,1)
   enddo
-  fid = FEM_Create_Field(FEM_DOUBLE, 1, 0, 8)
+  fid = FEM_Create_field(FEM_DOUBLE, 1, 0, 8)
   do i=1,nelems
     do j=1,npere
       elements(i) = elements(i) + nodes(conn(i,j))
@@ -76,7 +76,7 @@ include 'femf.h'
       nodes(conn(i,j)) = nodes(conn(i,j)) + elements(i)
     enddo
   enddo
-  call FEM_Update_Field(fid, nodes(1))
+  call FEM_Update_field(fid, nodes(1))
   failed = .FALSE.
   do i=1,nnodes
     if (nodes(i) .ne. nodeData(i,2)) failed= .TRUE.
@@ -87,7 +87,7 @@ include 'femf.h'
     call FEM_Print('update_field test passed.')
   endif
   sum = 0.0
-  call FEM_Reduce_Field(fid, nodes(1), sum, FEM_SUM)
+  call FEM_Reduce_field(fid, nodes(1), sum, FEM_SUM)
   if (sum .eq. 1.0) then
     call FEM_Print('reduce_field test passed.')
   else
@@ -95,7 +95,7 @@ include 'femf.h'
   endif
   sum = 1.0
   call FEM_Reduce(fid, sum, sum, FEM_SUM)
-  if (sum .eq. FEM_Num_Partitions()) then
+  if (sum .eq. FEM_Num_partitions()) then
     call FEM_Print('reduce test passed.')
   else
     call FEM_Print('reduce test failed.')
index e2c470660394c415b89642b6f59b91f05602cc0f..7683f887caa829d9eb730a4b5024a1f2d2aa4336 100644 (file)
@@ -29,9 +29,9 @@ pupMyGlobals(pup_er p)
 }
 
 extern "C" void
-TCharmUserNodeSetup(void)
+TCHARM_User_node_setup(void)
 {
-       TCharmReadonlyGlobals(pupMyGlobals);
+       TCHARM_Readonly_globals(pupMyGlobals);
 }
 
 void printargs(void) {
@@ -58,8 +58,8 @@ init(void)
   for (int e=0;e<nelems;e++) elements[e]=0.3;
 
   //Describe the nodes and elements
-  FEM_Set_Node(nnodes,tsteps);
-  FEM_Set_Elem(0,nelems,1,np);
+  FEM_Set_node(nnodes,tsteps);
+  FEM_Set_elem(0,nelems,1,np);
 
   //Create the connectivity array
   for(int y=0;y<dim;y++) for (int x=0;x<dim;x++) {
@@ -89,8 +89,8 @@ init(void)
       data[3*y+0]=data[3*y+1]=val;
       data[3*y+2]=10.0;
     }
-    FEM_Set_Sparse(sparseNo,nSparse, nodes,2, data,3,FEM_DOUBLE);
-    FEM_Set_Sparse_Elem(sparseNo,elems);
+    FEM_Set_sparse(sparseNo,nSparse, nodes,2, data,3,FEM_DOUBLE);
+    FEM_Set_sparse_elem(sparseNo,elems);
     delete[] nodes;
     delete[] elems;
     delete[] data;
@@ -99,8 +99,8 @@ init(void)
   //Set the initial conditions
   elements[3*dim+1]=256;
   elements[2*dim+1]=256;
-  FEM_Set_Elem_Data(0,elements);
-  FEM_Set_Elem_Conn(0,conn);
+  FEM_Set_elem_data(0,elements);
+  FEM_Set_elem_conn(0,conn);
 
   //Run the time loop over our serial mesh--
   // we'll use this data to check the parallel calculation.
@@ -131,28 +131,28 @@ init(void)
        for (i=0;i<nnodes;i++) reduceSum+=nodes[i];
        reduceValues[t]=reduceSum;
   }
-  FEM_Set_Node_Data(noData);
+  FEM_Set_node_data(noData);
 
 //Set up ghost layers:
   if (0) 
   { /*Match across single nodes*/
      static const int quad2node[]={0,1,2,3};
-     FEM_Add_Ghost_Layer(1,1);
-     FEM_Add_Ghost_Elem(0,4,quad2node);
+     FEM_Add_ghost_layer(1,1);
+     FEM_Add_ghost_elem(0,4,quad2node);
   } else if (1) 
   { /*Match edges*/
 #if 1 /*Include ignored "-1" nodes as a test*/
      static const int quad2edge[]= {0,1,-1,  1,2,-1,  2,3,-1,  3,0,-1};
-     FEM_Add_Ghost_Layer(3,1);
-     FEM_Add_Ghost_Elem(0,4,quad2edge);
+     FEM_Add_ghost_layer(3,1);
+     FEM_Add_ghost_elem(0,4,quad2edge);
 #else
      static const int quad2edge[]= {0,1,  1,2,  2,3,  3,0};
-     FEM_Add_Ghost_Layer(2,1);
-     FEM_Add_Ghost_Elem(0,4,quad2edge);
+     FEM_Add_ghost_layer(2,1);
+     FEM_Add_ghost_elem(0,4,quad2edge);
 #endif
 /*Add a second layer
-     FEM_Add_Ghost_Layer(2,0);
-     FEM_Add_Ghost_Elem(0,4,quad2edge);
+     FEM_Add_ghost_layer(2,0);
+     FEM_Add_ghost_elem(0,4,quad2edge);
 */
   }
   delete[] conn;
@@ -163,12 +163,12 @@ init(void)
 #if 0 //Test out the serial split routines
   int nchunks=10;
   printf("Splitting into %d pieces:\n");
-  FEM_Serial_Split(nchunks);
+  FEM_Serial_split(nchunks);
   for (int i=0;i<nchunks;i++) {
-    FEM_Serial_Begin(i);
+    FEM_Serial_begin(i);
     int node,elem,ignored;
-    FEM_Get_Node(&node,&ignored);
-    FEM_Get_Elem(0,&elem,&ignored,&ignored);
+    FEM_Get_node(&node,&ignored);
+    FEM_Get_elem(0,&elem,&ignored,&ignored);
     printf(" partition[%d] has %d nodes, %d elems\n",i,node,elem);
   }
   FEM_Done();
@@ -187,18 +187,18 @@ typedef struct _element {
 
 void testEqual(double is,double shouldBe,const char *what) {
        if (fabs(is-shouldBe)<0.000001) {
-               //CkPrintf("[chunk %d] %s test passed.\n",FEM_My_Partition(),what);
+               //CkPrintf("[chunk %d] %s test passed.\n",FEM_My_partition(),what);
        } 
        else {/*test failed*/
                CkPrintf("[chunk %d] %s test FAILED-- expected %f, got %f (pe %d)\n",
-                        FEM_My_Partition(),what,shouldBe,is,CkMyPe());
+                        FEM_My_partition(),what,shouldBe,is,CkMyPe());
                CkAbort("FEM Test failed\n");
        }
 }
 
 void testAssert(int shouldBe,const char *what,int myPartition=-1) 
 {
-       if (myPartition==-1) myPartition=FEM_My_Partition();
+       if (myPartition==-1) myPartition=FEM_My_partition();
        if (shouldBe) {
                // CkPrintf("[chunk %d] %s test passed.\n",myPartition,what);
        }
@@ -219,30 +219,30 @@ driver(void)
 
   FEM_Print("Starting driver...");
 printargs();
-  FEM_Get_Node(&nnodes,&nnodeData);
+  FEM_Get_node(&nnodes,&nnodeData);
   double *nodeData=new double[nnodeData*nnodes];
-  FEM_Get_Node_Data(nodeData);  
+  FEM_Get_node_data(nodeData);  
 
-  FEM_Get_Elem(0,&nelems,&nelemData,&np);
+  FEM_Get_elem(0,&nelems,&nelemData,&np);
   int *conn=new int[np*nelems];
-  FEM_Get_Elem_Conn(0,conn);
+  FEM_Get_elem_conn(0,conn);
   double *elData=new double[nelemData*nelems];
-  FEM_Get_Elem_Data(0,elData);
+  FEM_Get_elem_data(0,elData);
 
-  int myId = FEM_My_Partition();
-  //FEM_Print_Partition();
+  int myId = FEM_My_partition();
+  //FEM_Print_partition();
   Node *nodes = new Node[nnodes];
   Element *elements = new Element[nelems];
-  int doubleField=FEM_Create_Simple_Field(FEM_DOUBLE,1);
-  int fid = FEM_Create_Field(FEM_DOUBLE, 1, 
+  int doubleField=FEM_Create_simple_field(FEM_DOUBLE,1);
+  int fid = FEM_Create_field(FEM_DOUBLE, 1, 
        (char *)(&nodes[0].val)-(char *)nodes, sizeof(Node));
-  int efid = FEM_Create_Field(FEM_DOUBLE, 1, 
+  int efid = FEM_Create_field(FEM_DOUBLE, 1, 
        (char *)(&elements[0].val)-(char *)elements, sizeof(Element));
   
 //Test out reduction
   double localSum = 1.0,globalSum;
   FEM_Reduce(fid, &localSum, &globalSum, FEM_SUM);
-  testEqual(globalSum,(double)FEM_Num_Partitions(),"reduce");
+  testEqual(globalSum,(double)FEM_Num_partitions(),"reduce");
   
 //Test readonly global
   testEqual(tsteps,nnodeData,"readonly");
@@ -252,11 +252,11 @@ printargs();
 
 //Grab and check the sparse data:
   for (int sparseNo=0;sparseNo<2;sparseNo++) {
-    int nSparse=FEM_Get_Sparse_Length(sparseNo);
+    int nSparse=FEM_Get_sparse_length(sparseNo);
     //CkPrintf("FEM Chunk %d has %d sparse entries (pass %d)\n",myId,nSparse,sparseNo);
     int *nodes=new int[2*nSparse];
     double *data=new double[3*nSparse];
-    FEM_Get_Sparse(sparseNo,nodes,data);
+    FEM_Get_sparse(sparseNo,nodes,data);
     double sum=0.0;
     for (int y=0;y<nSparse;y++) {
       testAssert(nodes[2*y]>=0 && nodes[2*y]<nnodes,"Sparse nodes");
@@ -283,12 +283,12 @@ printargs();
 
 //Clip off ghost nodes/elements
   ngnodes=nnodes; ngelems=nelems;
-  nnodes=FEM_Get_Node_Ghost();
-  nelems=FEM_Get_Elem_Ghost(0);
+  nnodes=FEM_Get_node_ghost();
+  nelems=FEM_Get_elem_ghost(0);
 
 //Update ghost field test
   for (i=nelems;i<ngelems;i++) {elements[i].val=-1.0;}
-  FEM_Update_Ghost_Field(efid,0,elements);
+  FEM_Update_ghost_field(efid,0,elements);
   for (i=0;i<ngelems;i++)
          testEqual(elements[i].pad,123,"update element ghost field pad");
   for (i=0;i<ngelems;i++)
@@ -306,7 +306,7 @@ printargs();
         nodes[conn[i*np+j]].val += elements[i].val/np;
 
        //Update shared nodes
-    FEM_Update_Field(fid, nodes);
+    FEM_Update_field(fid, nodes);
 
        //Elements are average of surrounding nodes
     for(i=0;i<nelems;i++) {
@@ -321,25 +321,25 @@ printargs();
         testEqual(nodes[i].val,nodeData[nnodeData*i+t], "update_field");
 
     double sum = 0.0;
-    FEM_Reduce_Field(fid, nodes, &sum, FEM_SUM);
+    FEM_Reduce_field(fid, nodes, &sum, FEM_SUM);
     testEqual(sum,reduceValues[t],"reduce_field");
 
     //Communicate our ghost elements:
     for (i=nelems;i<ngelems;i++) elements[i].val=-1;
-    FEM_Update_Ghost_Field(efid,0,elements);
+    FEM_Update_ghost_field(efid,0,elements);
     for (i=nelems;i<ngelems;i++) {
       testAssert(elements[i].val!=-1,"update_ghost_field");
     }
 
     //Communicate our ghost nodes:
-    FEM_Update_Ghost_Field(fid,-1,nodes);
+    FEM_Update_ghost_field(fid,-1,nodes);
     for(i=nnodes;i<ngnodes;i++)
         testEqual(nodes[i].val,nodeData[nnodeData*i+t],
           "update_ghost_node_field");
 
 
     //Make a list of elements with odd global numbers
-    const int *elGnum=FEM_Get_Elem_Nums();
+    const int *elGnum=FEM_Get_elem_nums();
     int elListLen=0;
     double thresh=2.0;
     for (i=0;i<nelems;i++) 
@@ -349,9 +349,9 @@ printargs();
            }
 
     //Get a list of ghost elements with odd global numbers
-    FEM_Exchange_Ghost_Lists(0,elListLen,elList);
-    elListLen=FEM_Get_Ghost_List_Length();
-    FEM_Get_Ghost_List(elList);
+    FEM_Exchange_ghost_lists(0,elListLen,elList);
+    elListLen=FEM_Get_ghost_list_length();
+    FEM_Get_ghost_list(elList);
     //CkPrintf("[%d] My ghost list has %d entries\n",myId,elListLen);
     //Make sure everything on the list are actually ghosts and
     // actually have large values
@@ -371,23 +371,23 @@ printargs();
 
 #if 1
 /*Try reassembling the mesh*/
-    const int *noGnum=FEM_Get_Node_Nums();
+    const int *noGnum=FEM_Get_node_nums();
     double *nodeOut=new double[nnodes];
-    FEM_Set_Node(nnodes,1);
+    FEM_Set_node(nnodes,1);
     for (i=0;i<nnodes;i++) {
        nodeOut[i]=0.1*noGnum[i];
     }
-    FEM_Set_Node_Data(nodeOut);
+    FEM_Set_node_data(nodeOut);
     delete[] nodeOut;
-    const int *elGnum=FEM_Get_Elem_Nums();
+    const int *elGnum=FEM_Get_elem_nums();
     double *elOut=new double[nelems];
-    FEM_Set_Elem(0,nelems,1,0);
+    FEM_Set_elem(0,nelems,1,0);
     for (i=0;i<nelems;i++) {
        elOut[i]=0.1*elGnum[i];
     }
-    FEM_Set_Elem_Data(0,elOut);
+    FEM_Set_elem_data(0,elOut);
     delete[] elOut;
-    FEM_Update_Mesh(123,2);
+    FEM_Update_mesh(123,2);
 #endif
 
   FEM_Print("All tests passed.");
@@ -400,19 +400,19 @@ mesh_updated(int param)
   CkPrintf("mesh_updated(%d) called.\n",param);
   testEqual(param,123,"mesh_updated param");
   
-  FEM_Get_Node(&nnodes,&dataPer);
+  FEM_Get_node(&nnodes,&dataPer);
   CkPrintf("Getting %d nodes (%d data per)\n",nnodes,dataPer);
   double *ndata=new double[nnodes*dataPer];
-  FEM_Get_Node_Data(ndata);
+  FEM_Get_node_data(ndata);
   for (i=0;i<nnodes;i++) {
     testEqual(ndata[i],0.1*i,"mesh_updated node values");
   }
   delete[] ndata;
   
-  FEM_Get_Elem(0,&nelems,&dataPer,&nodePer);
+  FEM_Get_elem(0,&nelems,&dataPer,&nodePer);
   CkPrintf("Getting %d elems (%d data per)\n",nelems,dataPer);
   double *ldata=new double[nelems*dataPer];
-  FEM_Get_Elem_Data(0,ldata);
+  FEM_Get_elem_data(0,ldata);
   for (i=0;i<nelems;i++) {
     testEqual(ldata[i],0.1*i,"mesh_updated elem values");
   }