int64_t
st_conn_stinger_source (const struct stinger * G, const int64_t nv,
const int64_t ne, const int64_t from,
const int64_t * sources, const int64_t num,
const int64_t numSteps)
{
int64_t k;
int64_t *Q = (int64_t *) xmalloc (nv * sizeof (int64_t));
int64_t *marks_s = (int64_t *) xmalloc (nv * sizeof (int64_t));
int64_t *marks_t = (int64_t *) xmalloc (nv * sizeof (int64_t));
int64_t *QHead = (int64_t *) xmalloc (2 * numSteps * sizeof (int64_t));
int64_t *neighbors = (int64_t *) xmalloc (ne * sizeof (int64_t));
int64_t count = 0;
int64_t deg_s = stinger_outdegree (G, from);
if (deg_s == 0) {
return num;
}
bfs_stinger (G, nv, ne, from, marks_s, numSteps, Q, QHead, neighbors);
for (k = 0; k < num; k++) {
int64_t t = sources[k];
int64_t deg_t = stinger_outdegree (G, t);
if (deg_t == 0) {
stinger_int64_fetch_add (&count, 1);
} else {
bfs_stinger (G, nv, ne, t, marks_t, numSteps, Q, QHead, neighbors);
int64_t local_count = 0;
MTA ("mta assert nodep")
for (int64_t j = 0; j < nv; j++) {
if (marks_s[j] && marks_t[j])
stinger_int64_fetch_add (&local_count, 1);
}
if (local_count == 0)
stinger_int64_fetch_add (&count, 1);
}
}
free (neighbors);
free (QHead);
free (marks_t);
free (marks_s);
free (Q);
return count;
}
void
bfs_stinger (const struct stinger *G, const int64_t nv, const int64_t ne,
const int64_t startV,
int64_t * marks, const int64_t numSteps,
int64_t * Q, int64_t * QHead, int64_t * neighbors)
{
int64_t j, k, s;
int64_t nQ, Qnext, Qstart, Qend;
int64_t w_start;
MTA ("mta assert nodep")
for (j = 0; j < nv; j++) {
marks[j] = 0;
}
s = startV;
/* Push node s onto Q and set bounds for first Q sublist */
Q[0] = s;
Qnext = 1;
nQ = 1;
QHead[0] = 0;
QHead[1] = 1;
marks[s] = 1;
PushOnStack: /* Push nodes onto Q */
/* Execute the nested loop for each node v on the Q AND
for each neighbor w of v */
Qstart = QHead[nQ - 1];
Qend = QHead[nQ];
w_start = 0;
MTA ("mta assert no dependence")
MTA ("mta block dynamic schedule")
for (j = Qstart; j < Qend; j++) {
int64_t v = Q[j];
size_t d;
size_t deg_v = stinger_outdegree (G, v);
int64_t my_w = stinger_int64_fetch_add (&w_start, deg_v);
stinger_gather_typed_successors (G, 0, v, &d, &neighbors[my_w], deg_v);
assert (d == deg_v);
MTA ("mta assert nodep")
for (k = 0; k < deg_v; k++) {
int64_t d, w, l;
w = neighbors[my_w + k];
/* If node has not been visited, set distance and push on Q */
if (stinger_int64_fetch_add (marks + w, 1) == 0) {
Q[stinger_int64_fetch_add (&Qnext, 1)] = w;
}
}
}
if (Qnext != QHead[nQ] && nQ < numSteps) {
nQ++;
QHead[nQ] = Qnext;
goto PushOnStack;
}
}
// NE number of undirected edges.
csrGraph* CreateCSRFromStinger(struct stinger* stingerGraph,int64_t NV,int64_t NE)
{
csrGraph* newGraph = (csrGraph*)malloc(sizeof(csrGraph));
newGraph->NV = NV;
newGraph->NE = NE*2;
newGraph->vertexPointerArray=(int64_t*)malloc(sizeof(int64_t)*(NV+1));
newGraph->edgeArray=(int64_t*)malloc(sizeof(int64_t)*NE);
int64_t edgeCounter=0;
newGraph->vertexPointerArray[0]=0;
for(int64_t v=0; v<NV;v++)
{
newGraph->vertexPointerArray[v+1]= newGraph->vertexPointerArray[v]+stinger_outdegree(stingerGraph,v);
STINGER_FORALL_EDGES_OF_VTX_BEGIN(stingerGraph,v)
{
newGraph->edgeArray[edgeCounter]=STINGER_EDGE_DEST;
edgeCounter++;
}
STINGER_FORALL_EDGES_OF_VTX_END();
}
int64_t
count_triangles (stinger_t * S, uint64_t v)
{
int64_t out = 0;
int64_t deg = stinger_outdegree(S, v);
int64_t * neighbors = xmalloc(deg * sizeof(int64_t));
size_t d;
stinger_gather_typed_successors(S, 0, v, &d, neighbors, deg);
qsort(neighbors, d, sizeof(int64_t), compare);
STINGER_FORALL_EDGES_OF_VTX_BEGIN(S, v) {
if (STINGER_EDGE_DEST != v) {
//out += count_intersections (S, v, STINGER_EDGE_DEST);
out += count_intersections (S, v, STINGER_EDGE_DEST, neighbors, d);
}
} STINGER_FORALL_EDGES_OF_VTX_END();
free (neighbors);
return out;
}
int64_t
st_conn_stinger (const struct stinger *G, const int64_t nv, const int64_t ne,
const int64_t * sources, const int64_t num,
const int64_t numSteps)
{
int64_t k, x;
int64_t *Q_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *marks_s_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *marks_t_big = (int64_t *) xmalloc (INC * nv * sizeof (int64_t));
int64_t *QHead_big =
(int64_t *) xmalloc (INC * 2 * numSteps * sizeof (int64_t));
int64_t *neighbors_big = (int64_t *) xmalloc (INC * ne * sizeof (int64_t));
int64_t count = 0;
k = 0;
x = 0;
OMP ("omp parallel for")
MTA ("mta assert parallel")
MTA ("mta loop future")
MTA ("mta assert nodep")
MTA ("mta assert no alias")
for (x = 0; x < INC; x++) {
int64_t *Q = Q_big + x * nv;
int64_t *marks_s = marks_s_big + x * nv;
int64_t *marks_t = marks_t_big + x * nv;
int64_t *QHead = QHead_big + x * 2 * numSteps;
int64_t *neighbors = neighbors_big + x * ne;
for (int64_t claimedk = stinger_int64_fetch_add (&k, 2);
claimedk < 2 * num; claimedk = stinger_int64_fetch_add (&k, 2)) {
int64_t s = sources[claimedk];
int64_t deg_s = stinger_outdegree (G, s);
int64_t t = sources[claimedk + 1];
int64_t deg_t = stinger_outdegree (G, t);
if (deg_s == 0 || deg_t == 0) {
stinger_int64_fetch_add (&count, 1);
} else {
bfs_stinger (G, nv, ne, s, marks_s, numSteps, Q, QHead, neighbors);
bfs_stinger (G, nv, ne, t, marks_t, numSteps, Q, QHead, neighbors);
int64_t local_count = 0;
MTA ("mta assert nodep")
for (int64_t j = 0; j < nv; j++) {
if (marks_s[j] && marks_t[j])
stinger_int64_fetch_add (&local_count, 1);
}
if (local_count == 0)
stinger_int64_fetch_add (&count, 1);
}
}
}
free (neighbors_big);
free (QHead_big);
free (marks_t_big);
free (marks_s_big);
free (Q_big);
return count;
}
