/* =============================================================================
* prefix_sums
* =============================================================================
*/
static void
prefix_sums (ULONGINT_T* result, LONGINT_T* input, ULONGINT_T arraySize)
{
long myId = thread_getId();
long numThread = thread_getNumThread();
ULONGINT_T* p = NULL;
if (myId == 0) {
p = (ULONGINT_T*)malloc(NOSHARE(numThread) * sizeof(ULONGINT_T));
assert(p);
global_p = p;
}
thread_barrier_wait();
p = global_p;
long start;
long end;
long r = arraySize / numThread;
start = myId * r + 1;
end = (myId + 1) * r;
if (myId == (numThread - 1)) {
end = arraySize;
}
//ULONGINT_T j;
long j;
for (j = start; j < end; j++) {
result[j] = input[j-1] + result[j-1];
}
p[NOSHARE(myId)] = result[end-1];
thread_barrier_wait();
if (myId == 0) {
for (j = 1; j < numThread; j++) {
p[NOSHARE(j)] += p[NOSHARE(j-1)];
}
}
thread_barrier_wait();
if (myId > 0) {
ULONGINT_T add_value = p[NOSHARE(myId-1)];
for (j = start-1; j < end; j++) {
result[j] += add_value;
}
}
thread_barrier_wait();
if (myId == 0) {
free(p);
}
}
/* =============================================================================
* genScalData
* =============================================================================
*/
void
genScalData (void* argPtr)
{
TM_THREAD_ENTER();
graphSDG* SDGdataPtr = (graphSDG*)argPtr;
long myId = thread_getId();
long numThread = thread_getNumThread();
/*
* STEP 0: Create the permutations required to randomize the vertices
*/
random_t* stream = PRANDOM_ALLOC();
assert(stream);
PRANDOM_SEED(stream, myId);
ULONGINT_T* permV; /* the vars associated with the graph tuple */
if (myId == 0) {
permV = (ULONGINT_T*)P_MALLOC(TOT_VERTICES * sizeof(ULONGINT_T));
assert(permV);
global_permV = permV;
}
thread_barrier_wait();
permV = global_permV;
long i;
long i_start;
long i_stop;
createPartition(0, TOT_VERTICES, myId, numThread, &i_start, &i_stop);
/* Initialize the array */
for (i = i_start; i < i_stop; i++) {
permV[i] = i;
}
thread_barrier_wait();
for (i = i_start; i < i_stop; i++) {
long t1 = PRANDOM_GENERATE(stream);
long t = i + t1 % (TOT_VERTICES - i);
if (t != i) {
__transaction_atomic {
long t2 = permV[t];
permV[t] = permV[i];
permV[i] = t2;
}
}
}
void
printId (void* argPtr)
{
long threadId = thread_getId();
long numThread = thread_getNumThread();
long i;
for ( i = 0; i < NUM_ITERATIONS; i++ ) {
thread_barrier_wait();
if (threadId == 0) {
sleep(1);
} else if (threadId == numThread-1) {
usleep(100);
}
printf("i = %li, tid = %li\n", i, threadId);
if (threadId == 0) {
puts("");
}
fflush(stdout);
}
}
/* =============================================================================
* sequencer_run
* =============================================================================
*/
void
sequencer_run (void* argPtr)
{
TM_THREAD_ENTER();
long threadId = thread_getId();
sequencer_t* sequencerPtr = (sequencer_t*)argPtr;
hashtable_t* uniqueSegmentsPtr;
endInfoEntry_t* endInfoEntries;
table_t** startHashToConstructEntryTables;
constructEntry_t* constructEntries;
table_t* hashToConstructEntryTable;
uniqueSegmentsPtr = sequencerPtr->uniqueSegmentsPtr;
endInfoEntries = sequencerPtr->endInfoEntries;
startHashToConstructEntryTables = sequencerPtr->startHashToConstructEntryTables;
constructEntries = sequencerPtr->constructEntries;
hashToConstructEntryTable = sequencerPtr->hashToConstructEntryTable;
segments_t* segmentsPtr = sequencerPtr->segmentsPtr;
assert(segmentsPtr);
vector_t* segmentsContentsPtr = segmentsPtr->contentsPtr;
long numSegment = vector_getSize(segmentsContentsPtr);
long segmentLength = segmentsPtr->length;
long i;
long j;
long i_start;
long i_stop;
long numUniqueSegment;
long substringLength;
long entryIndex;
/*
* Step 1: Remove duplicate segments
*/
// #if defined(HTM) || defined(STM)
long numThread = thread_getNumThread();
{
/* Choose disjoint segments [i_start,i_stop) for each thread */
long partitionSize = (numSegment + numThread/2) / numThread; /* with rounding */
i_start = threadId * partitionSize;
if (threadId == (numThread - 1)) {
i_stop = numSegment;
} else {
i_stop = i_start + partitionSize;
}
}
// #else /* !(HTM || STM) */
// i_start = 0;
// i_stop = numSegment;
// #endif /* !(HTM || STM) */
for (i = i_start; i < i_stop; i+=CHUNK_STEP1) {
TM_BEGIN();
{
long ii;
long ii_stop = MIN(i_stop, (i+CHUNK_STEP1));
for (ii = i; ii < ii_stop; ii++) {
void* segment = vector_at(segmentsContentsPtr, ii);
TMHASHTABLE_INSERT(uniqueSegmentsPtr,
segment,
segment);
} /* ii */
}
TM_END();
}
thread_barrier_wait();
/*
* Step 2a: Iterate over unique segments and compute hashes.
*
* For the gene "atcg", the hashes for the end would be:
*
* "t", "tc", and "tcg"
*
* And for the gene "tcgg", the hashes for the start would be:
*
* "t", "tc", and "tcg"
*
* The names are "end" and "start" because if a matching pair is found,
* they are the substring of the end part of the pair and the start
* part of the pair respectively. In the above example, "tcg" is the
* matching substring so:
*
* (end) (start)
* a[tcg] + [tcg]g = a[tcg]g (overlap = "tcg")
*/
/* uniqueSegmentsPtr is constant now */
numUniqueSegment = hashtable_getSize(uniqueSegmentsPtr);
entryIndex = 0;
// #if defined(HTM) || defined(STM)
{
/* Choose disjoint segments [i_start,i_stop) for each thread */
long num = uniqueSegmentsPtr->numBucket;
long partitionSize = (num + numThread/2) / numThread; /* with rounding */
i_start = threadId * partitionSize;
if (threadId == (numThread - 1)) {
i_stop = num;
} else {
i_stop = i_start + partitionSize;
}
}
{
/* Approximate disjoint segments of element allocation in constructEntries */
long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */
entryIndex = threadId * partitionSize;
}
// #else /* !(HTM || STM) */
// i_start = 0;
// i_stop = uniqueSegmentsPtr->numBucket;
// entryIndex = 0;
//#endif /* !(HTM || STM) */
for (i = i_start; i < i_stop; i++) {
list_t* chainPtr = uniqueSegmentsPtr->buckets[i];
list_iter_t it;
list_iter_reset(&it, chainPtr);
while (list_iter_hasNext(&it, chainPtr)) {
char* segment =
(char*)((pair_t*)list_iter_next(&it, chainPtr))->firstPtr;
constructEntry_t* constructEntryPtr;
long j;
ulong_t startHash;
bool_t status;
/* Find an empty constructEntries entry */
TM_BEGIN();
while (((void*)TM_SHARED_READ_P(constructEntries[entryIndex].segment)) != NULL) {
entryIndex = (entryIndex + 1) % numUniqueSegment; /* look for empty */
}
constructEntryPtr = &constructEntries[entryIndex];
TM_SHARED_WRITE_P(constructEntryPtr->segment, segment);
TM_END();
entryIndex = (entryIndex + 1) % numUniqueSegment;
/*
* Save hashes (sdbm algorithm) of segment substrings
*
* endHashes will be computed for shorter substrings after matches
* have been made (in the next phase of the code). This will reduce
* the number of substrings for which hashes need to be computed.
*
* Since we can compute startHashes incrementally, we go ahead
* and compute all of them here.
*/
/* constructEntryPtr is local now */
constructEntryPtr->endHash = (ulong_t)hashString(&segment[1]);
startHash = 0;
for (j = 1; j < segmentLength; j++) {
startHash = (ulong_t)segment[j-1] +
(startHash << 6) + (startHash << 16) - startHash;
TM_BEGIN();
status = TMTABLE_INSERT(startHashToConstructEntryTables[j],
(ulong_t)startHash,
(void*)constructEntryPtr );
TM_END();
assert(status);
}
/*
* For looking up construct entries quickly
*/
startHash = (ulong_t)segment[j-1] +
(startHash << 6) + (startHash << 16) - startHash;
TM_BEGIN();
status = TMTABLE_INSERT(hashToConstructEntryTable,
(ulong_t)startHash,
(void*)constructEntryPtr);
TM_END();
assert(status);
}
}
thread_barrier_wait();
/*
* Step 2b: Match ends to starts by using hash-based string comparison.
*/
for (substringLength = segmentLength-1; substringLength > 0; substringLength--) {
table_t* startHashToConstructEntryTablePtr =
startHashToConstructEntryTables[substringLength];
list_t** buckets = startHashToConstructEntryTablePtr->buckets;
long numBucket = startHashToConstructEntryTablePtr->numBucket;
long index_start;
long index_stop;
// #if defined(HTM) || defined(STM)
{
/* Choose disjoint segments [index_start,index_stop) for each thread */
long partitionSize = (numUniqueSegment + numThread/2) / numThread; /* with rounding */
index_start = threadId * partitionSize;
if (threadId == (numThread - 1)) {
index_stop = numUniqueSegment;
} else {
index_stop = index_start + partitionSize;
}
}
// #else /* !(HTM || STM) */
// index_start = 0;
// index_stop = numUniqueSegment;
//#endif /* !(HTM || STM) */
/* Iterating over disjoint itervals in the range [0, numUniqueSegment) */
for (entryIndex = index_start;
entryIndex < index_stop;
entryIndex += endInfoEntries[entryIndex].jumpToNext)
{
if (!endInfoEntries[entryIndex].isEnd) {
continue;
}
/* ConstructEntries[entryIndex] is local data */
constructEntry_t* endConstructEntryPtr =
&constructEntries[entryIndex];
char* endSegment = endConstructEntryPtr->segment;
ulong_t endHash = endConstructEntryPtr->endHash;
list_t* chainPtr = buckets[endHash % numBucket]; /* buckets: constant data */
list_iter_t it;
list_iter_reset(&it, chainPtr);
/* Linked list at chainPtr is constant */
while (list_iter_hasNext(&it, chainPtr)) {
constructEntry_t* startConstructEntryPtr =
(constructEntry_t*)list_iter_next(&it, chainPtr);
char* startSegment = startConstructEntryPtr->segment;
long newLength = 0;
/* endConstructEntryPtr is local except for properties startPtr/endPtr/length */
TM_BEGIN();
/* Check if matches */
if (TM_SHARED_READ(startConstructEntryPtr->isStart) &&
(TM_SHARED_READ_P(endConstructEntryPtr->startPtr) != startConstructEntryPtr) &&
(strncmp(startSegment,
&endSegment[segmentLength - substringLength],
substringLength) == 0))
{
TM_SHARED_WRITE(startConstructEntryPtr->isStart, FALSE);
constructEntry_t* startConstructEntry_endPtr;
constructEntry_t* endConstructEntry_startPtr;
/* Update endInfo (appended something so no longer end) */
TM_LOCAL_WRITE(endInfoEntries[entryIndex].isEnd, FALSE);
/* Update segment chain construct info */
startConstructEntry_endPtr =
(constructEntry_t*)TM_SHARED_READ_P(startConstructEntryPtr->endPtr);
endConstructEntry_startPtr =
(constructEntry_t*)TM_SHARED_READ_P(endConstructEntryPtr->startPtr);
assert(startConstructEntry_endPtr);
assert(endConstructEntry_startPtr);
TM_SHARED_WRITE_P(startConstructEntry_endPtr->startPtr,
endConstructEntry_startPtr);
TM_LOCAL_WRITE_P(endConstructEntryPtr->nextPtr,
startConstructEntryPtr);
TM_SHARED_WRITE_P(endConstructEntry_startPtr->endPtr,
startConstructEntry_endPtr);
TM_SHARED_WRITE(endConstructEntryPtr->overlap, substringLength);
newLength = (long)TM_SHARED_READ(endConstructEntry_startPtr->length) +
(long)TM_SHARED_READ(startConstructEntryPtr->length) -
substringLength;
TM_SHARED_WRITE(endConstructEntry_startPtr->length, newLength);
} /* if (matched) */
TM_END();
if (!endInfoEntries[entryIndex].isEnd) { /* if there was a match */
break;
}
} /* iterate over chain */
} /* for (endIndex < numUniqueSegment) */
thread_barrier_wait();
/*
* Step 2c: Update jump values and hashes
*
* endHash entries of all remaining ends are updated to the next
* substringLength. Additionally jumpToNext entries are updated such
* that they allow to skip non-end entries. Currently this is sequential
* because parallelization did not perform better.
. */
if (threadId == 0) {
if (substringLength > 1) {
long index = segmentLength - substringLength + 1;
/* initialization if j and i: with i being the next end after j=0 */
for (i = 1; !endInfoEntries[i].isEnd; i+=endInfoEntries[i].jumpToNext) {
/* find first non-null */
}
/* entry 0 is handled seperately from the loop below */
endInfoEntries[0].jumpToNext = i;
if (endInfoEntries[0].isEnd) {
constructEntry_t* constructEntryPtr = &constructEntries[0];
char* segment = constructEntryPtr->segment;
constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]);
}
/* Continue scanning (do not reset i) */
for (j = 0; i < numUniqueSegment; i+=endInfoEntries[i].jumpToNext) {
if (endInfoEntries[i].isEnd) {
constructEntry_t* constructEntryPtr = &constructEntries[i];
char* segment = constructEntryPtr->segment;
constructEntryPtr->endHash = (ulong_t)hashString(&segment[index]);
endInfoEntries[j].jumpToNext = MAX(1, (i - j));
j = i;
}
}
endInfoEntries[j].jumpToNext = i - j;
}
}
thread_barrier_wait();
} /* for (substringLength > 0) */
thread_barrier_wait();
/*
* Step 3: Build sequence string
*/
if (threadId == 0) {
long totalLength = 0;
for (i = 0; i < numUniqueSegment; i++) {
constructEntry_t* constructEntryPtr = &constructEntries[i];
if (constructEntryPtr->isStart) {
totalLength += constructEntryPtr->length;
}
}
sequencerPtr->sequence = (char*)P_MALLOC((totalLength+1) * sizeof(char));
char* sequence = sequencerPtr->sequence;
assert(sequence);
char* copyPtr = sequence;
long sequenceLength = 0;
for (i = 0; i < numUniqueSegment; i++) {
constructEntry_t* constructEntryPtr = &constructEntries[i];
/* If there are several start segments, we append in arbitrary order */
if (constructEntryPtr->isStart) {
long newSequenceLength = sequenceLength + constructEntryPtr->length;
assert( newSequenceLength <= totalLength );
copyPtr = sequence + sequenceLength;
sequenceLength = newSequenceLength;
do {
long numChar = segmentLength - constructEntryPtr->overlap;
if ((copyPtr + numChar) > (sequence + newSequenceLength)) {
TM_PRINT0("ERROR: sequence length != actual length\n");
break;
}
memcpy(copyPtr,
constructEntryPtr->segment,
(numChar * sizeof(char)));
copyPtr += numChar;
} while ((constructEntryPtr = constructEntryPtr->nextPtr) != NULL);
assert(copyPtr <= (sequence + sequenceLength));
}
}
assert(sequence != NULL);
sequence[sequenceLength] = '\0';
}
TM_THREAD_EXIT();
}
/* =============================================================================
* findSubGraphs0
* =============================================================================
*/
void
findSubGraphs0 (void* argPtr)
{
graph* GPtr = ((findSubGraphs0_arg_t*)argPtr)->GPtr;
V* intWtVList = ((findSubGraphs0_arg_t*)argPtr)->intWtVList;
V* strWtVList = ((findSubGraphs0_arg_t*)argPtr)->strWtVList;
edge* maxIntWtList = ((findSubGraphs0_arg_t*)argPtr)->maxIntWtList;
long maxIntWtListSize = ((findSubGraphs0_arg_t*)argPtr)->maxIntWtListSize;
edge* soughtStrWtList = ((findSubGraphs0_arg_t*)argPtr)->soughtStrWtList;
long soughtStrWtListSize = ((findSubGraphs0_arg_t*)argPtr)->soughtStrWtListSize;
long myId = thread_getId();
long numThread = thread_getNumThread();
long i;
long i_start;
long i_stop;
createPartition(0,
(maxIntWtListSize + soughtStrWtListSize),
myId,
numThread,
&i_start,
&i_stop);
for (i = i_start; i < i_stop; i++) {
if (i < maxIntWtListSize) {
unsigned long j;
for (j = 0; j < GPtr->numVertices; j++) {
intWtVList[i*(GPtr->numVertices)+j].num = 0;
intWtVList[i*(GPtr->numVertices)+j].depth = 0;
}
} else {
long t = i - maxIntWtListSize;
unsigned long j;
for (j = 0; j < GPtr->numVertices; j++) {
strWtVList[t*(GPtr->numVertices)+j].num = 0;
strWtVList[t*(GPtr->numVertices)+j].depth = 0;
}
}
}
thread_barrier_wait();
LONGINT_T* visited = (LONGINT_T*)P_MALLOC(GPtr->numVertices * sizeof(LONGINT_T));
assert(visited);
/*
* Each thread runs a BFS from endvertex of maxIntWtList edgeList
*/
for (i = i_start; i < i_stop; i++) {
unsigned long k;
for (k = 0; k < GPtr->numVertices; k++) {
visited[k] = 0;
}
if (i < maxIntWtListSize) {
intWtVList[i*(GPtr->numVertices)+0].num = maxIntWtList[i].startVertex;
intWtVList[i*(GPtr->numVertices)+0].depth = -1;
intWtVList[i*(GPtr->numVertices)+1].num = maxIntWtList[i].endVertex;
intWtVList[i*(GPtr->numVertices)+1].depth = 1;
visited[(intWtVList[i*(GPtr->numVertices)+0]).num] = 1;
visited[(intWtVList[i*(GPtr->numVertices)+1]).num] = 1;
long depth = 1;
long verticesVisited = 2;
long currIndex = 1;
while ((depth < SUBGR_EDGE_LENGTH) ||
(verticesVisited == (long)GPtr->numVertices))
{
long intWtListIndex = i*(GPtr->numVertices)+currIndex;
depth = intWtVList[intWtListIndex].depth + 1;
long j;
long j_start = GPtr->outVertexIndex[intWtVList[intWtListIndex].num];
long j_stop = j_start + GPtr->outDegree[intWtVList[intWtListIndex].num];
for (j = j_start; j < j_stop; j++) {
if (visited[GPtr->outVertexList[j]] == 0) {
visited[GPtr->outVertexList[j]] = 1;
intWtVList[i*(GPtr->numVertices)+verticesVisited].num =
GPtr->outVertexList[j];
intWtVList[i*(GPtr->numVertices)+verticesVisited].depth =
depth;
verticesVisited++;
}
}
if ((currIndex < verticesVisited - 1) &&
(verticesVisited < (long)GPtr->numVertices))
{
currIndex++;
depth = intWtVList[i*(GPtr->numVertices)+currIndex].depth;
} else {
break;
}
}
} else {
long t = i - maxIntWtListSize;
strWtVList[t*(GPtr->numVertices)+0].num =
(soughtStrWtList[t]).startVertex;
strWtVList[t*(GPtr->numVertices)+0].depth = -1;
strWtVList[t*(GPtr->numVertices)+1].num =
(soughtStrWtList[t]).endVertex;
strWtVList[t*(GPtr->numVertices)+1].depth = 1;
visited[(strWtVList[t*(GPtr->numVertices)+0]).num] = 1;
visited[(strWtVList[t*(GPtr->numVertices)+1]).num] = 1;
long depth = 1;
long verticesVisited = 2;
long currIndex = 1;
while ((depth < SUBGR_EDGE_LENGTH) ||
(verticesVisited == (long)GPtr->numVertices))
{
long strWtVListIndex = t*(GPtr->numVertices)+currIndex;
depth = strWtVList[strWtVListIndex].depth + 1;
long j;
long j_start = GPtr->outVertexIndex[strWtVList[strWtVListIndex].num];
long j_stop = j_start + GPtr->outDegree[strWtVList[strWtVListIndex].num];
for (j = j_start; j < j_stop; j++) {
if (visited[GPtr->outVertexList[j]] == 0) {
visited[GPtr->outVertexList[j]] = 1;
strWtVList[t*(GPtr->numVertices)+verticesVisited].num =
GPtr->outVertexList[j];
strWtVList[t*(GPtr->numVertices)+verticesVisited].depth =
depth;
verticesVisited++;
}
}
if (currIndex < verticesVisited - 1) {
currIndex++;
depth = strWtVList[t*(GPtr->numVertices)+currIndex].depth;
} else {
break;
}
}
}
}
P_FREE(visited);
}
/* =============================================================================
* findSubGraphs2
* =============================================================================
*/
void
findSubGraphs2 (void* argPtr)
{
graph* GPtr = ((findSubGraphs2_arg_t*)argPtr)->GPtr;
Vd* intWtVDList = ((findSubGraphs2_arg_t*)argPtr)->intWtVDList;
Vd* strWtVDList = ((findSubGraphs2_arg_t*)argPtr)->strWtVDList;
edge* maxIntWtList = ((findSubGraphs2_arg_t*)argPtr)->maxIntWtList;
long maxIntWtListSize = ((findSubGraphs2_arg_t*)argPtr)->maxIntWtListSize;
edge* soughtStrWtList = ((findSubGraphs2_arg_t*)argPtr)->soughtStrWtList;
long soughtStrWtListSize = ((findSubGraphs2_arg_t*)argPtr)->soughtStrWtListSize;
long myId = thread_getId();
long numThread = thread_getNumThread();
long numSubArray = 30;
long arraySize = 5*MAX_CLUSTER_SIZE;
long i;
long i_start;
long i_stop;
createPartition(0,
(maxIntWtListSize + soughtStrWtListSize),
myId,
numThread,
&i_start,
&i_stop);
for (i = i_start; i < i_stop; i++) {
if (i < maxIntWtListSize) {
/* Initialize the DS and create one sub-array */
intWtVDList[i].numArrays = 1;
intWtVDList[i].arraySize =
(ULONGINT_T*)P_MALLOC(numSubArray * sizeof(ULONGINT_T));
assert(intWtVDList[i].arraySize);
intWtVDList[i].arraySize[0] = 0;
intWtVDList[i].vList = (V**)P_MALLOC(numSubArray*sizeof(V *));
assert(intWtVDList[i].vList);
intWtVDList[i].vList[0] = (V*)P_MALLOC(arraySize*sizeof(V));
assert(intWtVDList[i].vList[0]);
long j;
for (j = 0; j < arraySize; j++) {
intWtVDList[i].vList[0][j].num = 0;
intWtVDList[i].vList[0][j].depth = 0;
}
} else {
long t = i - maxIntWtListSize;
strWtVDList[t].numArrays = 1;
strWtVDList[t].arraySize =
(ULONGINT_T*)P_MALLOC(numSubArray * sizeof(ULONGINT_T));
assert(strWtVDList[t].arraySize);
strWtVDList[t].arraySize[0] = 0;
strWtVDList[t].vList = (V**)P_MALLOC(numSubArray * sizeof(V*));
assert(strWtVDList[t].vList);
strWtVDList[t].vList[0] = (V*)P_MALLOC(arraySize * sizeof(V));
assert(strWtVDList[t].vList[0]);
long j;
for (j = 0; j < arraySize; j++) {
strWtVDList[t].vList[0][j].num = 0;
strWtVDList[t].vList[0][j].depth = 0;
}
}
}
thread_barrier_wait();
char* visited = (char*)P_MALLOC(GPtr->numVertices * sizeof(char));
assert(visited);
/*
* Each thread runs a BFS from endvertex of maxIntWtList edgeList
*/
for (i = i_start; i < i_stop; i++) {
unsigned long k;
for (k = 0; k < GPtr->numVertices; k++) {
visited[k] = 'u';
}
if (i < maxIntWtListSize) {
intWtVDList[i].vList[0][0].num = maxIntWtList[i].startVertex;
intWtVDList[i].vList[0][0].depth = -1;
intWtVDList[i].vList[0][1].num = maxIntWtList[i].endVertex;
intWtVDList[i].vList[0][1].depth = 1;
intWtVDList[i].arraySize[0] = 2;
visited[intWtVDList[i].vList[0][0].num] = 'v';
visited[intWtVDList[i].vList[0][1].num] = 'v';
long depth = 1;
long verticesVisited = 2;
long currIndex = 1;
while ((depth < SUBGR_EDGE_LENGTH) ||
(verticesVisited == (long)GPtr->numVertices))
{
long currVListX = currIndex / arraySize;
long currVListY = currIndex % arraySize;
V* currV = &intWtVDList[i].vList[currVListX][currVListY];
long vNum = currV->num;
depth = currV->depth + 1;
long j;
long j_start = GPtr->outVertexIndex[vNum];
long j_stop = j_start + GPtr->outDegree[vNum];
for (j = j_start; j < j_stop; j++) {
if (visited[GPtr->outVertexList[j]] == 'u') {
visited[GPtr->outVertexList[j]] = 'v';
long vListX = verticesVisited/arraySize;
long vListY = verticesVisited % arraySize;
V* v = &intWtVDList[i].vList[vListX][vListY];
v->num = GPtr->outVertexList[j];
v->depth = depth;
intWtVDList[i].arraySize[vListX]++;
verticesVisited++;
}
}
/* Check if we need to create a new array */
if (((float) verticesVisited / (float) arraySize) > 0.5) {
/* create a new sub-array */
if (intWtVDList[i].numArrays !=
(unsigned long)(verticesVisited/arraySize + 2))
{
intWtVDList[i].numArrays++;
intWtVDList[i].vList[intWtVDList[i].numArrays-1] =
(V*)P_MALLOC(arraySize * sizeof(V));
assert(intWtVDList[i].vList[intWtVDList[i].numArrays-1]);
intWtVDList[i].arraySize[intWtVDList[i].numArrays-1] = 0;
}
}
if ((currIndex < verticesVisited - 1) &&
(verticesVisited < (long)GPtr->numVertices))
{
currIndex++;
long vListX = currIndex / arraySize;
long vListY = currIndex % arraySize;
depth = intWtVDList[i].vList[vListX][vListY].depth;
} else {
break;
}
}
} else {
long t = i - maxIntWtListSize;
strWtVDList[t].vList[0][0].num = soughtStrWtList[t].startVertex;
strWtVDList[t].vList[0][0].depth = -1;
strWtVDList[t].vList[0][1].num = soughtStrWtList[t].endVertex;
strWtVDList[t].vList[0][1].depth = 1;
strWtVDList[t].arraySize[0] = 2;
visited[strWtVDList[t].vList[0][0].num] = 'v';
visited[strWtVDList[t].vList[0][1].num] = 'v';
long depth = 1;
long verticesVisited = 2;
long currIndex = 1;
while ((depth < SUBGR_EDGE_LENGTH) ||
(verticesVisited == (long)GPtr->numVertices))
{
long currVListX = currIndex / arraySize;
long currVListY = currIndex % arraySize;
V* currV = &strWtVDList[t].vList[currVListX][currVListY];
long vNum = currV->num;
depth = currV->depth + 1;
long j;
long j_start = GPtr->outVertexIndex[vNum];
long j_stop = j_start + GPtr->outDegree[vNum];
for (j = j_start; j < j_stop; j++) {
if (visited[GPtr->outVertexList[j]] == 'u') {
visited[GPtr->outVertexList[j]] = 'v';
long vListX = verticesVisited / arraySize;
long vListY = verticesVisited % arraySize;
V* v = &strWtVDList[t].vList[vListX][vListY];
v->num = GPtr->outVertexList[j];
v->depth = depth;
strWtVDList[t].arraySize[vListX]++;
verticesVisited++;
}
}
/* Check if we need to create a new array */
if (((float)verticesVisited /(float) arraySize) > 0.5) {
/* create a new sub-array */
if (strWtVDList[t].numArrays !=
(unsigned long)(verticesVisited/arraySize + 2))
{
strWtVDList[t].numArrays++;
strWtVDList[t].vList[strWtVDList[t].numArrays-1] =
(V*)P_MALLOC(arraySize * sizeof(V));
assert(strWtVDList[t].vList[strWtVDList[t].numArrays-1]);
strWtVDList[t].arraySize[strWtVDList[t].numArrays-1] = 0;
}
}
if ((currIndex < verticesVisited - 1) &&
((unsigned long)verticesVisited < GPtr->numVertices))
{
currIndex++;
long currVListX = currIndex / arraySize;
long currVListY = currIndex % arraySize;
depth = strWtVDList[t].vList[currVListX][currVListY].depth;
} else {
break;
}
}
}
} /* for i */
P_FREE(visited);
}
/* =============================================================================
* findSubGraphs1
* =============================================================================
*/
void
findSubGraphs1 (void* argPtr)
{
graph* GPtr = ((findSubGraphs1_arg_t*)argPtr)->GPtr;
Vl** intWtVLList = ((findSubGraphs1_arg_t*)argPtr)->intWtVLList;
Vl** strWtVLList = ((findSubGraphs1_arg_t*)argPtr)->strWtVLList;
edge* maxIntWtList = ((findSubGraphs1_arg_t*)argPtr)->maxIntWtList;
long maxIntWtListSize = ((findSubGraphs1_arg_t*)argPtr)->maxIntWtListSize;
edge* soughtStrWtList = ((findSubGraphs1_arg_t*)argPtr)->soughtStrWtList;
long soughtStrWtListSize = ((findSubGraphs1_arg_t*)argPtr)->soughtStrWtListSize;
long myId = thread_getId();
long numThread = thread_getNumThread();
char* visited = (char*)P_MALLOC(GPtr->numVertices * sizeof(char));
assert(visited);
long i;
long i_start;
long i_stop;
createPartition(0,
(maxIntWtListSize + soughtStrWtListSize),
myId,
numThread,
&i_start,
&i_stop);
for (i = i_start; i < i_stop; i++) {
unsigned long k;
for (k = 0; k < GPtr->numVertices; k++) {
visited[k] = 'u';
}
if (i < maxIntWtListSize) {
intWtVLList[i] = (Vl*)P_MALLOC(sizeof(Vl));
assert(intWtVLList[i]);
(intWtVLList[i])->num = maxIntWtList[i].startVertex;
(intWtVLList[i])->depth = 0;
visited[(intWtVLList[i])->num] = 'v';
(intWtVLList[i])->next = (Vl*)P_MALLOC(sizeof(Vl));
P_FREE((intWtVLList[i])->next);
((intWtVLList[i])->next)->num = maxIntWtList[i].endVertex;
((intWtVLList[i])->next)->depth = 1;
visited[((intWtVLList[i])->next)->num] = 'v';
Vl* currV = (intWtVLList[i])->next;
Vl* startV = (intWtVLList[i])->next;
long depth = 1;
long verticesVisited = 2;
long currIndex = 1;
while ((startV->depth < SUBGR_EDGE_LENGTH) ||
(verticesVisited == (long)GPtr->numVertices))
{
depth = startV->depth + 1;
long j;
long j_start = GPtr->outVertexIndex[startV->num];
long j_stop = j_start + GPtr->outDegree[startV->num];
for (j = j_start; j < j_stop; j++) {
if (visited[GPtr->outVertexList[j]] == 'u') {
visited[GPtr->outVertexList[j]] = 'v';
currV->next = (Vl*)P_MALLOC(sizeof(Vl));
assert(currV->next);
(currV->next)->num = GPtr->outVertexList[j];
(currV->next)->depth = depth;
verticesVisited++;
currV = currV->next;
}
}
if ((currIndex < verticesVisited - 1) &&
(verticesVisited < (long)GPtr->numVertices))
{
currIndex++;
startV = startV->next;
} else {
break;
}
}
currV->next = NULL;
} else {
long t = i - maxIntWtListSize;
strWtVLList[t] = (Vl*)P_MALLOC(sizeof(Vl));
assert(strWtVLList[t]);
(strWtVLList[t])->num = soughtStrWtList[t].startVertex;
(strWtVLList[t])->depth = 0;
visited[(strWtVLList[t])->num] = 'v';
(strWtVLList[t])->next = (Vl*)P_MALLOC(sizeof(Vl));
assert((strWtVLList[t])->next);
((strWtVLList[t])->next)->num = soughtStrWtList[t].endVertex;
((strWtVLList[t])->next)->depth = 1;
visited[((strWtVLList[t])->next)->num] = 'v';
Vl* currV = (strWtVLList[t])->next;
Vl* startV = (strWtVLList[t])->next;
long depth = 1;
long verticesVisited = 2;
long currIndex = 1;
while ((startV->depth < SUBGR_EDGE_LENGTH) ||
(verticesVisited == (long)GPtr->numVertices))
{
depth = startV->depth + 1;
long j;
long j_start = GPtr->outVertexIndex[startV->num];
long j_stop = j_start + GPtr->outDegree[startV->num];
for (j = j_start; j < j_stop; j++) {
if (visited[GPtr->outVertexList[j]] == 'u') {
visited[GPtr->outVertexList[j]] = 'v';
currV->next = (Vl*)P_MALLOC(sizeof(Vl));
assert(currV->next);
(currV->next)->num = GPtr->outVertexList[j];
(currV->next)->depth = depth;
verticesVisited++;
currV = currV->next;
}
}
if ((currIndex < verticesVisited - 1) &&
(verticesVisited < (long)GPtr->numVertices))
{
currIndex++;
startV = startV->next;
} else {
break;
}
}
currV->next = NULL;
}
} /* for i */
P_FREE(visited);
}
/* =============================================================================
* genScalData
* =============================================================================
*/
void
genScalData (void* argPtr)
{
TM_THREAD_ENTER();
graphSDG* SDGdataPtr = (graphSDG*)argPtr;
long myId = thread_getId();
long numThread = thread_getNumThread();
/*
* STEP 0: Create the permutations required to randomize the vertices
*/
random_t* stream = PRANDOM_ALLOC();
assert(stream);
PRANDOM_SEED(stream, myId);
ULONGINT_T* permV; /* the vars associated with the graph tuple */
if (myId == 0) {
permV = (ULONGINT_T*)P_MALLOC(TOT_VERTICES * sizeof(ULONGINT_T));
assert(permV);
global_permV = permV;
}
thread_barrier_wait();
permV = global_permV;
long i;
long i_start;
long i_stop;
createPartition(0, TOT_VERTICES, myId, numThread, &i_start, &i_stop);
/* Initialize the array */
for (i = i_start; i < i_stop; i++) {
permV[i] = i;
}
thread_barrier_wait();
for (i = i_start; i < i_stop; i++) {
long t1 = PRANDOM_GENERATE(stream);
long t = i + t1 % (TOT_VERTICES - i);
if (t != i) {
AL_LOCK(0);
TM_BEGIN();
long t2 = (long)TM_SHARED_READ(permV[t]);
TM_SHARED_WRITE(permV[t], TM_SHARED_READ(permV[i]));
TM_SHARED_WRITE(permV[i], t2);
TM_END();
}
}
/*
* STEP 1: Create Cliques
*/
long* cliqueSizes;
long estTotCliques = ceil(1.5 * TOT_VERTICES / ((1+MAX_CLIQUE_SIZE)/2));
/*
* Allocate mem for Clique array
* Estimate number of clique required and pad by 50%
*/
if (myId == 0) {
cliqueSizes = (long*)P_MALLOC(estTotCliques * sizeof(long));
assert(cliqueSizes);
global_cliqueSizes = cliqueSizes;
}
thread_barrier_wait();
cliqueSizes = global_cliqueSizes;
createPartition(0, estTotCliques, myId, numThread, &i_start, &i_stop);
/* Generate random clique sizes. */
for (i = i_start; i < i_stop; i++) {
cliqueSizes[i] = 1 + (PRANDOM_GENERATE(stream) % MAX_CLIQUE_SIZE);
}
thread_barrier_wait();
long totCliques = 0;
/*
* Allocate memory for cliqueList
*/
ULONGINT_T* lastVsInCliques;
ULONGINT_T* firstVsInCliques;
if (myId == 0) {
lastVsInCliques = (ULONGINT_T*)P_MALLOC(estTotCliques * sizeof(ULONGINT_T));
assert(lastVsInCliques);
global_lastVsInCliques = lastVsInCliques;
firstVsInCliques = (ULONGINT_T*)P_MALLOC(estTotCliques * sizeof(ULONGINT_T));
assert(firstVsInCliques);
global_firstVsInCliques = firstVsInCliques;
/*
* Sum up vertices in each clique to determine the lastVsInCliques array
*/
lastVsInCliques[0] = cliqueSizes[0] - 1;
for (i = 1; i < estTotCliques; i++) {
lastVsInCliques[i] = cliqueSizes[i] + lastVsInCliques[i-1];
if (lastVsInCliques[i] >= TOT_VERTICES-1) {
break;
}
}
totCliques = i + 1;
global_totCliques = totCliques;
/*
* Fix the size of the last clique
*/
cliqueSizes[totCliques-1] =
TOT_VERTICES - lastVsInCliques[totCliques-2] - 1;
lastVsInCliques[totCliques-1] = TOT_VERTICES - 1;
firstVsInCliques[0] = 0;
}
thread_barrier_wait();
lastVsInCliques = global_lastVsInCliques;
firstVsInCliques = global_firstVsInCliques;
totCliques = global_totCliques;
/* Compute start Vertices in cliques. */
createPartition(1, totCliques, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
firstVsInCliques[i] = lastVsInCliques[i-1] + 1;
}
#ifdef WRITE_RESULT_FILES
thread_barrier_wait();
/* Write the generated cliques to file for comparison with Kernel 4 */
if (myId == 0) {
FILE* outfp = fopen("cliques.txt", "w");
fprintf(outfp, "No. of cliques - %lu\n", totCliques);
for (i = 0; i < totCliques; i++) {
fprintf(outfp, "Clq %lu - ", i);
long j;
for (j = firstVsInCliques[i]; j <= lastVsInCliques[i]; j++) {
fprintf(outfp, "%lu ", permV[j]);
}
fprintf(outfp, "\n");
}
fclose(outfp);
}
thread_barrier_wait();
#endif
/*
* STEP 2: Create the edges within the cliques
*/
/*
* Estimate number of edges - using an empirical measure
*/
long estTotEdges;
if (SCALE >= 12) {
estTotEdges = ceil(((MAX_CLIQUE_SIZE-1) * TOT_VERTICES));
} else {
estTotEdges = ceil(1.2 * (((MAX_CLIQUE_SIZE-1)*TOT_VERTICES)
* ((1 + MAX_PARAL_EDGES)/2) + TOT_VERTICES*2));
}
/*
* Initialize edge counter
*/
long i_edgePtr = 0;
float p = PROB_UNIDIRECTIONAL;
/*
* Partial edgeLists
*/
ULONGINT_T* startV;
ULONGINT_T* endV;
if (numThread > 3) {
long numByte = 1.5 * (estTotEdges/numThread) * sizeof(ULONGINT_T);
startV = (ULONGINT_T*)P_MALLOC(numByte);
endV = (ULONGINT_T*)P_MALLOC(numByte);
} else {
long numByte = (estTotEdges/numThread) * sizeof(ULONGINT_T);
startV = (ULONGINT_T*)P_MALLOC(numByte);
endV = (ULONGINT_T*)P_MALLOC(numByte);
}
assert(startV);
assert(endV);
/*
* Tmp array to keep track of the no. of parallel edges in each direction
*/
ULONGINT_T** tmpEdgeCounter =
(ULONGINT_T**)P_MALLOC(MAX_CLIQUE_SIZE * sizeof(ULONGINT_T *));
assert(tmpEdgeCounter);
for (i = 0; i < MAX_CLIQUE_SIZE; i++) {
tmpEdgeCounter[i] =
(ULONGINT_T*)P_MALLOC(MAX_CLIQUE_SIZE * sizeof(ULONGINT_T));
assert(tmpEdgeCounter[i]);
}
/*
* Create edges in parallel
*/
long i_clique;
createPartition(0, totCliques, myId, numThread, &i_start, &i_stop);
for (i_clique = i_start; i_clique < i_stop; i_clique++) {
/*
* Get current clique parameters
*/
long i_cliqueSize = cliqueSizes[i_clique];
long i_firstVsInClique = firstVsInCliques[i_clique];
/*
* First create at least one edge between two vetices in a clique
*/
for (i = 0; i < i_cliqueSize; i++) {
long j;
for (j = 0; j < i; j++) {
float r = (float)(PRANDOM_GENERATE(stream) % 1000) / (float)1000;
if (r >= p) {
startV[i_edgePtr] = i + i_firstVsInClique;
endV[i_edgePtr] = j + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[i][j] = 1;
startV[i_edgePtr] = j + i_firstVsInClique;
endV[i_edgePtr] = i + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[j][i] = 1;
} else if (r >= 0.5) {
startV[i_edgePtr] = i + i_firstVsInClique;
endV[i_edgePtr] = j + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[i][j] = 1;
tmpEdgeCounter[j][i] = 0;
} else {
startV[i_edgePtr] = j + i_firstVsInClique;
endV[i_edgePtr] = i + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[j][i] = 1;
tmpEdgeCounter[i][j] = 0;
}
} /* for j */
} /* for i */
if (i_cliqueSize != 1) {
long randNumEdges = (long)(PRANDOM_GENERATE(stream)
% (2*i_cliqueSize*MAX_PARAL_EDGES));
long i_paralEdge;
for (i_paralEdge = 0; i_paralEdge < randNumEdges; i_paralEdge++) {
i = (PRANDOM_GENERATE(stream) % i_cliqueSize);
long j = (PRANDOM_GENERATE(stream) % i_cliqueSize);
if ((i != j) && (tmpEdgeCounter[i][j] < MAX_PARAL_EDGES)) {
float r = (float)(PRANDOM_GENERATE(stream) % 1000) / (float)1000;
if (r >= p) {
/* Copy to edge structure. */
startV[i_edgePtr] = i + i_firstVsInClique;
endV[i_edgePtr] = j + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[i][j]++;
}
}
}
}
} /* for i_clique */
for (i = 0; i < MAX_CLIQUE_SIZE; i++) {
P_FREE(tmpEdgeCounter[i]);
}
P_FREE(tmpEdgeCounter);
/*
* Merge partial edge lists
*/
ULONGINT_T* i_edgeStartCounter;
ULONGINT_T* i_edgeEndCounter;
if (myId == 0) {
i_edgeStartCounter = (ULONGINT_T*)P_MALLOC(numThread * sizeof(ULONGINT_T));
assert(i_edgeStartCounter);
global_i_edgeStartCounter = i_edgeStartCounter;
i_edgeEndCounter = (ULONGINT_T*)P_MALLOC(numThread * sizeof(ULONGINT_T));
assert(i_edgeEndCounter);
global_i_edgeEndCounter = i_edgeEndCounter;
}
thread_barrier_wait();
i_edgeStartCounter = global_i_edgeStartCounter;
i_edgeEndCounter = global_i_edgeEndCounter;
i_edgeEndCounter[myId] = i_edgePtr;
i_edgeStartCounter[myId] = 0;
thread_barrier_wait();
if (myId == 0) {
for (i = 1; i < numThread; i++) {
i_edgeEndCounter[i] = i_edgeEndCounter[i-1] + i_edgeEndCounter[i];
i_edgeStartCounter[i] = i_edgeEndCounter[i-1];
}
}
AL_LOCK(0);
TM_BEGIN();
TM_SHARED_WRITE(global_edgeNum,
((long)TM_SHARED_READ(global_edgeNum) + i_edgePtr));
TM_END();
thread_barrier_wait();
long edgeNum = global_edgeNum;
/*
* Initialize edge list arrays
*/
ULONGINT_T* startVertex;
ULONGINT_T* endVertex;
if (myId == 0) {
if (SCALE < 10) {
long numByte = 2 * edgeNum * sizeof(ULONGINT_T);
startVertex = (ULONGINT_T*)P_MALLOC(numByte);
endVertex = (ULONGINT_T*)P_MALLOC(numByte);
} else {
long numByte = (edgeNum + MAX_PARAL_EDGES * TOT_VERTICES)
* sizeof(ULONGINT_T);
startVertex = (ULONGINT_T*)P_MALLOC(numByte);
endVertex = (ULONGINT_T*)P_MALLOC(numByte);
}
assert(startVertex);
assert(endVertex);
global_startVertex = startVertex;
global_endVertex = endVertex;
}
thread_barrier_wait();
startVertex = global_startVertex;
endVertex = global_endVertex;
for (i = i_edgeStartCounter[myId]; i < i_edgeEndCounter[myId]; i++) {
startVertex[i] = startV[i-i_edgeStartCounter[myId]];
endVertex[i] = endV[i-i_edgeStartCounter[myId]];
}
ULONGINT_T numEdgesPlacedInCliques = edgeNum;
thread_barrier_wait();
/*
* STEP 3: Connect the cliques
*/
i_edgePtr = 0;
p = PROB_INTERCL_EDGES;
/*
* Generating inter-clique edges as given in the specs
*/
createPartition(0, TOT_VERTICES, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
ULONGINT_T tempVertex1 = i;
long h = totCliques;
long l = 0;
long t = -1;
while (h - l > 1) {
long m = (h + l) / 2;
if (tempVertex1 >= firstVsInCliques[m]) {
l = m;
} else {
if ((tempVertex1 < firstVsInCliques[m]) && (m > 0)) {
if (tempVertex1 >= firstVsInCliques[m-1]) {
t = m - 1;
break;
} else {
h = m;
}
}
}
}
if (t == -1) {
long m;
for (m = (l + 1); m < h; m++) {
if (tempVertex1<firstVsInCliques[m]) {
break;
}
}
t = m-1;
}
long t1 = firstVsInCliques[t];
ULONGINT_T d;
for (d = 1, p = PROB_INTERCL_EDGES; d < TOT_VERTICES; d *= 2, p /= 2) {
float r = (float)(PRANDOM_GENERATE(stream) % 1000) / (float)1000;
if (r <= p) {
ULONGINT_T tempVertex2 = (i+d) % TOT_VERTICES;
h = totCliques;
l = 0;
t = -1;
while (h - l > 1) {
long m = (h + l) / 2;
if (tempVertex2 >= firstVsInCliques[m]) {
l = m;
} else {
if ((tempVertex2 < firstVsInCliques[m]) && (m > 0)) {
if (firstVsInCliques[m-1] <= tempVertex2) {
t = m - 1;
break;
} else {
h = m;
}
}
}
}
if (t == -1) {
long m;
for (m = (l + 1); m < h; m++) {
if (tempVertex2 < firstVsInCliques[m]) {
break;
}
}
t = m - 1;
}
long t2 = firstVsInCliques[t];
if (t1 != t2) {
long randNumEdges =
PRANDOM_GENERATE(stream) % MAX_PARAL_EDGES + 1;
long j;
for (j = 0; j < randNumEdges; j++) {
startV[i_edgePtr] = tempVertex1;
endV[i_edgePtr] = tempVertex2;
i_edgePtr++;
}
}
} /* r <= p */
float r0 = (float)(PRANDOM_GENERATE(stream) % 1000) / (float)1000;
if ((r0 <= p) && (i-d>=0)) {
ULONGINT_T tempVertex2 = (i-d) % TOT_VERTICES;
h = totCliques;
l = 0;
t = -1;
while (h - l > 1) {
long m = (h + l) / 2;
if (tempVertex2 >= firstVsInCliques[m]) {
l = m;
} else {
if ((tempVertex2 < firstVsInCliques[m]) && (m > 0)) {
if (firstVsInCliques[m-1] <= tempVertex2) {
t = m - 1;
break;
} else {
h = m;
}
}
}
}
if (t == -1) {
long m;
for (m = (l + 1); m < h; m++) {
if (tempVertex2 < firstVsInCliques[m]) {
break;
}
}
t = m - 1;
}
long t2 = firstVsInCliques[t];
if (t1 != t2) {
long randNumEdges =
PRANDOM_GENERATE(stream) % MAX_PARAL_EDGES + 1;
long j;
for (j = 0; j < randNumEdges; j++) {
startV[i_edgePtr] = tempVertex1;
endV[i_edgePtr] = tempVertex2;
i_edgePtr++;
}
}
} /* r0 <= p && (i-d) > 0 */
} /* for d, p */
} /* for i */
i_edgeEndCounter[myId] = i_edgePtr;
i_edgeStartCounter[myId] = 0;
if (myId == 0) {
global_edgeNum = 0;
}
thread_barrier_wait();
if (myId == 0) {
for (i = 1; i < numThread; i++) {
i_edgeEndCounter[i] = i_edgeEndCounter[i-1] + i_edgeEndCounter[i];
i_edgeStartCounter[i] = i_edgeEndCounter[i-1];
}
}
AL_LOCK(0);
TM_BEGIN();
TM_SHARED_WRITE(global_edgeNum,
((long)TM_SHARED_READ(global_edgeNum) + i_edgePtr));
TM_END();
thread_barrier_wait();
edgeNum = global_edgeNum;
ULONGINT_T numEdgesPlacedOutside = global_edgeNum;
for (i = i_edgeStartCounter[myId]; i < i_edgeEndCounter[myId]; i++) {
startVertex[i+numEdgesPlacedInCliques] = startV[i-i_edgeStartCounter[myId]];
endVertex[i+numEdgesPlacedInCliques] = endV[i-i_edgeStartCounter[myId]];
}
thread_barrier_wait();
ULONGINT_T numEdgesPlaced = numEdgesPlacedInCliques + numEdgesPlacedOutside;
if (myId == 0) {
SDGdataPtr->numEdgesPlaced = numEdgesPlaced;
printf("Finished generating edges\n");
printf("No. of intra-clique edges - %lu\n", numEdgesPlacedInCliques);
printf("No. of inter-clique edges - %lu\n", numEdgesPlacedOutside);
printf("Total no. of edges - %lu\n", numEdgesPlaced);
P_FREE(i_edgeStartCounter);
P_FREE(i_edgeEndCounter);
P_FREE(cliqueSizes);
P_FREE(firstVsInCliques);
P_FREE(lastVsInCliques);
}
thread_barrier_wait();
P_FREE(startV);
P_FREE(endV);
/*
* STEP 4: Generate edge weights
*/
if (myId == 0) {
SDGdataPtr->intWeight =
(LONGINT_T*)P_MALLOC(numEdgesPlaced * sizeof(LONGINT_T));
assert(SDGdataPtr->intWeight);
}
thread_barrier_wait();
p = PERC_INT_WEIGHTS;
ULONGINT_T numStrWtEdges = 0;
createPartition(0, numEdgesPlaced, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
float r = (float)(PRANDOM_GENERATE(stream) % 1000) / (float)1000;
if (r <= p) {
SDGdataPtr->intWeight[i] =
1 + (PRANDOM_GENERATE(stream) % (MAX_INT_WEIGHT-1));
} else {
SDGdataPtr->intWeight[i] = -1;
numStrWtEdges++;
}
}
thread_barrier_wait();
if (myId == 0) {
long t = 0;
for (i = 0; i < numEdgesPlaced; i++) {
if (SDGdataPtr->intWeight[i] < 0) {
SDGdataPtr->intWeight[i] = -t;
t++;
}
}
}
AL_LOCK(0);
TM_BEGIN();
TM_SHARED_WRITE(global_numStrWtEdges,
((long)TM_SHARED_READ(global_numStrWtEdges) + numStrWtEdges));
TM_END();
thread_barrier_wait();
numStrWtEdges = global_numStrWtEdges;
if (myId == 0) {
SDGdataPtr->strWeight =
(char*)P_MALLOC(numStrWtEdges * MAX_STRLEN * sizeof(char));
assert(SDGdataPtr->strWeight);
}
thread_barrier_wait();
createPartition(0, numEdgesPlaced, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
if (SDGdataPtr->intWeight[i] <= 0) {
long j;
for (j = 0; j < MAX_STRLEN; j++) {
SDGdataPtr->strWeight[(-SDGdataPtr->intWeight[i])*MAX_STRLEN+j] =
(char) (1 + PRANDOM_GENERATE(stream) % 127);
}
}
}
/*
* Choose SOUGHT STRING randomly if not assigned
*/
if (myId == 0) {
if (strlen(SOUGHT_STRING) != MAX_STRLEN) {
SOUGHT_STRING = (char*)P_MALLOC(MAX_STRLEN * sizeof(char));
assert(SOUGHT_STRING);
}
long t = PRANDOM_GENERATE(stream) % numStrWtEdges;
long j;
for (j = 0; j < MAX_STRLEN; j++) {
SOUGHT_STRING[j] =
(char) ((long) SDGdataPtr->strWeight[t*MAX_STRLEN+j]);
}
}
thread_barrier_wait();
/*
* STEP 5: Permute Vertices
*/
for (i = i_start; i < i_stop; i++) {
startVertex[i] = permV[(startVertex[i])];
endVertex[i] = permV[(endVertex[i])];
}
thread_barrier_wait();
/*
* STEP 6: Sort Vertices
*/
/*
* Radix sort with StartVertex as primary key
*/
if (myId == 0) {
long numByte = numEdgesPlaced * sizeof(ULONGINT_T);
SDGdataPtr->startVertex = (ULONGINT_T*)P_MALLOC(numByte);
assert(SDGdataPtr->startVertex);
SDGdataPtr->endVertex = (ULONGINT_T*)P_MALLOC(numByte);
assert(SDGdataPtr->endVertex);
}
thread_barrier_wait();
all_radixsort_node_aux_s3(numEdgesPlaced,
startVertex,
SDGdataPtr->startVertex,
endVertex,
SDGdataPtr->endVertex);
thread_barrier_wait();
if (myId == 0) {
P_FREE(startVertex);
P_FREE(endVertex);
}
thread_barrier_wait();
if (SCALE < 12) {
/*
* Sort with endVertex as secondary key
*/
if (myId == 0) {
long i0 = 0;
long i1 = 0;
i = 0;
while (i < numEdgesPlaced) {
for (i = i0; i < numEdgesPlaced; i++) {
if (SDGdataPtr->startVertex[i] !=
SDGdataPtr->startVertex[i1])
{
i1 = i;
break;
}
}
long j;
for (j = i0; j < i1; j++) {
long k;
for (k = j+1; k < i1; k++) {
if (SDGdataPtr->endVertex[k] <
SDGdataPtr->endVertex[j])
{
long t = SDGdataPtr->endVertex[j];
SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k];
SDGdataPtr->endVertex[k] = t;
}
}
}
if (SDGdataPtr->startVertex[i0] != TOT_VERTICES-1) {
i0 = i1;
} else {
long j;
for (j=i0; j<numEdgesPlaced; j++) {
long k;
for (k=j+1; k<numEdgesPlaced; k++) {
if (SDGdataPtr->endVertex[k] <
SDGdataPtr->endVertex[j])
{
long t = SDGdataPtr->endVertex[j];
SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k];
SDGdataPtr->endVertex[k] = t;
}
}
}
}
} /* while i < numEdgesPlaced */
}
} else {
ULONGINT_T* tempIndex;
if (myId == 0) {
tempIndex =
(ULONGINT_T*)P_MALLOC((TOT_VERTICES + 1) * sizeof(ULONGINT_T));
assert(tempIndex);
global_tempIndex = tempIndex;
/*
* Update degree of each vertex
*/
tempIndex[0] = 0;
tempIndex[TOT_VERTICES] = numEdgesPlaced;
long i0 = 0;
for (i=0; i < TOT_VERTICES; i++) {
tempIndex[i+1] = tempIndex[i];
long j;
for (j = i0; j < numEdgesPlaced; j++) {
if (SDGdataPtr->startVertex[j] !=
SDGdataPtr->startVertex[i0])
{
if (SDGdataPtr->startVertex[i0] == i) {
tempIndex[i+1] = j;
i0 = j;
break;
}
}
}
}
}
thread_barrier_wait();
tempIndex = global_tempIndex;
/*
* Insertion sort for now, replace with something better later on
*/
#if 0
createPartition(0, TOT_VERTICES, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
long j;
for (j = tempIndex[i]; j < tempIndex[i+1]; j++) {
long k;
for (k = (j + 1); k < tempIndex[i+1]; k++) {
if (SDGdataPtr->endVertex[k] <
SDGdataPtr->endVertex[j])
{
long t = SDGdataPtr->endVertex[j];
SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k];
SDGdataPtr->endVertex[k] = t;
}
}
}
}
#else
if (myId == 0) {
for (i = 0; i < TOT_VERTICES; i++) {
long j;
for (j = tempIndex[i]; j < tempIndex[i+1]; j++) {
long k;
for (k = (j + 1); k < tempIndex[i+1]; k++) {
if (SDGdataPtr->endVertex[k] <
SDGdataPtr->endVertex[j])
{
long t = SDGdataPtr->endVertex[j];
SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k];
SDGdataPtr->endVertex[k] = t;
}
}
}
}
}
#endif
if (myId == 0) {
P_FREE(tempIndex);
}
} /* SCALE >= 12 */
PRANDOM_FREE(stream);
if (myId == 0) {
P_FREE(permV);
}
TM_THREAD_EXIT();
}
/* =============================================================================
* computeGraph
* =============================================================================
*/
void
computeGraph (void* argPtr)
{
TM_THREAD_ENTER();
graph* GPtr = ((computeGraph_arg_t*)argPtr)->GPtr;
graphSDG* SDGdataPtr = ((computeGraph_arg_t*)argPtr)->SDGdataPtr;
long myId = thread_getId();
long numThread = thread_getNumThread();
ULONGINT_T j;
ULONGINT_T maxNumVertices = 0;
ULONGINT_T numEdgesPlaced = SDGdataPtr->numEdgesPlaced;
/*
* First determine the number of vertices by scanning the tuple
* startVertex list
*/
long i;
long i_start;
long i_stop;
createPartition(0, numEdgesPlaced, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
if (SDGdataPtr->startVertex[i] > maxNumVertices) {
maxNumVertices = SDGdataPtr->startVertex[i];
}
}
TM_BEGIN();
long tmp_maxNumVertices = (long)TM_SHARED_READ_L(global_maxNumVertices);
long new_maxNumVertices = MAX(tmp_maxNumVertices, maxNumVertices) + 1;
TM_SHARED_WRITE_L(global_maxNumVertices, new_maxNumVertices);
TM_END();
thread_barrier_wait();
maxNumVertices = global_maxNumVertices;
if (myId == 0) {
GPtr->numVertices = maxNumVertices;
GPtr->numEdges = numEdgesPlaced;
GPtr->intWeight = SDGdataPtr->intWeight;
GPtr->strWeight = SDGdataPtr->strWeight;
for (i = 0; i < numEdgesPlaced; i++) {
if (GPtr->intWeight[numEdgesPlaced-i-1] < 0) {
GPtr->numStrEdges = -(GPtr->intWeight[numEdgesPlaced-i-1]) + 1;
GPtr->numIntEdges = numEdgesPlaced - GPtr->numStrEdges;
break;
}
}
GPtr->outDegree =
(LONGINT_T*)P_MALLOC((GPtr->numVertices) * sizeof(LONGINT_T));
assert(GPtr->outDegree);
GPtr->outVertexIndex =
(ULONGINT_T*)P_MALLOC((GPtr->numVertices) * sizeof(ULONGINT_T));
assert(GPtr->outVertexIndex);
}
thread_barrier_wait();
createPartition(0, GPtr->numVertices, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
GPtr->outDegree[i] = 0;
GPtr->outVertexIndex[i] = 0;
}
ULONGINT_T outVertexListSize = 0;
thread_barrier_wait();
ULONGINT_T i0 = -1UL;
for (i = i_start; i < i_stop; i++) {
ULONGINT_T k = i;
if ((outVertexListSize == 0) && (k != 0)) {
while (i0 == -1UL) {
for (j = 0; j < numEdgesPlaced; j++) {
if (k == SDGdataPtr->startVertex[j]) {
i0 = j;
break;
}
}
k--;
}
}
if ((outVertexListSize == 0) && (k == 0)) {
i0 = 0;
}
for (j = i0; j < numEdgesPlaced; j++) {
if (i == GPtr->numVertices-1) {
break;
}
if ((i != SDGdataPtr->startVertex[j])) {
if ((j > 0) && (i == SDGdataPtr->startVertex[j-1])) {
if (j-i0 >= 1) {
outVertexListSize++;
GPtr->outDegree[i]++;
ULONGINT_T t;
for (t = i0+1; t < j; t++) {
if (SDGdataPtr->endVertex[t] !=
SDGdataPtr->endVertex[t-1])
{
outVertexListSize++;
GPtr->outDegree[i] = GPtr->outDegree[i]+1;
}
}
}
}
i0 = j;
break;
}
}
if (i == GPtr->numVertices-1) {
if (numEdgesPlaced-i0 >= 0) {
outVertexListSize++;
GPtr->outDegree[i]++;
ULONGINT_T t;
for (t = i0+1; t < numEdgesPlaced; t++) {
if (SDGdataPtr->endVertex[t] != SDGdataPtr->endVertex[t-1]) {
outVertexListSize++;
GPtr->outDegree[i]++;
}
}
}
}
} /* for i */
thread_barrier_wait();
prefix_sums(GPtr->outVertexIndex, GPtr->outDegree, GPtr->numVertices);
thread_barrier_wait();
TM_BEGIN();
TM_SHARED_WRITE_L(
global_outVertexListSize,
((long)TM_SHARED_READ_L(global_outVertexListSize) + outVertexListSize)
);
TM_END();
thread_barrier_wait();
outVertexListSize = global_outVertexListSize;
if (myId == 0) {
GPtr->numDirectedEdges = outVertexListSize;
GPtr->outVertexList =
(ULONGINT_T*)P_MALLOC(outVertexListSize * sizeof(ULONGINT_T));
assert(GPtr->outVertexList);
GPtr->paralEdgeIndex =
(ULONGINT_T*)P_MALLOC(outVertexListSize * sizeof(ULONGINT_T));
assert(GPtr->paralEdgeIndex);
GPtr->outVertexList[0] = SDGdataPtr->endVertex[0];
}
thread_barrier_wait();
/*
* Evaluate outVertexList
*/
i0 = -1UL;
for (i = i_start; i < i_stop; i++) {
ULONGINT_T k = i;
while ((i0 == -1UL) && (k != 0)) {
for (j = 0; j < numEdgesPlaced; j++) {
if (k == SDGdataPtr->startVertex[j]) {
i0 = j;
break;
}
}
k--;
}
if ((i0 == -1) && (k == 0)) {
i0 = 0;
}
for (j = i0; j < numEdgesPlaced; j++) {
if (i == GPtr->numVertices-1) {
break;
}
if (i != SDGdataPtr->startVertex[j]) {
if ((j > 0) && (i == SDGdataPtr->startVertex[j-1])) {
if (j-i0 >= 1) {
long ii = GPtr->outVertexIndex[i];
ULONGINT_T r = 0;
GPtr->paralEdgeIndex[ii] = i0;
GPtr->outVertexList[ii] = SDGdataPtr->endVertex[i0];
r++;
ULONGINT_T t;
for (t = i0+1; t < j; t++) {
if (SDGdataPtr->endVertex[t] !=
SDGdataPtr->endVertex[t-1])
{
GPtr->paralEdgeIndex[ii+r] = t;
GPtr->outVertexList[ii+r] = SDGdataPtr->endVertex[t];
r++;
}
}
}
}
i0 = j;
break;
}
} /* for j */
if (i == GPtr->numVertices-1) {
ULONGINT_T r = 0;
if (numEdgesPlaced-i0 >= 0) {
long ii = GPtr->outVertexIndex[i];
GPtr->paralEdgeIndex[ii+r] = i0;
GPtr->outVertexList[ii+r] = SDGdataPtr->endVertex[i0];
r++;
ULONGINT_T t;
for (t = i0+1; t < numEdgesPlaced; t++) {
if (SDGdataPtr->endVertex[t] != SDGdataPtr->endVertex[t-1]) {
GPtr->paralEdgeIndex[ii+r] = t;
GPtr->outVertexList[ii+r] = SDGdataPtr->endVertex[t];
r++;
}
}
}
}
} /* for i */
thread_barrier_wait();
if (myId == 0) {
P_FREE(SDGdataPtr->startVertex);
P_FREE(SDGdataPtr->endVertex);
GPtr->inDegree =
(LONGINT_T*)P_MALLOC(GPtr->numVertices * sizeof(LONGINT_T));
assert(GPtr->inDegree);
GPtr->inVertexIndex =
(ULONGINT_T*)P_MALLOC(GPtr->numVertices * sizeof(ULONGINT_T));
assert(GPtr->inVertexIndex);
}
thread_barrier_wait();
for (i = i_start; i < i_stop; i++) {
GPtr->inDegree[i] = 0;
GPtr->inVertexIndex[i] = 0;
}
/* A temp. array to store the inplied edges */
ULONGINT_T* impliedEdgeList;
if (myId == 0) {
impliedEdgeList = (ULONGINT_T*)P_MALLOC(GPtr->numVertices
* MAX_CLUSTER_SIZE
* sizeof(ULONGINT_T));
global_impliedEdgeList = impliedEdgeList;
}
thread_barrier_wait();
impliedEdgeList = global_impliedEdgeList;
createPartition(0,
(GPtr->numVertices * MAX_CLUSTER_SIZE),
myId,
numThread,
&i_start,
&i_stop);
for (i = i_start; i < i_stop; i++) {
impliedEdgeList[i] = 0;
}
/*
* An auxiliary array to store implied edges, in case we overshoot
* MAX_CLUSTER_SIZE
*/
ULONGINT_T** auxArr;
if (myId == 0) {
auxArr = (ULONGINT_T**)P_MALLOC(GPtr->numVertices * sizeof(ULONGINT_T*));
assert(auxArr);
global_auxArr = auxArr;
}
thread_barrier_wait();
auxArr = global_auxArr;
createPartition(0, GPtr->numVertices, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
/* Inspect adjacency list of vertex i */
for (j = GPtr->outVertexIndex[i];
j < (GPtr->outVertexIndex[i] + GPtr->outDegree[i]);
j++)
{
ULONGINT_T v = GPtr->outVertexList[j];
ULONGINT_T k;
for (k = GPtr->outVertexIndex[v];
k < (GPtr->outVertexIndex[v] + GPtr->outDegree[v]);
k++)
{
if (GPtr->outVertexList[k] == i) {
break;
}
}
if (k == GPtr->outVertexIndex[v]+GPtr->outDegree[v]) {
TM_BEGIN();
/* Add i to the impliedEdgeList of v */
long inDegree = (long)TM_SHARED_READ_L(GPtr->inDegree[v]);
TM_SHARED_WRITE_L(GPtr->inDegree[v], (inDegree + 1));
if (inDegree < MAX_CLUSTER_SIZE) {
TM_SHARED_WRITE_L(impliedEdgeList[v*MAX_CLUSTER_SIZE+inDegree],
i);
} else {
/* Use auxiliary array to store the implied edge */
/* Create an array if it's not present already */
ULONGINT_T* a = NULL;
if ((inDegree % MAX_CLUSTER_SIZE) == 0) {
a = (ULONGINT_T*)TM_MALLOC(MAX_CLUSTER_SIZE
* sizeof(ULONGINT_T));
assert(a);
TM_SHARED_WRITE_P(auxArr[v], a);
} else {
a = auxArr[v];
}
TM_SHARED_WRITE_L(a[inDegree % MAX_CLUSTER_SIZE], i);
}
TM_END();
}
}
} /* for i */
thread_barrier_wait();
prefix_sums(GPtr->inVertexIndex, GPtr->inDegree, GPtr->numVertices);
if (myId == 0) {
GPtr->numUndirectedEdges = GPtr->inVertexIndex[GPtr->numVertices-1]
+ GPtr->inDegree[GPtr->numVertices-1];
GPtr->inVertexList =
(ULONGINT_T *)P_MALLOC(GPtr->numUndirectedEdges * sizeof(ULONGINT_T));
}
thread_barrier_wait();
/*
* Create the inVertex List
*/
for (i = i_start; i < i_stop; i++) {
for (j = GPtr->inVertexIndex[i];
j < (GPtr->inVertexIndex[i] + GPtr->inDegree[i]);
j++)
{
if ((j - GPtr->inVertexIndex[i]) < MAX_CLUSTER_SIZE) {
GPtr->inVertexList[j] =
impliedEdgeList[i*MAX_CLUSTER_SIZE+j-GPtr->inVertexIndex[i]];
} else {
GPtr->inVertexList[j] =
auxArr[i][(j-GPtr->inVertexIndex[i]) % MAX_CLUSTER_SIZE];
}
}
}
thread_barrier_wait();
if (myId == 0) {
P_FREE(impliedEdgeList);
}
for (i = i_start; i < i_stop; i++) {
if (GPtr->inDegree[i] > MAX_CLUSTER_SIZE) {
P_FREE(auxArr[i]);
}
}
thread_barrier_wait();
if (myId == 0) {
P_FREE(auxArr);
}
TM_THREAD_EXIT();
}
/* =============================================================================
* getStartLists
* =============================================================================
*/
void
getStartLists (void* argPtr)
{
TM_THREAD_ENTER();
graph* GPtr = ((getStartLists_arg_t*)argPtr)->GPtr;
edge** maxIntWtListPtr = ((getStartLists_arg_t*)argPtr)->maxIntWtListPtr;
long* maxIntWtListSize = ((getStartLists_arg_t*)argPtr)->maxIntWtListSize;
edge** soughtStrWtListPtr = ((getStartLists_arg_t*)argPtr)->soughtStrWtListPtr;
long* soughtStrWtListSize = ((getStartLists_arg_t*)argPtr)->soughtStrWtListSize;
long myId = thread_getId();
long numThread = thread_getNumThread();
/*
* Find Max Wt on each thread
*/
LONGINT_T maxWeight = 0;
long i;
long i_start;
long i_stop;
createPartition(0, GPtr->numEdges, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
if (GPtr->intWeight[i] > maxWeight) {
maxWeight = GPtr->intWeight[i];
}
}
AL_LOCK(0);
TM_BEGIN(9);
long tmp_maxWeight = (long)TM_SHARED_READ(global_maxWeight);
if (maxWeight > tmp_maxWeight) {
TM_SHARED_WRITE(global_maxWeight, maxWeight);
}
TM_END();
thread_barrier_wait();
maxWeight = global_maxWeight;
/*
* Create partial lists
*/
/*
* Allocate mem. for temp edge list for each thread
*/
long numTmpEdge = (5+ceil(1.5*(GPtr->numIntEdges)/MAX_INT_WEIGHT));
edge* tmpEdgeList = (edge*)P_MALLOC(numTmpEdge * sizeof(edge));
long i_edgeCounter = 0;
for (i = i_start; i < i_stop; i++) {
if (GPtr->intWeight[i] == maxWeight) {
/* Find the corresponding endVertex */
long j;
for (j = 0; j < GPtr->numDirectedEdges; j++) {
if (GPtr->paralEdgeIndex[j] > i) {
break;
}
}
tmpEdgeList[i_edgeCounter].endVertex = GPtr->outVertexList[j-1];
tmpEdgeList[i_edgeCounter].edgeNum = j-1;
long t;
for (t = 0; t < GPtr->numVertices; t++) {
if (GPtr->outVertexIndex[t] > j-1) {
break;
}
}
tmpEdgeList[i_edgeCounter].startVertex = t-1;
i_edgeCounter++;
}
}
/*
* Merge partial edge lists
*/
long* i_edgeStartCounter;
long* i_edgeEndCounter;
if (myId == 0) {
i_edgeStartCounter = (long*)P_MALLOC(numThread * sizeof(long));
assert(i_edgeStartCounter);
global_i_edgeStartCounter = i_edgeStartCounter;
i_edgeEndCounter = (long*)P_MALLOC(numThread * sizeof(long));
assert(i_edgeEndCounter);
global_i_edgeEndCounter = i_edgeEndCounter;
*maxIntWtListSize = 0;
}
thread_barrier_wait();
i_edgeStartCounter = global_i_edgeStartCounter;
i_edgeEndCounter = global_i_edgeEndCounter;
i_edgeEndCounter[myId] = i_edgeCounter;
i_edgeStartCounter[myId] = 0;
thread_barrier_wait();
if (myId == 0) {
for (i = 1; i < numThread; i++) {
i_edgeEndCounter[i] = i_edgeEndCounter[i-1] + i_edgeEndCounter[i];
i_edgeStartCounter[i] = i_edgeEndCounter[i-1];
}
}
*maxIntWtListSize += i_edgeCounter;
thread_barrier_wait();
edge* maxIntWtList;
if (myId == 0) {
P_FREE(*maxIntWtListPtr);
maxIntWtList = (edge*)P_MALLOC((*maxIntWtListSize) * sizeof(edge));
assert(maxIntWtList);
global_maxIntWtList = maxIntWtList;
}
thread_barrier_wait();
maxIntWtList = global_maxIntWtList;
for (i = i_edgeStartCounter[myId]; i<i_edgeEndCounter[myId]; i++) {
(maxIntWtList[i]).startVertex = tmpEdgeList[i-i_edgeStartCounter[myId]].startVertex;
(maxIntWtList[i]).endVertex = tmpEdgeList[i-i_edgeStartCounter[myId]].endVertex;
(maxIntWtList[i]).edgeNum = tmpEdgeList[i-i_edgeStartCounter[myId]].edgeNum;
}
if (myId == 0) {
*maxIntWtListPtr = maxIntWtList;
}
i_edgeCounter = 0;
createPartition(0, GPtr->numStrEdges, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
if (strncmp(GPtr->strWeight+i*MAX_STRLEN,
SOUGHT_STRING,
MAX_STRLEN) == 0)
{
/*
* Find the corresponding endVertex
*/
long t;
for (t = 0; t < GPtr->numEdges; t++) {
if (GPtr->intWeight[t] == -i) {
break;
}
}
long j;
for (j = 0; j < GPtr->numDirectedEdges; j++) {
if (GPtr->paralEdgeIndex[j] > t) {
break;
}
}
tmpEdgeList[i_edgeCounter].endVertex = GPtr->outVertexList[j-1];
tmpEdgeList[i_edgeCounter].edgeNum = j-1;
for (t = 0; t < GPtr->numVertices; t++) {
if (GPtr->outVertexIndex[t] > j-1) {
break;
}
}
tmpEdgeList[i_edgeCounter].startVertex = t-1;
i_edgeCounter++;
}
}
thread_barrier_wait();
i_edgeEndCounter[myId] = i_edgeCounter;
i_edgeStartCounter[myId] = 0;
if (myId == 0) {
*soughtStrWtListSize = 0;
}
thread_barrier_wait();
if (myId == 0) {
for (i = 1; i < numThread; i++) {
i_edgeEndCounter[i] = i_edgeEndCounter[i-1] + i_edgeEndCounter[i];
i_edgeStartCounter[i] = i_edgeEndCounter[i-1];
}
}
*soughtStrWtListSize += i_edgeCounter;
thread_barrier_wait();
edge* soughtStrWtList;
if (myId == 0) {
P_FREE(*soughtStrWtListPtr);
soughtStrWtList = (edge*)P_MALLOC((*soughtStrWtListSize) * sizeof(edge));
assert(soughtStrWtList);
global_soughtStrWtList = soughtStrWtList;
}
thread_barrier_wait();
soughtStrWtList = global_soughtStrWtList;
for (i = i_edgeStartCounter[myId]; i < i_edgeEndCounter[myId]; i++) {
(soughtStrWtList[i]).startVertex =
tmpEdgeList[i-i_edgeStartCounter[myId]].startVertex;
(soughtStrWtList[i]).endVertex =
tmpEdgeList[i-i_edgeStartCounter[myId]].endVertex;
(soughtStrWtList[i]).edgeNum =
tmpEdgeList[i-i_edgeStartCounter[myId]].edgeNum;
}
thread_barrier_wait();
if (myId == 0) {
*soughtStrWtListPtr = soughtStrWtList;
P_FREE(i_edgeStartCounter);
P_FREE(i_edgeEndCounter);
}
P_FREE(tmpEdgeList);
TM_THREAD_EXIT();
}
/* =============================================================================
* cutClusters
* =============================================================================
*/
void
cutClusters (void* argPtr)
{
TM_THREAD_ENTER();
graph* GPtr = (graph*)argPtr;
long myId = thread_getId();
long numThread = thread_getNumThread();
/*
* Sort the vertex list by their degree
*/
ULONGINT_T* Index;
ULONGINT_T* neighbourArray;
ULONGINT_T* IndexSorted;
ULONGINT_T* neighbourArraySorted;
if (myId == 0) {
long numByte = GPtr->numVertices * sizeof(ULONGINT_T);
Index = (ULONGINT_T*)P_MALLOC(numByte);
assert(Index);
global_Index = Index;
neighbourArray = (ULONGINT_T*)P_MALLOC(numByte);
assert(neighbourArray);
global_neighbourArray = neighbourArray;
IndexSorted = (ULONGINT_T*)P_MALLOC(numByte);
assert(IndexSorted);
global_IndexSorted = IndexSorted;
neighbourArraySorted = (ULONGINT_T*)P_MALLOC(numByte);
assert(neighbourArraySorted);
global_neighbourArraySorted = neighbourArraySorted;
}
thread_barrier_wait();
Index = global_Index;
neighbourArray = global_neighbourArray;
IndexSorted = global_IndexSorted;
neighbourArraySorted = global_neighbourArraySorted;
long i;
long i_start;
long i_stop;
createPartition(0, GPtr->numVertices, myId, numThread, &i_start, &i_stop);
for (i = i_start; i < i_stop; i++) {
neighbourArray[i] = GPtr->inDegree[i] + GPtr->outDegree[i];
Index[i] = i;
}
thread_barrier_wait();
all_radixsort_node_aux_s3(GPtr->numVertices,
neighbourArray,
neighbourArraySorted,
Index,
IndexSorted);
thread_barrier_wait();
/*
* Global array to keep track of vertex status:
* -1 if a vertex hasn't been assigned to a cluster yet
* t if it belongs to a cluster; t = iteration*numThread + myId
*/
long* vStatus;
edge* pCutSet;
ULONGINT_T* startV;
ULONGINT_T* clusterSize;
if (myId == 0) {
P_FREE(Index);
P_FREE(neighbourArray);
vStatus = (long*)P_MALLOC(GPtr->numVertices * sizeof(long));
assert(vStatus);
global_vStatus = vStatus;
/*
* Allocate mem. for the cut set list
* Maintain local arrays initially and merge them in the end
*/
if (SCALE < 12) {
pCutSet =(edge*)P_MALLOC((1*(GPtr->numDirectedEdges)/numThread)
* sizeof(edge));
} else {
pCutSet = (edge*)P_MALLOC((0.2*(GPtr->numDirectedEdges)/numThread)
* sizeof(edge));
}
assert(pCutSet);
global_pCutSet = pCutSet;
/*
* Vertex to start from, on each thread
*/
startV = (ULONGINT_T*)P_MALLOC(numThread * sizeof(ULONGINT_T));
assert(startV);
global_startV = startV;
clusterSize = (ULONGINT_T*)P_MALLOC(numThread * sizeof(ULONGINT_T));
assert(clusterSize);
global_clusterSize = clusterSize;
}
thread_barrier_wait();
vStatus = global_vStatus;
pCutSet = global_pCutSet;
startV = global_startV;
clusterSize = global_clusterSize;
for (i = i_start; i < i_stop; i++) {
vStatus[i] = -1;
}
thread_barrier_wait();
ULONGINT_T verticesVisited = 0;
#ifdef WRITE_RESULT_FILES
FILE* outfp1 = NULL;
if (myId == 0) {
outfp1 = fopen("clusters.txt", "w");
fprintf(outfp1, "\nKernel 4 - Extracted Clusters\n");
}
#endif
long iter = 0;
ULONGINT_T currIndex = 0;
ULONGINT_T cutSetIndex = 0;
while (verticesVisited < GPtr->numVertices) {
/* Clear start vertex array */
startV[myId] = -1;
clusterSize[myId] = 0;
if (currIndex == GPtr->numVertices) {
currIndex = 0;
}
thread_barrier_wait();
/*
* Choose vertices to start from
* Done sequentially right now, can be parallelized
*/
if (myId == 0) {
long t;
for (t = 0; t < numThread; t++) {
long r;
for (r = currIndex; r < GPtr->numVertices; r++) {
if (vStatus[IndexSorted[GPtr->numVertices - r - 1]] == -1) {
startV[t] = IndexSorted[GPtr->numVertices - r - 1];
vStatus[startV[t]] = iter * numThread + t;
long j;
for (j = 0; j < GPtr->outDegree[startV[t]]; j++) {
long outVertexListIndex =
j+GPtr->outVertexIndex[startV[t]];
long vStatusIndex =
GPtr->outVertexList[outVertexListIndex];
if (vStatus[vStatusIndex] == -1) {
vStatus[vStatusIndex] = iter * numThread + t;
clusterSize[t]++;
}
}
for (j = 0; j < GPtr->inDegree[startV[t]]; j++) {
long inVertexIndex = j+GPtr->inVertexIndex[startV[t]];
long vStatusIndex = GPtr->inVertexList[inVertexIndex];
if (vStatus[vStatusIndex] == -1) {
vStatus[vStatusIndex] = iter * numThread + t;
clusterSize[t]++;
}
}
currIndex = r+1;
break;
}
}
}
}
thread_barrier_wait();
/*
* Determine clusters and cut sets in parallel
*/
i = startV[myId];
ULONGINT_T cliqueSize = 0;
/* If the thread has some vertex to start from */
if (i != -1) {
cliqueSize = 1;
/* clusterSize[myId] gives the no. of 'unassigned' vertices adjacent to the current vertex */
if ((clusterSize[myId] >= 0.6*(GPtr->inDegree[i]+GPtr->outDegree[i])) ||
((iter > (GPtr->numVertices)/(numThread*MAX_CLUSTER_SIZE)) &&
(clusterSize[myId] > 0)))
{
/*
* Most of the adjacent vertices are unassigned,
* should be able to extract a cluster easily
*/
/* Inspect adjacency list */
long j;
for (j = 0; j < GPtr->outDegree[i]; j++) {
ULONGINT_T clusterCounter = 0;
ULONGINT_T cutSetIndexPrev = cutSetIndex;
ULONGINT_T cutSetCounter = 0;
if (vStatus[GPtr->outVertexList[j+GPtr->outVertexIndex[i]]] ==
iter * numThread + myId)
{
long v = GPtr->outVertexList[j+GPtr->outVertexIndex[i]];
/*
* Inspect vertices adjacent to v and determine if it belongs
* to a cluster or not
*/
long k;
for (k = 0; k < GPtr->outDegree[v]; k++) {
long outVertexListIndex = k+GPtr->outVertexIndex[v];
long vStatusIndex = GPtr->outVertexList[outVertexListIndex];
if (vStatus[vStatusIndex] == (iter * numThread + myId)) {
clusterCounter++;
} else {
cutSetCounter++;
if (vStatus[vStatusIndex] == -1) {
/* Ensure that an edge is not added twice to the list */
pCutSet[cutSetIndex].startVertex = v;
pCutSet[cutSetIndex].endVertex = vStatusIndex;
cutSetIndex++;
}
}
}
if ((cutSetCounter >= clusterCounter) ||
((SCALE < 9) &&
(clusterCounter <= 2) &&
(GPtr->inDegree[v]+GPtr->outDegree[v] >
clusterCounter + cutSetCounter) &&
(clusterSize[myId] > clusterCounter + 2)) ||
((SCALE > 9) &&
(clusterCounter < 0.5*clusterSize[myId])))
{
/* v doesn't belong to this clique, free it */
vStatus[v] = -1;
/* Also add this edge to cutset list, removing previously added edges */
cutSetIndex = cutSetIndexPrev;
pCutSet[cutSetIndex].startVertex = i;
pCutSet[cutSetIndex].endVertex = v;
cutSetIndex++;
} else {
cliqueSize++;
/* Add edges in inVertexList also to cut Set */
for (k = 0; k < GPtr->inDegree[v]; k++) {
long inVertexListIndex = k+GPtr->inVertexIndex[v];
long vStatusIndex = GPtr->inVertexList[inVertexListIndex];
if (vStatus[vStatusIndex] == -1) {
pCutSet[cutSetIndex].startVertex = v;
pCutSet[cutSetIndex].endVertex = vStatusIndex;
cutSetIndex++;
}
}
}
}
}
/* Do the same for the implied edges too */
for (j = 0; j < GPtr->inDegree[i]; j++) {
ULONGINT_T clusterCounter = 0;
ULONGINT_T cutSetIndexPrev = cutSetIndex;
ULONGINT_T cutSetCounter = 0;
if (vStatus[GPtr->inVertexList[j+GPtr->inVertexIndex[i]]] ==
iter*numThread+myId)
{
long v = GPtr->inVertexList[j+GPtr->inVertexIndex[i]];
/* Inspect vertices adjacent to v and determine if it belongs to a cluster or not */
long k;
for (k = 0; k < GPtr->outDegree[v]; k++) {
long outVertexListIndex = k+GPtr->outVertexIndex[v];
long vStatusIndex = GPtr->outVertexList[outVertexListIndex];
if (vStatus[vStatusIndex] == iter*numThread+myId) {
clusterCounter++;
} else {
cutSetCounter++;
if (vStatus[vStatusIndex] == -1) {
/* To ensure that an edge is not added twice to the list */
pCutSet[cutSetIndex].startVertex = v;
pCutSet[cutSetIndex].endVertex = vStatusIndex;
cutSetIndex++;
}
}
}
if ((cutSetCounter >= clusterCounter) ||
((SCALE < 9) &&
(clusterCounter <= 2) &&
(GPtr->inDegree[v]+GPtr->outDegree[v] >
clusterCounter + cutSetCounter) &&
(clusterSize[myId] > clusterCounter + 2)) ||
((SCALE > 9) &&
(clusterCounter < 0.5*clusterSize[myId])))
{
/* v doesn't belong to this clique, free it */
vStatus[v] = -1;
cutSetIndex = cutSetIndexPrev;
pCutSet[cutSetIndex].startVertex = i;
pCutSet[cutSetIndex].endVertex = v;
cutSetIndex++;
} else {
cliqueSize++;
/* Add edges in inVertexList also to cut Set */
for (k = 0; k < GPtr->inDegree[v]; k++) {
long inVertexListIndex = k+GPtr->inVertexIndex[v];
long vStatusIndex = GPtr->inVertexList[inVertexListIndex];
if (vStatus[vStatusIndex] == -1) {
pCutSet[cutSetIndex].startVertex = v;
pCutSet[cutSetIndex].endVertex = vStatusIndex;
cutSetIndex++;
}
}
}
}
}
} /* i != -1 */
if (clusterSize[myId] == 0) {
/* Only one vertex in cluster */
cliqueSize = 1;
} else {
if ((clusterSize[myId] < 0.6*(GPtr->inDegree[i]+GPtr->outDegree[i])) &&
(iter <= GPtr->numVertices/(numThread*MAX_CLUSTER_SIZE)))
{
/* High perc. of intra-clique edges, do not commit clique */
cliqueSize = 0;
vStatus[i] = -1;
long j;
for (j=0; j<GPtr->outDegree[i]; j++) {
long outVertexListIndex = j+GPtr->outVertexIndex[i];
long vStatusIndex = GPtr->outVertexList[outVertexListIndex];
if (vStatus[vStatusIndex] == iter*numThread+myId) {
vStatus[vStatusIndex] = -1;
}
}
for (j=0; j<GPtr->inDegree[i]; j++) {
long inVertexListIndex = j+GPtr->inVertexIndex[i];
long vStatusIndex = GPtr->inVertexList[inVertexListIndex];
if (vStatus[vStatusIndex] == iter*numThread+myId) {
vStatus[vStatusIndex] = -1;
}
}
}
}
} /* if i != -1 */
if (myId == 0) {
global_cliqueSize = 0;
}
thread_barrier_wait();
#ifdef WRITE_RESULT_FILES
/* Print to results.clq file */
if (myId == 0) {
long t;
for (t = 0; t < numThread; t++) {
if (startV[t] != -1) {
if (vStatus[startV[t]] == iter*numThread+t) {
fprintf(outfp1, "%lu ", startV[t]);
long j;
for (j = 0; j < GPtr->outDegree[startV[t]]; j++) {
long outVertexListIndex = j+GPtr->outVertexIndex[startV[t]];
long vStatusIndex = GPtr->outVertexList[outVertexListIndex];
if (vStatus[vStatusIndex] == iter*numThread+t) {
fprintf(outfp1, "%lu ", vStatusIndex);
}
}
for (j = 0; j < GPtr->inDegree[startV[t]]; j++) {
long inVertexListIndex = j+GPtr->inVertexIndex[startV[t]];
long vStatusIndex = GPtr->inVertexList[inVertexListIndex];
if (vStatus[vStatusIndex] == iter*numThread+t) {
fprintf(outfp1, "%lu ", vStatusIndex);
}
}
fprintf(outfp1, "\n");
}
}
}
}
thread_barrier_wait();
#endif /* WRITE_RESULTS_FILE */
if (myId == 0) {
iter++;
global_iter = iter;
}
TM_BEGIN();
long tmp_cliqueSize = (long)TM_SHARED_READ(global_cliqueSize);
TM_SHARED_WRITE(global_cliqueSize, (tmp_cliqueSize + cliqueSize));
TM_END();
thread_barrier_wait();
iter = global_iter;
verticesVisited += global_cliqueSize;
if ((verticesVisited >= 0.95*GPtr->numVertices) ||
(iter > GPtr->numVertices/2))
{
break;
}
} /* while (verticesVisited < GPtr->numVertices) */
thread_barrier_wait();
#ifdef WRITE_RESULT_FILES
/* Take care of unmarked vertices */
if (myId == 0) {
if (verticesVisited < GPtr->numVertices) {
for(i = 0; i < GPtr->numVertices; i++) {
if (vStatus[i] == -1) {
vStatus[i] = iter*numThread+myId;
fprintf(outfp1, "%lu\n", i);
iter++;
}
}
}
}
thread_barrier_wait();
#endif
/*
* Merge partial Cutset Lists
*/
/* Temp vars for merging edge lists */
ULONGINT_T* edgeStartCounter;
ULONGINT_T* edgeEndCounter;
if (myId == 0) {
edgeStartCounter = (ULONGINT_T*)P_MALLOC(numThread * sizeof(ULONGINT_T));
assert(edgeStartCounter);
global_edgeStartCounter = edgeStartCounter;
edgeEndCounter = (ULONGINT_T*)P_MALLOC(numThread * sizeof(ULONGINT_T));
assert(edgeEndCounter);
global_edgeEndCounter = edgeEndCounter;
}
thread_barrier_wait();
edgeStartCounter = global_edgeStartCounter;
edgeEndCounter = global_edgeEndCounter;
edgeEndCounter[myId] = cutSetIndex;
edgeStartCounter[myId] = 0;
thread_barrier_wait();
if (myId == 0) {
long t;
for (t = 1; t < numThread; t++) {
edgeEndCounter[t] = edgeEndCounter[t-1] + edgeEndCounter[t];
edgeStartCounter[t] = edgeEndCounter[t-1];
}
}
TM_BEGIN();
long tmp_cutSetIndex = (long)TM_SHARED_READ(global_cutSetIndex);
TM_SHARED_WRITE(global_cutSetIndex, (tmp_cutSetIndex + cutSetIndex));
TM_END();
thread_barrier_wait();
cutSetIndex = global_cutSetIndex;
ULONGINT_T cutSetCounter = cutSetIndex;
/* Data struct. for storing edgeCut */
edge* cutSet;
if (myId == 0) {
cutSet = (edge*)P_MALLOC(cutSetCounter * sizeof(edge));
assert(cutSet);
global_cutSet = cutSet;
}
thread_barrier_wait();
cutSet = global_cutSet;
long j;
for (j = edgeStartCounter[myId]; j < edgeEndCounter[myId]; j++) {
cutSet[j].startVertex = pCutSet[j-edgeStartCounter[myId]].startVertex;
cutSet[j].endVertex = pCutSet[j-edgeStartCounter[myId]].endVertex;
}
thread_barrier_wait();
#ifdef WRITE_RESULT_FILES
FILE* outfp2 = NULL;
if (myId == 0) {
outfp2 = fopen("edgeCut.txt", "w");
fprintf(outfp2, "\nEdges in Cut Set - \n");
for (i = 0; i < cutSetCounter; i++) {
fprintf(outfp2, "[%lu %lu] ",
cutSet[i].startVertex, cutSet[i].endVertex);
}
fclose(outfp2);
fclose(outfp1);
}
#endif
if (myId == 0) {
P_FREE(edgeStartCounter);
P_FREE(edgeEndCounter);
P_FREE(pCutSet);
P_FREE(IndexSorted);
P_FREE(neighbourArraySorted);
P_FREE(startV);
P_FREE(clusterSize);
P_FREE(cutSet);
P_FREE(vStatus);
}
TM_THREAD_EXIT();
}
