Using std atomic and compare exchange wrong in multi-threaded cpp - c++

Question

I am trying to implement multi-threaded page rank algorithm using std::atomic and compare_exchange.
I am definitely doing something wrong as the program never ends. I have the page ranks stored in pr_next and pr_curr.
I was able to make it work using an array of mutexes for each vertex of the graph and locking pr_next[v] += pr_curr[u]/out_degree (commented out in the first for-loop below).
To allow for atomics, I made pr_next an array of std::atomic<PageRankType> and am using compare_exchange_weak to write the new value.
#include "core/graph.h"
#include "core/utils.h"
#include <iomanip>
#include <iostream>
#include <stdlib.h>
#include <thread>
#define INIT_PAGE_RANK 1.0
#define EPSILON 0.01
#define DAMPING 0.85
#define PAGE_RANK(x) (1 - DAMPING + DAMPING * x)
typedef float PageRankType;
//std::vector<std::mutex> mutexes;
void threadFunction(Graph& g, int max_iters, uintV start, uintV end, PageRankType* pr_curr, std::atomic<PageRankType>* pr_next, CustomBarrier& bar){
for (int iter = 0; iter < max_iters; iter++) {
// for each vertex 'u', process all its outNeighbors 'v'
for (uintV u = start; u < end; u++) {
uintE out_degree = g.vertices_[u].getOutDegree();
for (uintE i = 0; i < out_degree; i++) {
uintV v = g.vertices_[u].getOutNeighbor(i);
//mutex version
// mutexes[v].lock();
//pr_next[v] += (pr_curr[u] / out_degree);
//mutexes[v].unlock();
PageRankType expected = std::atomic_load(&pr_next[v]);
while(!std::atomic_compare_exchange_weak(&pr_next[v], &expected, expected + (pr_curr[u] / out_degree))){
}
}
bar.wait();
for (uintV v = start; v < end; v++) {
pr_next[v] = PAGE_RANK(pr_next[v]);
// reset pr_curr for the next iteration
pr_curr[v] = pr_next[v];
pr_next[v] = 0.0;
}
bar.wait();
}
rs.time = t1.stop();
}
}
void pageRankParallel(Graph &g, int max_iters, uint n_workers) {
uintV n = g.n_;
PageRankType *pr_curr = new PageRankType[n];
std::atomic<PageRankType> *pr_next = new std::atomic<PageRankType>[n];
for (uintV i = 0; i < n; i++) {
pr_curr[i] = INIT_PAGE_RANK;
pr_next[i] = 0.0;
}
//mutexes = std::vector<std::mutex>(n);
// Push based pagerank
std::thread threads[n_workers];
CustomBarrier bar(n_workers);
uintV part = n/n_workers;
uintV start = 0;
uintV end = start + part;
for(uint i = 0; i < n_workers; i++){
if( i == n_workers-1)
end = n;
threads[i] = std::thread(threadFunction, std::ref(g), max_iters, start, end, pr_curr, pr_next, std::ref(bar));
start += part;
end += part;
}
for(uint i = 0; i < n_workers; i++) {
threads[i].join();
}
}
int main(int argc, char *argv[]) {
uint n_workers = 4;
int max_iterations = 5;
std::string input_file_path = argv[1];
Graph g;
std::cout << "Reading graph\n";
g.readGraphFromBinary<int>(input_file_path);
std::cout << "Created graph\n";
pageRankParallel(g, max_iterations, n_workers);
return 0;
}
The only changes I made from my working mutex version is changing PageRank* pr_next to std::atomic<PageRank>* pr_next and the two lines here :
PageRankType expected = std::atomic_load(&pr_next[v]);
while(!std::atomic_compare_exchange_weak(&pr_next[v], &expected, expected + (pr_curr[u] / out_degree))){
}
It compiles but when I run it it just goes on forever. If I add print statements before and after the compare_exchange loop, it keeps printing "before loop" "after loop" forever.
What am I doing wrong here?