Merge pull request #98 from erikzenker/topic-pagerank

Pagerank example

Author: erikzenker

CMakeLists.txt

@@ -90,8 +90,10 @@ add_test(graybat_check_build "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --ta
 add_test(graybat_example_build "${CMAKE_COMMAND}" --build ${CMAKE_BINARY_DIR} --target example)
 add_test(graybat_test_run  mpiexec --allow-run-as-root -n 2 check )
 add_test(graybat_gol_run  mpiexec --allow-run-as-root gol 90 4 )
+add_test(graybat_pr_run  mpiexec --allow-run-as-root pagerank )
 set_tests_properties(graybat_test_run PROPERTIES DEPENDS graybat_check_build)
 set_tests_properties(graybat_gol_run PROPERTIES DEPENDS graybat_example_build)
+set_tests_properties(graybat_pr_run PROPERTIES DEPENDS graybat_example_build)
 
 # Install
 file(GLOB CMAKE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cmake")

example/pagerank.cpp

@@ -0,0 +1,111 @@
+/**
+ * @example chain.cpp
+ *
+ * @brief Data is send through a chain of compute 
+ *        nodes and every node increments the value.
+ *
+ */
+
+// STL
+#include <iostream>   /* std::cout */
+#include <vector>     /* std::vector */
+
+// GRAYBAT
+#include <graybat/Cage.hpp>
+#include <graybat/communicationPolicy/BMPI.hpp>
+#include <graybat/graphPolicy/BGL.hpp>
+
+// GRAYBAT mappings
+#include <graybat/mapping/Consecutive.hpp>
+
+// GRAYBAT pattern
+#include <graybat/pattern/Random.hpp>
+
+struct PageRank {
+    PageRank() : pageRank({1}){ }
+    std::vector<float> pageRank;
+};
+
+int exp() {
+    /***************************************************************************
+     * Configuration
+     ****************************************************************************/
+
+    // CommunicationPolicy
+    typedef graybat::communicationPolicy::BMPI  CP;
+    typedef CP::Config                          Config;    
+    
+    // GraphPolicy
+    typedef graybat::graphPolicy::BGL<PageRank> GP;
+    
+    // Cage
+    typedef graybat::Cage<CP, GP> Cage;
+    typedef typename Cage::Event  Event;
+    typedef typename Cage::Vertex Vertex;
+    typedef typename Cage::Edge   Edge;    
+
+    /***************************************************************************
+     * Initialize Communication
+     ****************************************************************************/
+    size_t const n = 1000;    
+    size_t const min = 1;
+    size_t const max = 10;
+    size_t const seed = 1234;
+    Config config;
+    Cage cage(config);
+
+    cage.setGraph(graybat::pattern::Random<GP>(n, min, max, seed));    
+    
+    // Distribute vertices
+    cage.distribute(graybat::mapping::Consecutive());
+
+    /***************************************************************************
+     * Run Simulation
+     ****************************************************************************/
+    std::vector<Event> events;
+    size_t const nIterations = 20;
+    float const dampingFactor = 0.5;
+
+    for(size_t iteration = 0; iteration < nIterations; iteration++){
+
+        // Calculate relative pagerank and spread it to
+        // adjacent vertices
+        for(Vertex &v : cage.hostedVertices){
+            assert(cage.getAdjacentVertices(v).size() > 0);            
+            std::vector<float> relativePageRank{1};
+            relativePageRank[0] = v().pageRank[0] / static_cast<float>(cage.getAdjacentVertices(v).size());
+            v.spread(relativePageRank, events);
+        }
+
+        // Calculate vertex page rank based on
+        // relative page rank of adjacent vertices
+        for(Vertex &v : cage.hostedVertices){
+            std::vector<float> relativePageRank{1};            
+            float relativePageRankSum = 0;
+            
+            for(Edge e : cage.getInEdges(v)){
+                cage.recv(e, relativePageRank);
+                relativePageRankSum += relativePageRank[0];                
+            }
+            v().pageRank[0] = (1 - dampingFactor) + dampingFactor * relativePageRankSum;
+        }
+
+        for(unsigned i = 0; i < events.size(); ++i){
+            events.back().wait();
+            events.pop_back();
+        }
+    }
+
+    // Print page final page rank
+    for(Vertex &v : cage.hostedVertices){
+        std::cout << "Pagerank[" <<v.id << "] : " << v().pageRank[0] << std::endl;
+    }
+    
+    return 0;
+
+}
+
+int main(){
+    exp();
+    return 0;
+}

include/graybat/pattern/Random.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+// CLIB
+#include <assert.h>
+
+// STL
+#include <utility> /* std::make_pair */
+#include <cstdlib> /* std::rand */
+
+// GRAYBAT
+#include <graybat/graphPolicy/Traits.hpp>
+
+namespace graybat {
+
+    namespace pattern {
+
+        template<typename T_GraphPolicy>
+        struct Random {
+
+            using GraphPolicy       = T_GraphPolicy;
+            using VertexDescription = graybat::graphPolicy::VertexDescription<GraphPolicy>;
+            using EdgeDescription   = graybat::graphPolicy::EdgeDescription<GraphPolicy>;
+            using GraphDescription  = graybat::graphPolicy::GraphDescription<GraphPolicy>;
+            using EdgeProperty      = graybat::graphPolicy::EdgeProperty<GraphPolicy>;
+            using VertexProperty    = graybat::graphPolicy::VertexProperty<GraphPolicy>;            
+
+            size_t const nVertices;
+            size_t const minEdgesPerVertex;
+            size_t const maxEdgesPerVertex;
+            
+            Random(size_t const nVertices, size_t const minEdgesPerVertex, size_t const maxEdgesPerVertex, size_t const seed) :
+                nVertices(nVertices),
+                minEdgesPerVertex(minEdgesPerVertex),
+                maxEdgesPerVertex(maxEdgesPerVertex)
+            {
+                assert(minEdgesPerVertex <= maxEdgesPerVertex);
+                std::srand(seed);
+            }
+            
+            GraphDescription operator()(){
+                std::vector<VertexDescription> vertices;
+                std::vector<EdgeDescription> edges;
+                
+                for(size_t vertex_i = 0; vertex_i < nVertices; ++vertex_i){
+                    vertices.push_back(std::make_pair(vertex_i, VertexProperty()));
+                }
+
+                for(size_t vertex_i = 0; vertex_i < nVertices; ++vertex_i){
+                    size_t nEdges = std::max(minEdgesPerVertex, (std::rand() % maxEdgesPerVertex));
+                    for(size_t j = 0; j < nEdges; ++j){
+                        size_t adjacentVertex_i = std::rand() % nVertices;
+                        edges.push_back(std::make_pair(std::make_pair(vertices[vertex_i].first, vertices[adjacentVertex_i].first), EdgeProperty()));
+                    }
+                }
+                
+                return std::make_pair(vertices, edges);
+            }
+
+        };
+
+    } /* pattern */
+
+} /* graybat */