Makefile fix

amgprec/impl/aggregator/Makefile

@@ -62,9 +62,22 @@ amg_s_parmatch_smth_bld.o \
 amg_s_parmatch_spmm_bld_inner.o
 
 MPCOBJS=MatchBoxPC.o \
+sendBundledMessages.o \
+initialize.o \
+extractUChunk.o \
+isAlreadyMatched.o \
+findOwnerOfGhost.o \
+computeCandidateMate.o \
+parallelComputeCandidateMateB.o \
+processMatchedVertices.o \
+processCrossEdge.o \
+queueTransfer.o \
+processMessages.o \
+processExposedVertex.o \
 algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.o \
 algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.o
 
+
 OBJS = $(FOBJS) $(MPCOBJS)
 
 LIBNAME=libamg_prec.a

amgprec/impl/aggregator/MatchBoxPC.h

@@ -64,7 +64,10 @@
 #include "dataStrStaticQueue.h"
 
 using namespace std;
+
 #define NUM_THREAD 4
+#define UCHUNK 1000
+
 const MilanLongInt REQUEST = 1;
 const MilanLongInt SUCCESS = 2;
 const MilanLongInt FAILURE = 3;
@@ -166,119 +169,206 @@ extern "C"
 #define MilanRealMin MINUS_INFINITY
 #endif
 
-
-
     // Function of find the owner of a ghost vertex using binary search:
-    inline MilanInt findOwnerOfGhost(MilanLongInt vtxIndex, MilanLongInt *mVerDistance,
-                                     MilanInt myRank, MilanInt numProcs);
+    MilanInt findOwnerOfGhost(MilanLongInt vtxIndex, MilanLongInt *mVerDistance,
+                              MilanInt myRank, MilanInt numProcs);
 
-    inline MilanLongInt firstComputeCandidateMate(MilanLongInt adj1,
-                                                  MilanLongInt adj2,
-                                                  MilanLongInt *verLocInd,
-                                                  MilanReal *edgeLocWeight);
+    MilanLongInt firstComputeCandidateMate(MilanLongInt adj1,
+                                           MilanLongInt adj2,
+                                           MilanLongInt *verLocInd,
+                                           MilanReal *edgeLocWeight);
 
-    inline bool isAlreadyMatched(MilanLongInt node,
-                                 MilanLongInt StartIndex,
-                                 MilanLongInt EndIndex,
-                                 vector<MilanLongInt> &GMate,
-                                 MilanLongInt *Mate,
-                                 map<MilanLongInt, MilanLongInt> &Ghost2LocalMap);
+    void queuesTransfer(staticQueue &U,
+                        staticQueue &privateU,
+                        vector<MilanLongInt> &QLocalVtx,
+                        vector<MilanLongInt> &QGhostVtx,
+                        vector<MilanLongInt> &QMsgType,
+                        vector<MilanInt> &QOwner,
+                        staticQueue &privateQLocalVtx,
+                        staticQueue &privateQGhostVtx,
+                        staticQueue &privateQMsgType,
+                        staticQueue &privateQOwner);
 
-    inline MilanLongInt computeCandidateMate(MilanLongInt adj1,
-                                             MilanLongInt adj2,
-                                             MilanReal *edgeLocWeight,
-                                             MilanLongInt k,
-                                             MilanLongInt *verLocInd,
-                                             MilanLongInt StartIndex,
-                                             MilanLongInt EndIndex,
-                                             vector<MilanLongInt> &GMate,
-                                             MilanLongInt *Mate,
-                                             map<MilanLongInt, MilanLongInt> &Ghost2LocalMap);
+    bool isAlreadyMatched(MilanLongInt node,
+                          MilanLongInt StartIndex,
+                          MilanLongInt EndIndex,
+                          vector<MilanLongInt> &GMate,
+                          MilanLongInt *Mate,
+                          map<MilanLongInt, MilanLongInt> &Ghost2LocalMap);
 
-    inline void initialize(MilanLongInt NLVer, MilanLongInt NLEdge,
-                           MilanLongInt StartIndex, MilanLongInt EndIndex,
-                           MilanLongInt *numGhostEdgesPtr,
-                           MilanLongInt *numGhostVerticesPtr,
-                           MilanLongInt *S,
-                           MilanLongInt *verLocInd,
-                           MilanLongInt *verLocPtr,
-                           omp_lock_t *MateLock,
-                           map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
-                           vector<MilanLongInt> &Counter,
-                           vector<MilanLongInt> &verGhostPtr,
-                           vector<MilanLongInt> &verGhostInd,
-                           vector<MilanLongInt> &tempCounter,
-                           vector<MilanLongInt> &GMate,
-                           vector<MilanLongInt> &Message,
-                           vector<MilanLongInt> &QLocalVtx,
-                           vector<MilanLongInt> &QGhostVtx,
-                           vector<MilanLongInt> &QMsgType,
-                           vector<MilanInt> &QOwner,
-                           MilanLongInt *&candidateMate,
-                           staticQueue &U,
-                           staticQueue &privateU,
-                           staticQueue &privateQLocalVtx,
-                           staticQueue &privateQGhostVtx,
-                           staticQueue &privateQMsgType,
-                           staticQueue &privateQOwner);
+    MilanLongInt computeCandidateMate(MilanLongInt adj1,
+                                      MilanLongInt adj2,
+                                      MilanReal *edgeLocWeight,
+                                      MilanLongInt k,
+                                      MilanLongInt *verLocInd,
+                                      MilanLongInt StartIndex,
+                                      MilanLongInt EndIndex,
+                                      vector<MilanLongInt> &GMate,
+                                      MilanLongInt *Mate,
+                                      map<MilanLongInt, MilanLongInt> &Ghost2LocalMap);
 
-    inline void PARALLEL_COMPUTE_CANDIDATE_MATE_B(MilanLongInt NLVer,
-                                                  MilanLongInt *verLocPtr,
-                                                  MilanLongInt *verLocInd,
-                                                  MilanInt myRank,
-                                                  MilanReal *edgeLocWeight,
-                                                  MilanLongInt *candidateMate);
+    void initialize(MilanLongInt NLVer, MilanLongInt NLEdge,
+                    MilanLongInt StartIndex, MilanLongInt EndIndex,
+                    MilanLongInt *numGhostEdgesPtr,
+                    MilanLongInt *numGhostVerticesPtr,
+                    MilanLongInt *S,
+                    MilanLongInt *verLocInd,
+                    MilanLongInt *verLocPtr,
+                    omp_lock_t *MateLock,
+                    map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
+                    vector<MilanLongInt> &Counter,
+                    vector<MilanLongInt> &verGhostPtr,
+                    vector<MilanLongInt> &verGhostInd,
+                    vector<MilanLongInt> &tempCounter,
+                    vector<MilanLongInt> &GMate,
+                    vector<MilanLongInt> &Message,
+                    vector<MilanLongInt> &QLocalVtx,
+                    vector<MilanLongInt> &QGhostVtx,
+                    vector<MilanLongInt> &QMsgType,
+                    vector<MilanInt> &QOwner,
+                    MilanLongInt *&candidateMate,
+                    staticQueue &U,
+                    staticQueue &privateU,
+                    staticQueue &privateQLocalVtx,
+                    staticQueue &privateQGhostVtx,
+                    staticQueue &privateQMsgType,
+                    staticQueue &privateQOwner);
 
-    inline void PARALLEL_PROCESS_EXPOSED_VERTEX_B(MilanLongInt NLVer,
-                                                  MilanLongInt *candidateMate,
-                                                  MilanLongInt *verLocInd,
-                                                  MilanLongInt *verLocPtr,
-                                                  MilanLongInt StartIndex,
-                                                  MilanLongInt EndIndex,
-                                                  MilanLongInt *Mate,
-                                                  vector<MilanLongInt> &GMate,
-                                                  map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
-                                                  MilanReal *edgeLocWeight,
-                                                  MilanLongInt *myCardPtr,
-                                                  MilanLongInt *msgIndPtr,
-                                                  MilanLongInt *NumMessagesBundledPtr,
-                                                  MilanLongInt *SPtr,
-                                                  MilanLongInt *verDistance,
-                                                  MilanLongInt *PCounter,
-                                                  vector<MilanLongInt> &Counter,
-                                                  MilanInt myRank,
-                                                  MilanInt numProcs,
-                                                  staticQueue &U,
-                                                  staticQueue &privateU,
-                                                  vector<MilanLongInt> &QLocalVtx,
-                                                  vector<MilanLongInt> &QGhostVtx,
-                                                  vector<MilanLongInt> &QMsgType,
-                                                  vector<MilanInt> &QOwner,
-                                                  staticQueue &privateQLocalVtx,
-                                                  staticQueue &privateQGhostVtx,
-                                                  staticQueue &privateQMsgType,
-                                                  staticQueue &privateQOwner);
+    void clean(MilanInt myRank,
+               MilanLongInt MessageIndex,
+               vector<MPI_Request> &SRequest,
+               vector<MPI_Status> &SStatus,
+               MilanInt BufferSize,
+               MilanLongInt *Buffer,
+               MilanLongInt msgActual,
+               MilanLongInt *msgActualSent,
+               MilanLongInt msgInd,
+               MilanLongInt *msgIndSent,
+               MilanLongInt NumMessagesBundled,
+               MilanReal *msgPercent);
 
-        inline void queuesTransfer(staticQueue &U,
-                          staticQueue &privateU,
-                          vector<MilanLongInt> &QLocalVtx,
-                          vector<MilanLongInt> &QGhostVtx,
-                          vector<MilanLongInt> &QMsgType,
-                          vector<MilanInt> &QOwner,
-                          staticQueue &privateQLocalVtx,
-                          staticQueue &privateQGhostVtx,
-                          staticQueue &privateQMsgType,
-                          staticQueue &privateQOwner);
+    void PARALLEL_COMPUTE_CANDIDATE_MATE_B(MilanLongInt NLVer,
+                                           MilanLongInt *verLocPtr,
+                                           MilanLongInt *verLocInd,
+                                           MilanInt myRank,
+                                           MilanReal *edgeLocWeight,
+                                           MilanLongInt *candidateMate);
 
-        void dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(
-            MilanLongInt NLVer, MilanLongInt NLEdge,
-            MilanLongInt *verLocPtr, MilanLongInt *verLocInd, MilanReal *edgeLocWeight,
-            MilanLongInt *verDistance,
-            MilanLongInt *Mate,
-            MilanInt myRank, MilanInt numProcs, MPI_Comm comm,
-            MilanLongInt *msgIndSent, MilanLongInt *msgActualSent, MilanReal *msgPercent,
-            MilanReal *ph0_time, MilanReal *ph1_time, MilanReal *ph2_time,
-            MilanLongInt *ph1_card, MilanLongInt *ph2_card);
+    void PARALLEL_PROCESS_EXPOSED_VERTEX_B(MilanLongInt NLVer,
+                                           MilanLongInt *candidateMate,
+                                           MilanLongInt *verLocInd,
+                                           MilanLongInt *verLocPtr,
+                                           MilanLongInt StartIndex,
+                                           MilanLongInt EndIndex,
+                                           MilanLongInt *Mate,
+                                           vector<MilanLongInt> &GMate,
+                                           map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
+                                           MilanReal *edgeLocWeight,
+                                           MilanLongInt *myCardPtr,
+                                           MilanLongInt *msgIndPtr,
+                                           MilanLongInt *NumMessagesBundledPtr,
+                                           MilanLongInt *SPtr,
+                                           MilanLongInt *verDistance,
+                                           MilanLongInt *PCounter,
+                                           vector<MilanLongInt> &Counter,
+                                           MilanInt myRank,
+                                           MilanInt numProcs,
+                                           staticQueue &U,
+                                           staticQueue &privateU,
+                                           vector<MilanLongInt> &QLocalVtx,
+                                           vector<MilanLongInt> &QGhostVtx,
+                                           vector<MilanLongInt> &QMsgType,
+                                           vector<MilanInt> &QOwner,
+                                           staticQueue &privateQLocalVtx,
+                                           staticQueue &privateQGhostVtx,
+                                           staticQueue &privateQMsgType,
+                                           staticQueue &privateQOwner);
+
+    void PROCESS_CROSS_EDGE(vector<MilanLongInt> &Counter,
+                            map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
+                            MilanLongInt edge,
+                            MilanLongInt *SPtr);
+
+    void processMatchedVertices(
+        MilanLongInt NLVer,
+        vector<MilanLongInt> &UChunkBeingProcessed,
+        staticQueue &U,
+        staticQueue &privateU,
+        MilanLongInt StartIndex,
+        MilanLongInt EndIndex,
+        MilanLongInt *myCardPtr,
+        MilanLongInt *msgIndPtr,
+        MilanLongInt *NumMessagesBundledPtr,
+        MilanLongInt *SPtr,
+        MilanLongInt *verLocPtr,
+        MilanLongInt *verLocInd,
+        MilanLongInt *verDistance,
+        MilanLongInt *PCounter,
+        vector<MilanLongInt> &Counter,
+        MilanInt myRank,
+        MilanInt numProcs,
+        MilanLongInt *candidateMate,
+        vector<MilanLongInt> &GMate,
+        MilanLongInt *Mate,
+        map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
+        MilanReal *edgeLocWeight,
+        vector<MilanLongInt> &QLocalVtx,
+        vector<MilanLongInt> &QGhostVtx,
+        vector<MilanLongInt> &QMsgType,
+        vector<MilanInt> &QOwner,
+        staticQueue &privateQLocalVtx,
+        staticQueue &privateQGhostVtx,
+        staticQueue &privateQMsgType,
+        staticQueue &privateQOwner);
+
+    void sendBundledMessages(MilanLongInt *numGhostEdgesPtr,
+                             MilanInt *BufferSizePtr,
+                             MilanLongInt *Buffer,
+                             vector<MilanLongInt> &PCumulative,
+                             vector<MilanLongInt> &PMessageBundle,
+                             vector<MilanLongInt> &PSizeInfoMessages,
+                             MilanLongInt *PCounter,
+                             MilanLongInt NumMessagesBundled,
+                             MilanLongInt *msgActualPtr,
+                             MilanLongInt *MessageIndexPtr,
+                             MilanInt numProcs,
+                             MilanInt myRank,
+                             int ComputeTag,
+                             int BundleTag,
+                             MPI_Comm comm,
+                             vector<MilanLongInt> &QLocalVtx,
+                             vector<MilanLongInt> &QGhostVtx,
+                             vector<MilanLongInt> &QMsgType,
+                             vector<MilanInt> &QOwner,
+                             vector<MPI_Request> &SRequest,
+                             vector<MPI_Status> &SStatus);
+
+    void processMessages(int error_codeC,
+                         MilanInt numProcs,
+                         MilanInt myRank,
+                         int ComputeTag,
+                         int BundleTag,
+                         MPI_Comm comm,
+                         vector<MilanLongInt> &Message,
+                         char *error_message,
+                         int message_length,
+                         vector<MilanLongInt> &ReceiveBuffer,
+                         MilanLongInt *BundleSizePtr);
+
+    void extractUChunk(
+        vector<MilanLongInt> &UChunkBeingProcessed,
+        staticQueue &U,
+        staticQueue &privateU);
+
+    void dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(
+        MilanLongInt NLVer, MilanLongInt NLEdge,
+        MilanLongInt *verLocPtr, MilanLongInt *verLocInd, MilanReal *edgeLocWeight,
+        MilanLongInt *verDistance,
+        MilanLongInt *Mate,
+        MilanInt myRank, MilanInt numProcs, MPI_Comm comm,
+        MilanLongInt *msgIndSent, MilanLongInt *msgActualSent, MilanReal *msgPercent,
+        MilanReal *ph0_time, MilanReal *ph1_time, MilanReal *ph2_time,
+        MilanLongInt *ph1_card, MilanLongInt *ph2_card);
 
     void dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC(
         MilanLongInt NLVer, MilanLongInt NLEdge,

amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.cpp

@@ -72,12 +72,6 @@
 
 #ifdef SERIAL_MPI
 #else
-//MPI type map
-template<typename T> MPI_Datatype TypeMap();
-template<> inline MPI_Datatype TypeMap<int64_t>() { return MPI_LONG_LONG; }
-template<> inline MPI_Datatype TypeMap<int>() { return MPI_INT; }
-template<> inline MPI_Datatype TypeMap<double>() { return MPI_DOUBLE; }
-template<> inline MPI_Datatype TypeMap<float>() { return MPI_FLOAT; }
 
 // DOUBLE PRECISION VERSION
 //WARNING: The vertex block on a given rank is contiguous

amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.cpp

@@ -1,16 +1,4 @@
 #include "MatchBoxPC.h"
-#include <omp.h>
-#include <stdio.h>
-#include "isAlreadyMatched.cpp"
-#include "findOwnerOfGhost.cpp"
-#include "computeCandidateMate.cpp"
-#include "initialize.cpp"
-#include "parallelComputeCandidateMateB.cpp"
-#include "processExposedVertex.cpp"
-#include "processMatchedVertices.cpp"
-#include "sendBundledMessages.cpp"
-#include "processMessages.cpp"
-#include "clean.cpp"
 
 // ***********************************************************************
 //

amgprec/impl/aggregator/clean.cpp

@@ -1,19 +1,10 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <assert.h>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
-
 
 //TODO comment
 //TODO use task
 //TODO destroy the locks
 
-inline void clean(MilanInt myRank,
+void clean(MilanInt myRank,
                   MilanLongInt MessageIndex,
                   vector<MPI_Request> &SRequest,
                   vector<MPI_Status> &SStatus,

amgprec/impl/aggregator/computeCandidateMate.cpp

@@ -9,7 +9,7 @@
  * @param edgeLocWeight
  * @return
  */
-inline MilanLongInt firstComputeCandidateMate(MilanLongInt adj1,
+MilanLongInt firstComputeCandidateMate(MilanLongInt adj1,
                                               MilanLongInt adj2,
                                               MilanLongInt *verLocInd,
                                               MilanReal *edgeLocWeight)
@@ -45,7 +45,7 @@ inline MilanLongInt firstComputeCandidateMate(MilanLongInt adj1,
  * @param Ghost2LocalMap
  * @return
  */
-inline MilanLongInt computeCandidateMate(MilanLongInt adj1,
+MilanLongInt computeCandidateMate(MilanLongInt adj1,
                                          MilanLongInt adj2,
                                          MilanReal *edgeLocWeight,
                                          MilanLongInt k,

amgprec/impl/aggregator/extractUChunk.cpp

@@ -1,15 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
 
-#define UCHUNK 1000
-
-inline void extractUChunk(
+void extractUChunk(
     vector<MilanLongInt> &UChunkBeingProcessed,
     staticQueue &U,
     staticQueue &privateU)

amgprec/impl/aggregator/findOwnerOfGhost.cpp

@@ -1,13 +1,7 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
 
 ///Find the owner of a ghost node:
-inline MilanInt findOwnerOfGhost(MilanLongInt vtxIndex, MilanLongInt *mVerDistance,
+MilanInt findOwnerOfGhost(MilanLongInt vtxIndex, MilanLongInt *mVerDistance,
                                      MilanInt myRank, MilanInt numProcs) {
   //MilanLongInt Size = mVerDistance.size();
   MilanLongInt mStartInd = mVerDistance[myRank];

amgprec/impl/aggregator/initialize.cpp

@@ -1,16 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <assert.h>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
 
-#define NUM_THREAD 4
-
-inline void initialize(MilanLongInt NLVer, MilanLongInt NLEdge,
+void initialize(MilanLongInt NLVer, MilanLongInt NLEdge,
                        MilanLongInt StartIndex, MilanLongInt EndIndex,
                        MilanLongInt *numGhostEdgesPtr,
                        MilanLongInt *numGhostVerticesPtr,

amgprec/impl/aggregator/isAlreadyMatched.cpp

@@ -1,10 +1,4 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
 
 /**
  * //TODO documentation
@@ -17,7 +11,7 @@
  * @param Ghost2LocalMap
  * @return
  */
-inline bool isAlreadyMatched(MilanLongInt node,
+bool isAlreadyMatched(MilanLongInt node,
                              MilanLongInt StartIndex,
                              MilanLongInt EndIndex,
                              vector <MilanLongInt> &GMate,

amgprec/impl/aggregator/parallelComputeCandidateMateB.cpp

@@ -1,14 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <assert.h>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
 
-inline void PARALLEL_COMPUTE_CANDIDATE_MATE_B(MilanLongInt NLVer,
+void PARALLEL_COMPUTE_CANDIDATE_MATE_B(MilanLongInt NLVer,
                                               MilanLongInt *verLocPtr,
                                               MilanLongInt *verLocInd,
                                               MilanInt myRank,

amgprec/impl/aggregator/processCrossEdge.cpp

@@ -1,14 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <assert.h>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
 
-inline void PROCESS_CROSS_EDGE(vector<MilanLongInt> &Counter,
+void PROCESS_CROSS_EDGE(vector<MilanLongInt> &Counter,
                                map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
                                MilanLongInt edge,
                                MilanLongInt *SPtr)

amgprec/impl/aggregator/processExposedVertex.cpp

@@ -1,16 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <assert.h>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
-#include "queueTransfer.cpp"
-#include "processCrossEdge.cpp"
 
-inline void PARALLEL_PROCESS_EXPOSED_VERTEX_B(MilanLongInt NLVer,
+void PARALLEL_PROCESS_EXPOSED_VERTEX_B(MilanLongInt NLVer,
                                               MilanLongInt *candidateMate,
                                               MilanLongInt *verLocInd,
                                               MilanLongInt *verLocPtr,

amgprec/impl/aggregator/processMatchedVertices.cpp

@@ -1,16 +1,8 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
-#include "extractUChunk.cpp"
 
 //#define privateQueues
 
-inline void processMatchedVertices(
+void processMatchedVertices(
     MilanLongInt NLVer,
     vector<MilanLongInt> &UChunkBeingProcessed,
     staticQueue &U,
@@ -61,6 +53,7 @@ inline void processMatchedVertices(
 #endif
 
         // TODO what would be the optimal UCHUNK
+        // TODO refactor
         vector<MilanLongInt> UChunkBeingProcessed;
         UChunkBeingProcessed.reserve(UCHUNK);
 

amgprec/impl/aggregator/processMessages.cpp

@@ -1,13 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
 
-inline void processMessages(int error_codeC,
+void processMessages(int error_codeC,
                             MilanInt numProcs,
                             MilanInt myRank,
                             int ComputeTag,

amgprec/impl/aggregator/queueTransfer.cpp

@@ -1,13 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
 
-inline void queuesTransfer(staticQueue &U,
+void queuesTransfer(staticQueue &U,
                            staticQueue &privateU,
                            vector<MilanLongInt> &QLocalVtx,
                            vector<MilanLongInt> &QGhostVtx,

amgprec/impl/aggregator/sendBundledMessages.cpp

@@ -1,13 +1,6 @@
 #include "MatchBoxPC.h"
-#include <stdio.h>
-#include <iostream>
-#include <map>
-#include <vector>
-#include "primitiveDataTypeDefinitions.h"
-#include "dataStrStaticQueue.h"
-#include "omp.h"
 
-inline void sendBundledMessages(MilanLongInt *numGhostEdgesPtr,
+void sendBundledMessages(MilanLongInt *numGhostEdgesPtr,
                                 MilanInt *BufferSizePtr,
                                 MilanLongInt *Buffer,
                                 vector<MilanLongInt> &PCumulative,