fdurastante
/
amg4psblas
mirror of https://github.com/sfilippone/amg4psblas.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Makefile fix

Browse Source
omp-walther
StefanoPetrilli 3 years ago
parent 32777cc15c
commit 36bd3a51a2
17 changed files with 233 additions and 242 deletions
Show Stats Download Patch File Download Diff File

13
amgprec/impl/aggregator/Makefile
Unescape Escape View File

@ -62,9 +62,22 @@ amg_s_parmatch_smth_bld.o \
amg_s_parmatch_spmm_bld_inner.o amg_s_parmatch_spmm_bld_inner.o
MPCOBJS=MatchBoxPC.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 \ algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.o \
algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.o algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.o
OBJS = $(FOBJS) $(MPCOBJS) OBJS = $(FOBJS) $(MPCOBJS)
LIBNAME=libamg_prec.a LIBNAME=libamg_prec.a

314
amgprec/impl/aggregator/MatchBoxPC.h
Unescape Escape View File

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

6
amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.cpp
Unescape Escape View File

@ -72,12 +72,6 @@
#ifdef SERIAL_MPI #ifdef SERIAL_MPI
#else #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 // DOUBLE PRECISION VERSION
//WARNING: The vertex block on a given rank is contiguous //WARNING: The vertex block on a given rank is contiguous

12
amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.cpp
Unescape Escape View File

@ -1,16 +1,4 @@
#include "MatchBoxPC.h" #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"
// *********************************************************************** // ***********************************************************************
// //

11
amgprec/impl/aggregator/clean.cpp
Unescape Escape View File

@ -1,19 +1,10 @@
#include "MatchBoxPC.h" #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 comment
//TODO use task //TODO use task
//TODO destroy the locks //TODO destroy the locks
inline void clean(MilanInt myRank, void clean(MilanInt myRank,
MilanLongInt MessageIndex, MilanLongInt MessageIndex,
vector<MPI_Request> &SRequest, vector<MPI_Request> &SRequest,
vector<MPI_Status> &SStatus, vector<MPI_Status> &SStatus,

4
amgprec/impl/aggregator/computeCandidateMate.cpp
Unescape Escape View File

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

11
amgprec/impl/aggregator/extractUChunk.cpp
Unescape Escape View File

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

8
amgprec/impl/aggregator/findOwnerOfGhost.cpp
Unescape Escape View File

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

14
amgprec/impl/aggregator/initialize.cpp
Unescape Escape View File

@ -1,16 +1,6 @@
#include "MatchBoxPC.h" #include "MatchBoxPC.h"
#include <stdio.h>
#include <iostream> void initialize(MilanLongInt NLVer, MilanLongInt NLEdge,
#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,
MilanLongInt StartIndex, MilanLongInt EndIndex, MilanLongInt StartIndex, MilanLongInt EndIndex,
MilanLongInt *numGhostEdgesPtr, MilanLongInt *numGhostEdgesPtr,
MilanLongInt *numGhostVerticesPtr, MilanLongInt *numGhostVerticesPtr,

8
amgprec/impl/aggregator/isAlreadyMatched.cpp
Unescape Escape View File

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

10
amgprec/impl/aggregator/parallelComputeCandidateMateB.cpp
Unescape Escape View File

@ -1,14 +1,6 @@
#include "MatchBoxPC.h" #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 *verLocPtr,
MilanLongInt *verLocInd, MilanLongInt *verLocInd,
MilanInt myRank, MilanInt myRank,

10
amgprec/impl/aggregator/processCrossEdge.cpp
Unescape Escape View File

@ -1,14 +1,6 @@
#include "MatchBoxPC.h" #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, map<MilanLongInt, MilanLongInt> &Ghost2LocalMap,
MilanLongInt edge, MilanLongInt edge,
MilanLongInt *SPtr) MilanLongInt *SPtr)

14
amgprec/impl/aggregator/processExposedVertex.cpp
Unescape Escape View File

@ -1,16 +1,6 @@
#include "MatchBoxPC.h" #include "MatchBoxPC.h"
#include <stdio.h>
#include <iostream> void PARALLEL_PROCESS_EXPOSED_VERTEX_B(MilanLongInt NLVer,
#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,
MilanLongInt *candidateMate, MilanLongInt *candidateMate,
MilanLongInt *verLocInd, MilanLongInt *verLocInd,
MilanLongInt *verLocPtr, MilanLongInt *verLocPtr,

11
amgprec/impl/aggregator/processMatchedVertices.cpp
Unescape Escape View File

@ -1,16 +1,8 @@
#include "MatchBoxPC.h" #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 //#define privateQueues
inline void processMatchedVertices( void processMatchedVertices(
MilanLongInt NLVer, MilanLongInt NLVer,
vector<MilanLongInt> &UChunkBeingProcessed, vector<MilanLongInt> &UChunkBeingProcessed,
staticQueue &U, staticQueue &U,
@ -61,6 +53,7 @@ inline void processMatchedVertices(
#endif #endif
// TODO what would be the optimal UCHUNK // TODO what would be the optimal UCHUNK
// TODO refactor
vector<MilanLongInt> UChunkBeingProcessed; vector<MilanLongInt> UChunkBeingProcessed;
UChunkBeingProcessed.reserve(UCHUNK); UChunkBeingProcessed.reserve(UCHUNK);

9
amgprec/impl/aggregator/processMessages.cpp
Unescape Escape View File

@ -1,13 +1,6 @@
#include "MatchBoxPC.h" #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 numProcs,
MilanInt myRank, MilanInt myRank,
int ComputeTag, int ComputeTag,

9
amgprec/impl/aggregator/queueTransfer.cpp
Unescape Escape View File

@ -1,13 +1,6 @@
#include "MatchBoxPC.h" #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, staticQueue &privateU,
vector<MilanLongInt> &QLocalVtx, vector<MilanLongInt> &QLocalVtx,
vector<MilanLongInt> &QGhostVtx, vector<MilanLongInt> &QGhostVtx,

11
amgprec/impl/aggregator/sendBundledMessages.cpp
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save