Merge pull request #4 from erikzenker/topic-randdis

New Mapping : Random

Author: erikzenker

include/mapping.hpp

@@ -3,6 +3,7 @@
 #include <algorithm> /* std::min */
 #include <vector>    /* std::vector */
 #include <assert.h>  /* assert */
+#include <stdlib.h>  /* srand, rand */
 
 /*******************************************************************************
  *
@@ -12,74 +13,119 @@
 
 namespace graybat {
 
-  namespace mapping {
+    namespace mapping {
 
 
-    struct Roundrobin {
-    
-	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;
-
+	/**
+	 * Random distribution of vertices of the *graph* to the
+	 * the peers. All peers need to set the same random *seed*.
+	 * Thus, all peers have the same random base. Therefore
+	 * seeds that depend on varying parameters like time or
+	 * pid or not applicable here.
+	 *
+	 * @param  seed static random seed for all peers
+	 * @return random set of vertices of the *graph*
+	 *
+	 */
+	struct Random {
 
-	    // Distribute and announce vertices
-	    unsigned vertexCount   = graph.getVertices().size();
-	    unsigned maxVertex     = ceil((float)vertexCount / processCount);
+	    Random(int seed)
+		: seed(seed){
 
-	    std::vector<Vertex> myVertices;
-	    if(processID < processCount){
-		for(unsigned i = 0; i < maxVertex; ++i){
-		    unsigned vertex_i = processID + (i * processCount);
-		    if(vertex_i >= vertexCount){
-			break;
-		    }
-		    else {
-			myVertices.push_back(graph.getVertices().at(vertex_i));
+	    }
+	  
+	    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;
+	      
+		srand(seed);
+		std::vector<Vertex> myVertices;
+	      
+		for(Vertex v: graph.getVertices()){
+		    unsigned randomID = rand() % processCount;
+		    if(randomID == processID){
+			myVertices.push_back(v);
 		    }
-	
+
 		}
+	      
+
+		return myVertices;
 	    }
-	    return myVertices;
+	  
+	private:
+	    int seed;
+
+	};
+      
+
+      
+	struct Roundrobin {
+    
+	    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;
+
+
+		// Distribute and announce vertices
+		unsigned vertexCount   = graph.getVertices().size();
+		unsigned maxVertex     = ceil((float)vertexCount / processCount);
+
+		std::vector<Vertex> myVertices;
+		if(processID < processCount){
+		    for(unsigned i = 0; i < maxVertex; ++i){
+			unsigned vertex_i = processID + (i * processCount);
+			if(vertex_i >= vertexCount){
+			    break;
+			}
+			else {
+			    myVertices.push_back(graph.getVertices().at(vertex_i));
+			}
 
-	}
+		    }
+		}
+		return myVertices;
+	
+	    }
 
-    };
+	};
 
-    struct Consecutive {
+	struct Consecutive {
 
-	template<typename T_Graph>
-	std::vector<typename T_Graph::Vertex> operator()(const unsigned processID, const unsigned processCount, T_Graph &graph){
+	    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;
+		typedef typename T_Graph::Vertex Vertex;
 
-	    unsigned vertexCount      = graph.getVertices().size();
-	    unsigned vertexPerProcess = ceil((float)vertexCount / processCount);
+		unsigned vertexCount      = graph.getVertices().size();
+		unsigned vertexPerProcess = ceil((float)vertexCount / processCount);
 
-	    // More processes than vertices
-	    if(processID > vertexCount - 1){
-		return std::vector<Vertex>(0);
-	    }
+		// More processes than vertices
+		if(processID > vertexCount - 1){
+		    return std::vector<Vertex>(0);
+		}
 
-	    unsigned minVertex = processID * vertexPerProcess;
-	    unsigned maxVertex = minVertex + vertexPerProcess;
+		unsigned minVertex = processID * vertexPerProcess;
+		unsigned maxVertex = minVertex + vertexPerProcess;
 
-	    // Slice maxVertex of last process
-	    if(minVertex > vertexCount){
-		return std::vector<Vertex>(0);
-	    }
+		// Slice maxVertex of last process
+		if(minVertex > vertexCount){
+		    return std::vector<Vertex>(0);
+		}
 
-	    maxVertex = std::min(maxVertex, vertexCount);
+		maxVertex = std::min(maxVertex, vertexCount);
 
-	    assert(minVertex <= maxVertex);
+		assert(minVertex <= maxVertex);
 
-	    std::vector<Vertex> vertices = graph.getVertices();
-	    std::vector<Vertex> myVertices(vertices.begin() + minVertex, vertices.begin() + maxVertex);
-	    return myVertices;
+		std::vector<Vertex> vertices = graph.getVertices();
+		std::vector<Vertex> myVertices(vertices.begin() + minVertex, vertices.begin() + maxVertex);
+		return myVertices;
 
-	}
+	    }
 
-    };
+	};
 
-  } /* mapping */
+    } /* mapping */
 
 } /* graybat */

src/gol.cc

@@ -112,7 +112,7 @@ int gol(const unsigned nCells, const unsigned nTimeSteps ) {
     MyCave cave(graybat::pattern::GridDiagonal(height, width));
 
     // Distribute vertices
-    cave.distribute(graybat::mapping::Roundrobin());
+    cave.distribute(graybat::mapping::Random(1234));
 
     /***************************************************************************
      * Run Simulation