Polish

Author: lqhl

src/neighbor_partitioner.cpp

@@ -101,6 +101,14 @@ void NeighborPartitioner::read_remaining()
     }
 }
 
+size_t NeighborPartitioner::count_mirrors()
+{
+    size_t result = 0;
+    rep (i, p)
+        result += is_boundarys[i].count();
+    return result;
+}
+
 void NeighborPartitioner::split()
 {
     LOG(INFO) << "partition `" << basefilename << "'";
@@ -120,8 +128,11 @@ void NeighborPartitioner::split()
         while (occupied[bucket] < local_capacity) {
             vid_t d, vid;
             if (!min_heap.get_min(d, vid)) {
-                if (!get_free_vertex(vid))
+                if (!get_free_vertex(vid)) {
+                    LOG(INFO) << "partition " << bucket
+                              << " stop: no free vertices";
                     break;
+                }
                 d = adj_out[vid].size() + adj_in[vid].size();
             } else {
                 min_heap.remove(vid);
@@ -133,18 +144,17 @@ void NeighborPartitioner::split()
         min_heap.clear();
         compute_timer.stop();
     }
-    DLOG(INFO) << "last partition";
     bucket = p - 1;
+    DLOG(INFO) << "start partition " << bucket;
     read_timer.start();
     read_remaining();
     read_timer.stop();
+    LOG(INFO) << "expected edges in each partition: " << num_edges / p;
     rep (i, p)
         DLOG(INFO) << "edges in partition " << i << ": " << occupied[i];
     size_t max_occupied = *std::max_element(occupied.begin(), occupied.end());
     LOG(INFO) << "balance: " << (double)max_occupied / ((double)num_edges / p);
-    size_t total_mirrors = 0;
-    rep (i, p)
-        total_mirrors += is_boundarys[i].count();
+    size_t total_mirrors = count_mirrors();
     LOG(INFO) << "total mirrors: " << total_mirrors;
     LOG(INFO) << "replication factor: " << (double)total_mirrors / num_vertices;
     LOG(INFO) << "time used for graph input and construction: " << read_timer.get_time();

src/neighbor_partitioner.hpp

@@ -79,12 +79,12 @@ class NeighborPartitioner
         degrees[to]--;
     }
 
-    size_t erase(std::vector<vid_t> &neighbors, vid_t v)
+    size_t erase(std::vector<vid_t> &neighbors, const vid_t &v)
     {
         size_t count = 0;
         for (size_t i = 0; i < neighbors.size(); )
             if (neighbors[i] == v) {
-                std::swap(neighbors[i], neighbors[neighbors.size() - 1]);
+                std::swap(neighbors[i], neighbors.back());
                 neighbors.pop_back();
                 count++;
             } else
@@ -113,14 +113,14 @@ class NeighborPartitioner
                     sample_size--;
                     assign_edge(bucket, direction ? vid : adj[i], direction ? adj[i] : vid);
                     min_heap.decrease_key(vid);
-                    std::swap(adj[i], adj[adj.size() - 1]);
+                    std::swap(adj[i], adj.back());
                     adj.pop_back();
                 } else if (is_boundary[adj[i]] && occupied[bucket] < local_capacity) {
                     sample_size--;
                     assign_edge(bucket, direction ? vid : adj[i], direction ? adj[i] : vid);
                     min_heap.decrease_key(vid);
                     min_heap.decrease_key(adj[i], erase(adj_r[adj[i]], vid));
-                    std::swap(adj[i], adj[adj.size() - 1]);
+                    std::swap(adj[i], adj.back());
                     adj.pop_back();
                 } else
                     i++;
@@ -158,15 +158,14 @@ class NeighborPartitioner
                 is_cores[bucket][vid])) {
             vid = (vid + ++count) % num_vertices;
         }
-        if (count == num_vertices) {
-            DLOG(INFO) << "no free vertices";
+        if (count == num_vertices)
             return false;
-        }
         return true;
     }
 
     void read_more();
     void read_remaining();
+    size_t count_mirrors();
 
   public:
     NeighborPartitioner(std::string basefilename);