Merge pull request #31 from erikzenker/dev

Fix issue #30

Author: erikzenker

CMakeLists.txt

@@ -10,7 +10,7 @@ set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/utils/cmake/modules/" ${CMAKE
 ###############################################################################
 # METIS
 ###############################################################################
-find_package(METIS 5.1.0 REQUIRED)
+find_package(METIS 5.1.0)
 include_directories(SYSTEM ${METIS_INCLUDE_DIRS})
 set(LIBS ${LIBS} ${METIS_LIBRARIES})
 
@@ -37,7 +37,7 @@ endif(MPI_CXX_FOUND)
 # Compiler Flags
 ###############################################################################
 string(FIND ${CMAKE_CXX_COMPILER} "clang++" CXX_COMPILER_IS_CLANG++)
-string(FIND ${CMAKE_CXX_COMPILER} "clang++" CXX_COMPILER_IS_G++)
+string(FIND ${CMAKE_CXX_COMPILER} "g++" CXX_COMPILER_IS_G++)
 
 if(${CXX_COMPILER_IS_G++})
   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

include/BMPI.hpp

@@ -71,6 +71,7 @@ namespace graybat {
 		Context& operator=(const Context& otherContext){
 		    id            = otherContext.getID();
 		    isValid       = otherContext.valid();
+		    comm          = otherContext.comm;
 		    return *this;
 
 		}
@@ -91,7 +92,7 @@ namespace graybat {
 		    return isValid;
 		}
 
-		const mpi::communicator comm;
+		mpi::communicator comm;
 
 	    private:	
 		ContextID id;
@@ -563,8 +564,7 @@ namespace graybat {
 		    allGather(newContext, uri, otherUris);
 
 		    std::copy(otherUris.begin(), otherUris.end(), uriMap[newContext.getID()].begin());
-		    
-		    
+
 	    	    return newContext;
 
 	    	}

include/Cave.hpp

@@ -156,9 +156,9 @@ namespace graybat {
 	    assert(oldContext.valid());
 
 	    // Create new context for peers which host vertices
-	    std::vector<unsigned> hasVertices(1, vertices.size());
+	    std::vector<unsigned> nVertices(1, vertices.size());
 	    std::vector<unsigned> recvHasVertices(oldContext.size(), 0);
-	    cal.allGather(oldContext, hasVertices, recvHasVertices);
+	    cal.allGather(oldContext, nVertices, recvHasVertices);
 
 	    std::vector<VAddr> vAddrsWithVertices;
 
@@ -170,18 +170,16 @@ namespace graybat {
 
 	    Context newContext = cal.createContext(vAddrsWithVertices, oldContext);
 	    graphMap[graph.id] = newContext;
-	    // std::cout << "context size: " << newContext.size() << std::endl;
 
 	    // Each peer announces the vertices it hosts
 	    if(newContext.valid()){
-
 		// Bound graph to new context
 
 
 		// Retrieve maximum number of vertices per peer
-		std::vector<unsigned> myVerticesCount(1,vertices.size());
+		std::vector<unsigned> nVertices(1,vertices.size());
 		std::vector<unsigned> maxVerticesCount(1,  0);
-		cal.allReduce(newContext, op::maximum<unsigned>(), myVerticesCount, maxVerticesCount);
+		cal.allReduce(newContext, op::maximum<unsigned>(), nVertices, maxVerticesCount);
 
 		// Gather maxVerticesCount times vertex ids
 		std::vector<std::vector<Vertex> > newVertexMaps (newContext.size(), std::vector<Vertex>());

include/graybat.hpp

@@ -10,7 +10,6 @@
 //#include <MPI.hpp>     /* graybat::communicationPolicy::MPI */
 #include <BMPI.hpp>    /* graybat::communicationPolicy::BMPI */
 #include <Cave.hpp>    /* graybat::Cave */
-#include <mapping.hpp> /* graybat::Consecutive etc. */
-#include <pattern.hpp> /* graybat::GridDiagonal */
+#include <pattern.hpp> /* graybat::pattern::GridDiagonal */
 
 

include/mapping.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <algorithm> /* std::min */
+#include <vector>    /* std::vector */
+#include <assert.h>  /* assert */
+
+namespace graybat {
+    
+    namespace mapping {
+    
+	struct Consecutive {
+
+	    template<typename T_Graph>
+	    std::vector<typename T_Graph::Vertex> operator()(const unsigned processID, const unsigned processCount, T_Graph &graph){
+
+		typedef typename T_Graph::Vertex Vertex;
+
+		unsigned vertexCount      = graph.getVertices().size();
+		unsigned vertexPerProcess = ceil((float)vertexCount / processCount);
+
+		// More processes than vertices
+		if(processID > vertexCount - 1){
+		    return std::vector<Vertex>(0);
+		}
+
+		unsigned minVertex = processID * vertexPerProcess;
+		unsigned maxVertex = minVertex + vertexPerProcess;
+
+		// Slice maxVertex of last process
+		if(minVertex > vertexCount){
+		    return std::vector<Vertex>(0);
+		}
+	    
+		maxVertex = std::min(maxVertex, vertexCount);
+	
+		assert(minVertex <= maxVertex);
+	
+		std::vector<Vertex> vertices = graph.getVertices();
+		std::vector<Vertex> myVertices(vertices.begin() + minVertex, vertices.begin() + maxVertex);
+		return myVertices;
+
+	    }
+
+	};
+
+    } /* mapping */
+    
+} /* graybat */