void operator()(GNode item, Galois::UserContext<GNode>& ctx) {
if (!graph->containsNode(item, Galois::ALL))
return;
Cavity* cavp = NULL;
if (Version == detDisjoint) {
bool used;
LocalState* localState = (LocalState*) ctx.getLocalState(used);
if (used) {
localState->cav.update(item, ctx);
return;
} else {
cavp = &localState->cav;
}
}
if (Version == detDisjoint) {
cavp->initialize(item);
cavp->build();
cavp->computePost();
} else {
Cavity cav(graph, ctx.getPerIterAlloc());
cav.initialize(item);
cav.build();
cav.computePost();
if (Version == detPrefix)
return;
cav.update(item, ctx);
}
}
/**
* Do reverse BFS on residual graph.
*/
void operator()(const GNode& src, Galois::UserContext<GNode>& ctx) {
if (version != nondet) {
bool used = false;
if (version == detDisjoint) {
ctx.getLocalState(used);
}
if (!used) {
for (Graph::edge_iterator
ii = app.graph.edge_begin(src, Galois::CHECK_CONFLICT),
ee = app.graph.edge_end(src, Galois::CHECK_CONFLICT);
ii != ee; ++ii) {
GNode dst = app.graph.getEdgeDst(ii);
int rdata = app.graph.getEdgeData(findEdge(app.graph, dst, src));
if (rdata > 0) {
app.graph.getData(dst, Galois::CHECK_CONFLICT);
}
}
}
if (version == detDisjoint) {
if (!used)
return;
} else {
app.graph.getData(src, Galois::WRITE);
}
}
for (Graph::edge_iterator
ii = app.graph.edge_begin(src, useCAS ? Galois::NONE : Galois::CHECK_CONFLICT),
ee = app.graph.edge_end(src, useCAS ? Galois::NONE : Galois::CHECK_CONFLICT);
ii != ee; ++ii) {
GNode dst = app.graph.getEdgeDst(ii);
int rdata = app.graph.getEdgeData(findEdge(app.graph, dst, src));
if (rdata > 0) {
Node& node = app.graph.getData(dst, Galois::NONE);
int newHeight = app.graph.getData(src, Galois::NONE).height + 1;
if (useCAS) {
int oldHeight;
while (newHeight < (oldHeight = node.height)) {
if (__sync_bool_compare_and_swap(&node.height, oldHeight, newHeight)) {
ctx.push(dst);
break;
}
}
} else {
if (newHeight < node.height) {
node.height = newHeight;
ctx.push(dst);
}
}
}
}
}
void operator()(UpdateRequest& req, Galois::UserContext<UpdateRequest>& ctx) const {
Galois::MethodFlag flag = useCas ? Galois::NONE : Galois::ALL;
SNode& data = graph.getData(req.n, flag);
if (trackBadWork && req.w > data.dist) {
*WLEmptyWork += 1;
return;
}
for (Graph::edge_iterator ii = graph.edge_begin(req.n, flag),
ee = graph.edge_end(req.n, flag); ii != ee; ++ii) {
GNode dst = graph.getEdgeDst(ii);
unsigned int d = graph.getEdgeData(ii);
SNode& rdata = graph.getData(dst, Galois::NONE);
unsigned int newDist = data.dist + d;
unsigned int v;
while (newDist < (v = rdata.dist)) {
if (!useCas || __sync_bool_compare_and_swap(&rdata.dist, v, newDist)) {
if (!useCas)
rdata.dist = newDist;
if (trackBadWork && v != DIST_INFINITY)
*BadWork += 1;
ctx.push(UpdateRequest(dst, newDist));
break;
}
}
}
}
void relax_edge(unsigned src_data, Graph::edge_iterator ii,
Galois::UserContext<UpdateRequest>& ctx) {
GNode dst = graph.getEdgeDst(ii);
unsigned int edge_data = graph.getEdgeData(ii);
unsigned& dst_data = graph.getData(dst);
unsigned int newDist = dst_data + edge_data;
if (newDist < dst_data) {
dst_data = newDist;
ctx.push(std::make_pair(newDist, dst));
}
}
void relax_edge(Node src_data, Graph::edge_iterator ii,
Galois::UserContext<UpdateRequest>& ctx) {
GNode dst = graph.getEdgeDst(ii);
unsigned int edge_data = graph.getEdgeData(ii);
Node& dst_data = graph.getData(dst);
long long newDist = src_data.distance + edge_data;
if (newDist < dst_data.distance) {
Node t(src_data.nodeId, newDist, src_data.path);
ctx.push(std::make_pair(t, dst));
}
}
void operator()(GNode src, Galois::UserContext<GNode>& ctx) {
for (Graph::edge_iterator ii = graph.edge_begin(src, Galois::ALL),
ei = graph.edge_end(src, Galois::ALL); ii != ei; ++ii) {
GNode dst = graph.getEdgeDst(ii);
Node& ddata = graph.getData(dst, Galois::NONE);
if (ddata.component == root)
continue;
ddata.component = root;
mst.push(std::make_pair(src, dst));
ctx.push(dst);
}
}
void operator()(GNode node, Galois::UserContext<GNode> &lwl) {
auto flag = Galois::NONE;
Node &nData = graph.getData(node);
for (Graph::edge_iterator ei = graph.edge_begin(node,flag),ee=graph.edge_end(node,flag);
ei != ee; ei++) {
GNode neigh = graph.getEdgeDst(ei);
Node &neighData = graph.getData(neigh,Galois::WRITE);
if (neighData.component > nData.component) {
neighData.component = nData.component;
lwl.push(neigh);
}
}
}
void operator()(GNode& src, Galois::UserContext<GNode>& ctx) {
int increment = 1;
acquire(src);
if (discharge(src, ctx)) {
increment += BETA;
}
int v = *counter.local.getLocal() += increment;
if (app.global_relabel_interval > 0 && v >= limit) {
app.should_global_relabel = true;
ctx.breakLoop();
return;
}
}
void operator()(GNode& n, Galois::UserContext<GNode>& ctx) const {
//std::cout << Galois::getActiveThreads() << std::endl;
SNode& data = graph.getData(n, Galois::NONE);
unsigned int newDist = data.dist;
for (Graph::edge_iterator ii = graph.edge_begin(n, Galois::NONE),
ei = graph.edge_end(n, Galois::NONE); ii != ei; ++ii) {
GNode dst = graph.getEdgeDst(ii);
SNode& ddata = graph.getData(dst, Galois::NONE);
if(ddata.dist > newDist){
graph.getData(dst, Galois::NONE).dist= newDist;
ctx.push(dst);
}
}
}
void operator()(UpdateRequest& req, Galois::UserContext<UpdateRequest>& lwl) {
SNode& data = graph.getData(req.n,Galois::NONE);
// if (req.w >= data.dist)
// *WLEmptyWork += 1;
unsigned int v;
while (req.w < (v = data.dist[req.c])) {
if (__sync_bool_compare_and_swap(&data.dist[req.c], v, req.w)) {
// if (v != DIST_INFINITY)
// *BadWork += 1;
for (Graph::edge_iterator ii = graph.edge_begin(req.n, Galois::NONE),
ee = graph.edge_end(req.n, Galois::NONE); ii != ee; ++ii) {
GNode dst = graph.getEdgeDst(ii);
int d = graph.getEdgeData(ii);
unsigned int newDist = req.w + d;
SNode& rdata = graph.getData(dst,Galois::NONE);
if (newDist < rdata.dist[req.c])
lwl.push(UpdateRequest(dst, newDist, req.c));
}
break;
}
}
}
void operator()(GNode& src, Galois::UserContext<GNode>& ctx) {
if (version != nondet) {
bool used = false;
if (version == detDisjoint) {
ctx.getLocalState(used);
}
if (!used) {
acquire(src);
}
if (version == detDisjoint) {
if (!used)
return;
} else {
app.graph.getData(src, Galois::WRITE);
}
}
int increment = 1;
if (discharge(src, ctx)) {
increment += BETA;
}
counter.accum += increment;
}
bool discharge(const GNode& src, Galois::UserContext<GNode>& ctx) {
//Node& node = app.graph.getData(src, Galois::CHECK_CONFLICT);
Node& node = app.graph.getData(src, Galois::NONE);
//int prevHeight = node.height;
bool relabeled = false;
if (node.excess == 0 || node.height >= (int) app.graph.size()) {
return false;
}
while (true) {
//Galois::MethodFlag flag = relabeled ? Galois::NONE : Galois::CHECK_CONFLICT;
Galois::MethodFlag flag = Galois::NONE;
bool finished = false;
int current = node.current;
Graph::edge_iterator
ii = app.graph.edge_begin(src, flag),
ee = app.graph.edge_end(src, flag);
std::advance(ii, node.current);
for (; ii != ee; ++ii, ++current) {
GNode dst = app.graph.getEdgeDst(ii);
int cap = app.graph.getEdgeData(ii);
if (cap == 0)// || current < node.current)
continue;
Node& dnode = app.graph.getData(dst, Galois::NONE);
if (node.height - 1 != dnode.height)
continue;
// Push flow
int amount = std::min(static_cast<int>(node.excess), cap);
reduceCapacity(ii, src, dst, amount);
// Only add once
if (dst != app.sink && dst != app.source && dnode.excess == 0)
ctx.push(dst);
node.excess -= amount;
dnode.excess += amount;
if (node.excess == 0) {
finished = true;
node.current = current;
break;
}
}
if (finished)
break;
relabel(src);
relabeled = true;
if (node.height == (int) app.graph.size())
break;
//prevHeight = node.height;
}
return relabeled;
}
void operator()(int item, Galois::UserContext<int>& lwl) {
for (int i = 0; i < item; ++i)
lwl.push(item - 1);
}