Change the stopping condition of the PageRank implementations (linhares)

Author: Laxman Dhulipala

benchmarks/PageRank/PageRank.h

@@ -146,8 +146,9 @@ struct PR_F {
 //
 // The convergence threshold `eps` must be nonnegative. The algorithm stops when
 // the L1 distance between the PageRank values (seen as a vector with one entry
-// per node) in two consecutive iterations becomes smaller than `eps`, or when
-// `max_iters` iterations have been executed (whichever comes first).
+// per node) in two consecutive iterations becomes smaller than `eps * (number
+// of nodes in G)`, or when `max_iters` iterations have been executed (whichever
+// comes first).
 // `damping_factor` must be in the range [0, 1).
 //
 // If the source vector has non-zero length, the algorithm:
@@ -270,7 +271,7 @@ sequence<double> PageRank_edgeMap(const Graph& G, double eps = 0.000001,
 
     // Swap p_curr and p_next. The final vector returned will be p_curr.
     std::swap(p_curr, p_next);
-    if (L1_norm < eps) {
+    if (L1_norm < eps * n) {
       break;
     }
 

benchmarks/PageRank/PageRank_delta.h

@@ -1,6 +1,3 @@
-#ifndef THIRD_PARTY_GBBS_BENCHMARKS_PAGERANK_PAGERANK_DELTA_H_
-#define THIRD_PARTY_GBBS_BENCHMARKS_PAGERANK_PAGERANK_DELTA_H_
-
 // This code is part of the project "Theoretically Efficient Parallel Graph
 // Algorithms Can Be Fast and Scalable", presented at Symposium on Parallelism
 // in Algorithms and Architectures, 2018.
@@ -259,7 +256,7 @@ sequence<double> PageRankDelta(Graph& G, double eps = 0.000001,
     auto differences = parlay::delayed_seq<double>(
         n, [&](size_t i) { return fabs(Delta[i].delta); });
     double L1_norm = parlay::reduce(differences, parlay::plus<double>());
-    if (L1_norm < eps) break;
+    if (L1_norm < eps * n) break;
     gbbs_debug(std::cout << "L1_norm = " << L1_norm << std::endl;);
 
     // Reset
@@ -277,5 +274,3 @@ sequence<double> PageRankDelta(Graph& G, double eps = 0.000001,
 
 }  // namespace delta
 }  // namespace gbbs
-
-#endif  // THIRD_PARTY_GBBS_BENCHMARKS_PAGERANK_PAGERANK_DELTA_H_

benchmarks/PageRank/PageRank_edgeMapReduce.h

@@ -1,6 +1,3 @@
-#ifndef THIRD_PARTY_GBBS_BENCHMARKS_PAGERANK_PAGERANK_EDGEMAPREDUCE_H_
-#define THIRD_PARTY_GBBS_BENCHMARKS_PAGERANK_PAGERANK_EDGEMAPREDUCE_H_
-
 // This code is part of the project "Theoretically Efficient Parallel Graph
 // Algorithms Can Be Fast and Scalable", presented at Symposium on Parallelism
 // in Algorithms and Architectures, 2018.
@@ -25,7 +22,7 @@
 // SOFTWARE.
 //
 // This file provides an alternate implementation of computing PageRank. Please
-// see PageRank.h for comments that also apply to this file. The difference 
+// see PageRank.h for comments that also apply to this file. The difference
 // between this implementation and the one in PageRank.h is some optimizations
 // used to speed up how the matrix-vector product works. We should carefully
 // benchmark the two implementations again, but from a few years ago (~2020),
@@ -70,10 +67,10 @@ inline void ValidatePageRankParameters(const double eps,
                                        const double damping_factor) {
   ASSERT(eps >= 0.0);
   ASSERT(0.0 <= damping_factor && damping_factor < 1.0);
-}  
-  
 }
 
+}  // namespace pagerank_edgemapreduce_utils
+
 // This version of PageRank uses edgeMapReduce_dense, an implementation
 // which reduces over the in-neighbors of every vertex and aggregates the
 // incoming contributions to each vertex in parallel.
@@ -203,7 +200,7 @@ sequence<double> PageRank_edgeMapReduce(Graph& G, double eps = 0.000001,
     std::swap(p_curr, p_next);
     // Reset p_curr and p_div.
     std::swap(p_div, p_div_next);
-    if (L1_norm < eps) {
+    if (L1_norm < eps * n) {
       break;
     }
     gbbs_debug(std::cout << "L1_norm = " << L1_norm << std::endl;);
@@ -216,8 +213,4 @@ sequence<double> PageRank_edgeMapReduce(Graph& G, double eps = 0.000001,
   return p_curr;
 }
 
-
-  
-}
-
-#endif  // THIRD_PARTY_GBBS_BENCHMARKS_PAGERANK_PAGERANK_EDGEMAPREDUCE_H_
+}  // namespace gbbs

benchmarks/PageRank/PageRank_test.cc

@@ -2,6 +2,7 @@
 
 #include "benchmarks/PageRank/PageRank.h"
 
+#include <cmath>
 #include <cstddef>
 #include <unordered_set>
 #include <vector>
@@ -18,6 +19,7 @@
 
 using ::testing::DoubleNear;
 using ::testing::ElementsAre;
+using ::testing::ElementsAreArray;
 using ::testing::IsEmpty;
 using ::testing::Pointwise;
 
@@ -125,6 +127,59 @@ TYPED_TEST(PageRankFixture, Path) {
   }
 }
 
+TYPED_TEST(PageRankFixture, RespectsEps) {
+  // Graph diagram:
+  //     0 - 1 - 2
+  //
+  constexpr uintE kNumVertices{3};
+  const std::unordered_set<UndirectedEdge> kEdges{
+      {0, 1},
+      {1, 2},
+  };
+  auto graph{graph_test::MakeUnweightedSymmetricGraph(kNumVertices, kEdges)};
+  using Impl = typename TestFixture::Impl;
+
+  {
+    // Between iterations 4 and 5 and between iterations 5 and 6, the L1
+    // distance between the PageRank values are approximately 0.295804 and
+    // 0.251433 respectively. The next lines verify that assumption.
+    const sequence<double> result_with_4_iterations =
+        Impl::compute_pagerank(graph, /*eps=*/1e-6, /*sources=*/{},
+                               /*damping_factor=*/0.85, /*max_iters=*/4);
+    const sequence<double> result_with_5_iterations =
+        Impl::compute_pagerank(graph, /*eps=*/1e-6, /*sources=*/{},
+                               /*damping_factor=*/0.85, /*max_iters=*/5);
+    const sequence<double> result_with_6_iterations =
+        Impl::compute_pagerank(graph, /*eps=*/1e-6, /*sources=*/{},
+                               /*damping_factor=*/0.85, /*max_iters=*/6);
+
+    double l1_distance_iteration_4_to_5 = 0.0;
+    for (int i = 0; i < 3; ++i) {
+      l1_distance_iteration_4_to_5 +=
+          fabs(result_with_4_iterations[i] - result_with_5_iterations[i]);
+    }
+    ASSERT_GT(l1_distance_iteration_4_to_5, 0.28);
+    ASSERT_LT(l1_distance_iteration_4_to_5, 0.3);
+
+    double l1_distance_iteration_5_to_6 = 0.0;
+    for (int i = 0; i < 3; ++i) {
+      l1_distance_iteration_5_to_6 +=
+          fabs(result_with_5_iterations[i] - result_with_6_iterations[i]);
+    }
+    ASSERT_GT(l1_distance_iteration_5_to_6, 0.24);
+    ASSERT_LT(l1_distance_iteration_5_to_6, 0.26);
+
+    // Run the algorithm with `eps` small enough to reach iteration 5, but not
+    // iteration 6.
+    EXPECT_THAT(Impl::compute_pagerank(graph, /*eps=*/0.31 / 3),
+                ElementsAreArray(result_with_5_iterations));
+    // Run the algorithm with `eps` small enough to reach iteration 6, but not
+    // iteration 7.
+    EXPECT_THAT(Impl::compute_pagerank(graph, /*eps=*/0.27 / 3),
+                ElementsAreArray(result_with_6_iterations));
+  }
+}
+
 TYPED_TEST(PageRankFixture, BasicUndirected) {
   // Graph diagram:
   //     0 - 1    2 - 3 - 4

gbbs/helpers/parallel_for_with_status.h

@@ -1,5 +1,4 @@
-#ifndef THIRD_PARTY_GBBS_GBBS_HELPERS_PARALLEL_FOR_WITH_STATUS_H_
-#define THIRD_PARTY_GBBS_GBBS_HELPERS_PARALLEL_FOR_WITH_STATUS_H_
+#pragma once
 
 #include <cstddef>
 
@@ -41,5 +40,3 @@ absl::Status parallel_for_with_status(
 }
 
 }  // namespace gbbs
-
-#endif  // THIRD_PARTY_GBBS_GBBS_HELPERS_PARALLEL_FOR_WITH_STATUS_H_