void decrementer(omp_lock_t* lock_b) {
for(int i=0; i< LOOP_ITS; ++i) {
while (!omp_test_lock(&g_lock_a));
g_a--;
omp_unset_lock(&g_lock_a);
while (!omp_test_lock(lock_b));
g_b--;
omp_unset_lock(lock_b);
}
}
int POMP2_Test_lock(omp_lock_t *s) {
if ( pomp2_tracing ) {
int result;
esd_enter(epk_omp_regid[EPK__OMP_TEST_LOCK]);
result = omp_test_lock(s);
if (result) if ( pomp2_tracing > 1 ) esd_omp_alock(epk_lock_id(s));
esd_exit(epk_omp_regid[EPK__OMP_TEST_LOCK]);
return result;
} else {
return omp_test_lock(s);
}
}
VT_DECLDEF(int POMP_Test_lock_f(omp_lock_t *s)) {
if ( IS_POMP_TRACE_ON ) {
int result;
uint64_t time;
time = vt_pform_wtime();
vt_enter(VT_CURRENT_THREAD, &time, vt_omp_regid[VT__OMP_TEST_LOCK]);
result = omp_test_lock(s);
time = vt_pform_wtime();
vt_exit(VT_CURRENT_THREAD, &time);
return result;
} else {
return omp_test_lock(s);
}
} VT_GENERATE_F77_BINDINGS(pomp_test_lock, POMP_TEST_LOCK,
int POMP_Test_lock(omp_lock_t *s) {
if ( IS_POMP_TRACE_ON ) {
int result;
uint64_t time;
time = vt_pform_wtime();
vt_enter(VT_CURRENT_THREAD, &time, vt_omp_regid[VT__OMP_TEST_LOCK]);
result = omp_test_lock(s);
time = vt_pform_wtime();
vt_exit(VT_CURRENT_THREAD, &time);
return result;
} else {
return omp_test_lock(s);
}
}
/**
* PRIVATE. Insert a region in a context.
*/
static inline int
bfwork_region_insert(bam_fwork_t *fwork, bam_region_t *region)
{
linked_list_t *list;
size_t list_l;
assert(fwork);
assert(region);
omp_set_lock(&fwork->regions_lock);
//List handle
list = fwork->regions_list;
list_l = linked_list_size(list);
if(list_l >= FWORK_REGIONS_MAX)
{
omp_unset_lock(&fwork->regions_lock);
//Wait for free slots
if(!omp_test_lock(&fwork->free_slots))
{
if(omp_get_num_threads() == 2)
{
#pragma omp taskwait //Force processing
}
omp_set_lock(&fwork->free_slots);
}
//LOG_FATAL_F("Not enough region slots, current: %d\n", list_l);
}
//This lock must be always locked until regions buffer have regions free
omp_test_lock(&fwork->free_slots);
//Add region to list
linked_list_insert_last(region, list);
omp_set_lock(®ion->lock);
LOG_INFO_F("Inserting region %d:%lu-%lu with %d reads\n",
region->chrom + 1, region->init_pos + 1,
region->end_pos + 1, region->size);
LOG_INFO_F("Regions to process %lu\n", linked_list_size(list));
omp_unset_lock(®ion->lock);
omp_unset_lock(&fwork->regions_lock);
return NO_ERROR;
}
int POMP_Test_lock(omp_lock_t *s) {
if ( IS_POMP_TRACE_ON ) {
int result;
uint64_t time = vt_pform_wtime();
vt_enter(&time, vt_omp_regid[VT__OMP_TEST_LOCK]);
result = omp_test_lock(s);
time = vt_pform_wtime();
if (result) vt_omp_alock(&time, vt_lock_id(s));
vt_exit(&time);
return result;
} else {
return omp_test_lock(s);
}
}
DEF_FPOMP_FUNC(int POMP_Test_lock_f(omp_lock_t *s)) {
if ( IS_POMP_TRACE_ON ) {
int result;
uint64_t time = vt_pform_wtime();
vt_enter(&time, vt_omp_regid[VT__OMP_TEST_LOCK]);
result = omp_test_lock(s);
time = vt_pform_wtime();
if (result) vt_omp_alock(&time, vt_lock_id(s));
vt_exit(&time);
return result;
} else {
return omp_test_lock(s);
}
} VT_GENERATE_F77_BINDINGS(pomp_test_lock, POMP_TEST_LOCK,
int main()
{
omp_lock_t lck;
int id;
omp_init_lock(&lck);
#pragma omp parallel shared(lck) private(id)
{
id = omp_get_thread_num();
omp_set_lock(&lck);
/* only one thread at a time can execute this printf */
printf("My thread id is %d.\n", id);
omp_unset_lock(&lck);
while (! omp_test_lock(&lck)) {
skip(id); /* we do not yet have the lock,
so we must do something else */
}
work(id); /* we now have the lock
and can do the work */
omp_unset_lock(&lck);
}
omp_destroy_lock(&lck);
return 0;
}
/* Assumes node is already locked */
static inline void lockTwoNodes(Node *node, Node *node2)
{
IDnum nodeID = getNodeID(node);
IDnum node2ID = getNodeID(node2);
if (nodeID < 0)
nodeID = -nodeID;
if (node2ID < 0)
node2ID = -node2ID;
if (nodeID == node2ID)
return;
/* Lock lowest ID first to avoid deadlocks */
if (nodeID < node2ID)
{
omp_set_lock (nodeLocks + node2ID);
}
else if (!omp_test_lock (nodeLocks + node2ID))
{
omp_unset_lock (nodeLocks + nodeID);
omp_set_lock (nodeLocks + node2ID);
omp_set_lock (nodeLocks + nodeID);
}
}
int test_omp_test_lock()
{
int nr_threads_in_single = 0;
int result = 0;
int nr_iterations = 0;
int i;
omp_init_lock (&lck);
#pragma omp parallel shared(lck)
{
#pragma omp for
for (i = 0; i < LOOPCOUNT; i++) {
while (!omp_test_lock (&lck))
{};
#pragma omp flush
nr_threads_in_single++;
#pragma omp flush
nr_iterations++;
nr_threads_in_single--;
result = result + nr_threads_in_single;
omp_unset_lock (&lck);
}
}
omp_destroy_lock(&lck);
return ((result == 0) && (nr_iterations == LOOPCOUNT));
}
bool get_point(double *x, double *y, int i)
{
if(!omp_test_lock(&array_lock[i]))
return false;
*x = x_array[i];
*y = y_array[i];
omp_unset_lock(&array_lock[i]);
return true;
}
bool put_point(double x, double y, int i)
{
if(!omp_test_lock(&array_lock[i]))
return false;
x_array[i] = x;
y_array[i] = y;
omp_unset_lock(&array_lock[i]);
return true;
}
int colvarproxy_smp::smp_trylock()
{
#if defined(_OPENMP)
return omp_test_lock(reinterpret_cast<omp_lock_t *>(omp_lock_state)) ?
COLVARS_OK : COLVARS_ERROR;
#else
return COLVARS_OK;
#endif
}
/// @param waitForLock If false do not block the current thread
/// if the lock is not available.
///
OmpLockGuard::OmpLockGuard(omp_lock_t* lock, bool waitForLock = true) :
lock_(lock)
{
if (!waitForLock)
isSet_ = (omp_test_lock(lock_) != 0);
else {
omp_set_lock(lock_);
isSet_ = true;
}
}
bool trypush (const int& value)
{
bool result = omp_test_lock (&lock);
if (result)
{
result = result && this->base::push (value);
omp_unset_lock (&lock);
}
return result;
}
YSRESULT YsOpenMPMutex::LockNoWait(void)
{
if(true==omp_test_lock(&lock))
{
return YSOK;
}
else
{
return YSERR;
}
}
int tci_mutex_trylock(tci_mutex_t* mutex)
{
if (omp_test_lock(mutex))
{
return 0;
}
else
{
return EBUSY;
}
}
int main(int argc, const char * argv[]){
omp_init_lock(&simple_lock);
#pragma omp parallel num_threads(4)
{
while (!omp_test_lock(&simple_lock)){
printf("=== Hilo %d: bloqueo ocupado\n", omp_get_thread_num());
}
printf("+++ Hilo %d: Consegui el bloque\n", omp_get_thread_num());
printf("--- Hilo %d: Libere el bloqueo\n", omp_get_thread_num());
omp_unset_lock(&simple_lock);
}
omp_destroy_lock(&simple_lock);
}
bool try_lock() { return static_cast<bool>(omp_test_lock( &m_lock )); }
static int
bfwork_run_threaded(bam_fwork_t *fwork)
{
int err;
bam_region_t *region;
linked_list_t *regions;
double times;
omp_lock_t end_condition_lock;
int end_condition;
omp_lock_t reads_lock;
size_t reads;
size_t reads_to_write;
//Init lock
omp_init_lock(&end_condition_lock);
omp_init_lock(&reads_lock);
//#pragma omp parallel private(err, region, regions, times, reads_to_write)
{
//#pragma omp single
{
printf("Running in multithreading mode with %d threads\n", omp_get_max_threads());
end_condition = 1;
reads = 0;
}
#pragma omp parallel sections private(err, region, regions, times, reads_to_write)
{
//Region read
#pragma omp section
{
regions = fwork->regions_list;
while(1)
{
//Create new current region
region = (bam_region_t *)malloc(sizeof(bam_region_t));
breg_init(region);
//Fill region
#ifdef D_TIME_DEBUG
times = omp_get_wtime();
#endif
err = bfwork_obtain_region(fwork, region);
#ifdef D_TIME_DEBUG
times = omp_get_wtime() - times;
omp_set_lock(®ion->lock);
if(fwork->context->time_stats)
if(region->size != 0)
time_add_time_slot(D_FWORK_READ, fwork->context->time_stats, times / (double)region->size);
omp_unset_lock(®ion->lock);
#endif
if(err)
{
if(err == WANDER_REGION_CHANGED || err == WANDER_READ_EOF)
{
//Until process, this region cant be writed
omp_test_lock(®ion->write_lock);
//Add region to framework regions
bfwork_region_insert(fwork, region);
#pragma omp task untied firstprivate(region) private(err)
{
int i;
size_t pf_l;
double aux_time;
//Process region
omp_set_lock(®ion->lock);
#ifdef D_TIME_DEBUG
times = omp_get_wtime();
#endif
//Process region
pf_l = fwork->context->processing_f_l;
for(i = 0; i < pf_l; i++)
{
fwork->context->processing_f[i](fwork, region);
}
#ifdef D_TIME_DEBUG
times = omp_get_wtime() - times;
if(fwork->context->time_stats)
if(region->size != 0)
time_add_time_slot(D_FWORK_PROC_FUNC, fwork->context->time_stats, times / (double)region->size);
aux_time = omp_get_wtime();
#endif
omp_unset_lock(®ion->lock);
omp_set_lock(&reads_lock);
reads += region->size;
printf("Reads processed: %lu\r", reads);
omp_unset_lock(&reads_lock);
#ifdef D_TIME_DEBUG
aux_time = omp_get_wtime() - aux_time;
omp_set_lock(®ion->lock);
if(fwork->context->time_stats)
if(region->size != 0)
time_add_time_slot(D_FWORK_PROC, fwork->context->time_stats, (times + aux_time) / (double)region->size);
omp_unset_lock(®ion->lock);
#endif
//Set this region as writable
omp_unset_lock(®ion->write_lock);
}
//End readings
if(err == WANDER_READ_EOF)
break;
}
else
{
if(err == WANDER_READ_TRUNCATED)
{
LOG_WARN("Readed truncated read\n");
}
else
{
LOG_FATAL_F("Failed to read next region, error code: %d\n", err);
}
break;
}
}
else
{
//No more regions, end loop
LOG_INFO("No more regions to read");
break;
}
}
omp_set_lock(&end_condition_lock);
end_condition = 0;
omp_unset_lock(&end_condition_lock);
//LOG_WARN("Read thread exit\n");
}//End read section
//Write section
#pragma omp section
{
regions = fwork->regions_list;
omp_set_lock(&end_condition_lock);
while(end_condition || linked_list_size(regions) > 0)
{
omp_unset_lock(&end_condition_lock);
#ifdef D_TIME_DEBUG
times = omp_get_wtime();
#endif
//Get next region
omp_set_lock(&fwork->regions_lock);
region = linked_list_get_first(regions);
omp_unset_lock(&fwork->regions_lock);
if(region == NULL)
{
omp_set_lock(&end_condition_lock);
continue;
}
//Wait region to be writable
omp_set_lock(®ion->write_lock);
//Write region
omp_set_lock(&fwork->output_file_lock);
reads_to_write = region->size;
breg_write_n(region, reads_to_write, fwork->output_file);
omp_unset_lock(&fwork->output_file_lock);
//Remove from list
omp_set_lock(&fwork->regions_lock);
if(linked_list_size(regions) == 1) //Possible bug?
linked_list_clear(regions, NULL);
else
linked_list_remove_first(regions);
//Signal read section if regions list is full
if(linked_list_size(regions) < (FWORK_REGIONS_MAX / 2) )
omp_unset_lock(&fwork->free_slots);
omp_unset_lock(&fwork->regions_lock);
#ifdef D_TIME_DEBUG
times = omp_get_wtime() - times;
omp_set_lock(®ion->lock);
if(fwork->context->time_stats)
if(reads_to_write != 0)
time_add_time_slot(D_FWORK_WRITE, fwork->context->time_stats, times / (double)reads_to_write);
omp_unset_lock(®ion->lock);
#endif
//Free region
breg_destroy(region, 1);
free(region);
omp_set_lock(&end_condition_lock);
}
omp_unset_lock(&end_condition_lock);
//LOG_WARN("Write thread exit\n");
}//End write section
}//End sections
}//End parallel
//Lineskip
printf("\n");
//Free
omp_destroy_lock(&end_condition_lock);
return NO_ERROR;
}
void vertex_betweenness_centrality_parBFS(graph_t* G, double* BC, long numSrcs) {
attr_id_t *S; /* stack of vertices in the order of non-decreasing
distance from s. Also used to implicitly
represent the BFS queue */
plist_t* P; /* predecessors of a vertex v on shortest paths from s */
double* sig; /* No. of shortest paths */
attr_id_t* d; /* Length of the shortest path between every pair */
double* del; /* dependency of vertices */
attr_id_t *in_degree, *numEdges, *pSums;
attr_id_t* pListMem;
#if RANDSRCS
attr_id_t* Srcs;
#endif
attr_id_t *start, *end;
long MAX_NUM_PHASES;
attr_id_t *psCount;
#ifdef _OPENMP
omp_lock_t* vLock;
long chunkSize;
#endif
#ifdef DIAGNOSTIC
double elapsed_time;
#endif
int seed = 2387;
#ifdef _OPENMP
#pragma omp parallel firstprivate(G)
{
#endif
attr_id_t *myS, *myS_t;
attr_id_t myS_size;
long i, j, k, p, count, myCount;
long v, w, vert;
long k0, k1;
long numV, num_traversals, n, m, phase_num;
long start_iter, end_iter;
long tid, nthreads;
int* stream;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
#ifdef _OPENMP
int myLock;
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
#else
tid = 0;
nthreads = 1;
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time = get_seconds();
elapsed_time_part = get_seconds();
}
#endif
/* numV: no. of vertices to run BFS from = numSrcs */
numV = numSrcs;
n = G->n;
m = G->m;
/* Permute vertices */
if (tid == 0) {
#if RANDSRCS
Srcs = (attr_id_t *) malloc(n*sizeof(attr_id_t));
#endif
#ifdef _OPENMP
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#if RANDSRCS
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
Srcs[i] = i;
}
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n * sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
k = Srcs[i];
Srcs[i] = Srcs[j];
Srcs[j] = k;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
if (tid == 0) {
MAX_NUM_PHASES = 500;
}
#ifdef _OPENMP
#pragma omp barrier
#endif
/* Initialize predecessor lists */
/* The size of the predecessor list of each vertex is bounded by
its in-degree. So we first compute the in-degree of every
vertex */
if (tid == 0) {
P = (plist_t *) calloc(n, sizeof(plist_t));
in_degree = (attr_id_t *) calloc(n+1, sizeof(attr_id_t));
numEdges = (attr_id_t *) malloc((n+1)*sizeof(attr_id_t));
pSums = (attr_id_t *) malloc(nthreads*sizeof(attr_id_t));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
v = G->endV[i];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
in_degree[v]++;
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
prefix_sums(in_degree, numEdges, pSums, n);
if (tid == 0) {
pListMem = (attr_id_t *) malloc(m*sizeof(attr_id_t));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<n; i++) {
P[i].list = pListMem + numEdges[i];
P[i].degree = in_degree[i];
P[i].count = 0;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "In-degree computation time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Allocate shared memory */
if (tid == 0) {
free(in_degree);
free(numEdges);
free(pSums);
S = (attr_id_t *) malloc(n*sizeof(attr_id_t));
sig = (double *) malloc(n*sizeof(double));
d = (attr_id_t *) malloc(n*sizeof(attr_id_t));
del = (double *) calloc(n, sizeof(double));
start = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
end = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
psCount = (attr_id_t *) malloc((nthreads+1)*sizeof(attr_id_t));
}
/* local memory for each thread */
myS_size = (2*n)/nthreads;
myS = (attr_id_t *) malloc(myS_size*sizeof(attr_id_t));
num_traversals = 0;
myCount = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
d[i] = -1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC initialization time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
for (p=0; p<n; p++) {
#if RANDSRCS
i = Srcs[p];
#else
i = p;
#endif
if (G->numEdges[i+1] - G->numEdges[i] == 0) {
continue;
} else {
num_traversals++;
}
if (num_traversals == numV + 1) {
break;
}
if (tid == 0) {
sig[i] = 1;
d[i] = 0;
S[0] = i;
start[0] = 0;
end[0] = 1;
}
count = 1;
phase_num = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
while (end[phase_num] - start[phase_num] > 0) {
myCount = 0;
start_iter = start[phase_num];
end_iter = end[phase_num];
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for schedule(dynamic) nowait
#endif
for (vert = start_iter; vert < end_iter; vert++) {
v = S[vert];
for (j=G->numEdges[v]; j<G->numEdges[v+1]; j++) {
w = G->endV[j];
if (v != w) {
#ifdef _OPENMP
myLock = omp_test_lock(&vLock[w]);
if (myLock) {
#endif
/* w found for the first time? */
if (d[w] == -1) {
if (myS_size == myCount) {
/* Resize myS */
myS_t = (attr_id_t *)
malloc(2*myS_size*sizeof(attr_id_t));
memcpy(myS_t, myS,
myS_size*sizeof(attr_id_t));
free(myS);
myS = myS_t;
myS_size = 2*myS_size;
}
myS[myCount++] = w;
d[w] = d[v] + 1;
sig[w] = sig[v];
P[w].list[P[w].count++] = v;
} else if (d[w] == d[v] + 1) {
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
}
#ifdef _OPENMP
omp_unset_lock(&vLock[w]);
} else {
if ((d[w] == -1) || (d[w] == d[v]+ 1)) {
omp_set_lock(&vLock[w]);
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
omp_unset_lock(&vLock[w]);
}
}
#endif
}
}
}
/* Merge all local stacks for next iteration */
phase_num++;
if (tid == 0) {
if (phase_num >= MAX_NUM_PHASES) {
fprintf(stderr, "Error: Max num phases set to %ld\n",
MAX_NUM_PHASES);
fprintf(stderr, "Diameter of input network greater than"
" this value. Increase MAX_NUM_PHASES"
" in vertex_betweenness_centrality_parBFS()\n");
exit(-1);
}
}
psCount[tid+1] = myCount;
#ifdef _OPENMP
#pragma omp barrier
#endif
if (tid == 0) {
start[phase_num] = end[phase_num-1];
psCount[0] = start[phase_num];
for(k=1; k<=nthreads; k++) {
psCount[k] = psCount[k-1] + psCount[k];
}
end[phase_num] = psCount[nthreads];
}
#ifdef _OPENMP
#pragma omp barrier
#endif
k0 = psCount[tid];
k1 = psCount[tid+1];
for (k = k0; k < k1; k++) {
S[k] = myS[k-k0];
}
count = end[phase_num];
}
phase_num--;
while (phase_num > 0) {
start_iter = start[phase_num];
end_iter = end[phase_num];
#ifdef _OPENMP
#pragma omp for schedule(static) nowait
#endif
for (j=start_iter; j<end_iter; j++) {
w = S[j];
for (k = 0; k<P[w].count; k++) {
v = P[w].list[k];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
del[v] = del[v] + sig[v]*(1+del[w])/sig[w];
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
BC[w] += del[w];
}
phase_num--;
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef _OPENMP
chunkSize = n/nthreads;
#pragma omp for schedule(static, chunkSize) nowait
#endif
for (j=0; j<count; j++) {
w = S[j];
d[w] = -1;
del[w] = 0;
P[w].count = 0;
}
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC computation time: %lf seconds\n",
elapsed_time_part);
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#endif
free(myS);
if (tid == 0) {
free(S);
free(pListMem);
free(P);
free(sig);
free(d);
free(del);
#ifdef _OPENMP
free(vLock);
#endif
free(start);
free(end);
free(psCount);
#ifdef DIAGNOSTIC
elapsed_time = get_seconds() - elapsed_time;
fprintf(stderr, "Time taken: %lf\n seconds", elapsed_time);
#endif
#if RANDSRCS
free(Srcs);
#endif
}
free_sprng(stream);
#ifdef _OPENMP
}
#endif
}
void vertex_betweenness_centrality_simple(graph_t* G, double* BC, long numSrcs) {
attr_id_t *in_degree, *numEdges, *pSums;
#if RANDSRCS
attr_id_t* Srcs;
#endif
long num_traversals = 0;
#ifdef _OPENMP
omp_lock_t* vLock;
long chunkSize;
#endif
#ifdef DIAGNOSTIC
double elapsed_time;
#endif
int seed = 2387;
/* The outer loop is parallelized in this case. Each thread does a BFS
and the vertex BC values are incremented atomically */
#ifdef _OPENMP
#pragma omp parallel firstprivate(G)
{
#endif
attr_id_t *S; /* stack of vertices in the order of non-decreasing
distance from s. Also used to implicitly
represent the BFS queue */
plist_t* P; /* predecessors of a vertex v on shortest paths
from s */
attr_id_t* pListMem;
double* sig; /* No. of shortest paths */
attr_id_t* d; /* Length of the shortest path between every pair */
double* del; /* dependency of vertices */
attr_id_t *start, *end;
long MAX_NUM_PHASES;
long i, j, k, p, count;
long v, w, vert;
long numV, n, m, phase_num;
long tid, nthreads;
int* stream;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
#ifdef _OPENMP
int myLock;
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
#else
tid = 0;
nthreads = 1;
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time = get_seconds();
elapsed_time_part = get_seconds();
}
#endif
/* numV: no. of vertices to run BFS from = numSrcs */
numV = numSrcs;
n = G->n;
m = G->m;
/* Permute vertices */
if (tid == 0) {
#if RANDSRCS
Srcs = (attr_id_t *) malloc(n*sizeof(attr_id_t));
#endif
#ifdef _OPENMP
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#if RANDSRCS
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
Srcs[i] = i;
}
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n * sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
k = Srcs[i];
Srcs[i] = Srcs[j];
Srcs[j] = k;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
MAX_NUM_PHASES = 50;
/* Initialize predecessor lists */
/* The size of the predecessor list of each vertex is bounded by
its in-degree. So we first compute the in-degree of every
vertex */
if (tid == 0) {
in_degree = (attr_id_t *) calloc(n+1, sizeof(attr_id_t));
numEdges = (attr_id_t *) malloc((n+1)*sizeof(attr_id_t));
pSums = (attr_id_t *) malloc(nthreads*sizeof(attr_id_t));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
v = G->endV[i];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
in_degree[v]++;
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
prefix_sums(in_degree, numEdges, pSums, n);
P = (plist_t *) calloc(n, sizeof(plist_t));
pListMem = (attr_id_t *) malloc(m*sizeof(attr_id_t));
for (i=0; i<n; i++) {
P[i].list = pListMem + numEdges[i];
P[i].degree = in_degree[i];
P[i].count = 0;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "In-degree computation time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
/* Allocate shared memory */
if (tid == 0) {
free(in_degree);
free(numEdges);
free(pSums);
}
S = (attr_id_t *) malloc(n*sizeof(attr_id_t));
sig = (double *) malloc(n*sizeof(double));
d = (attr_id_t *) malloc(n*sizeof(attr_id_t));
del = (double *) calloc(n, sizeof(double));
start = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
end = (attr_id_t *) malloc(MAX_NUM_PHASES*sizeof(attr_id_t));
#ifdef _OPENMP
#pragma omp barrier
#endif
for (i=0; i<n; i++) {
d[i] = -1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC initialization time: %lf seconds\n",
elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
#ifdef _OPENMP
#pragma omp for reduction(+:num_traversals)
#endif
for (p=0; p<numV; p++) {
#if RANDSRCS
i = Srcs[p];
#else
i = p;
#endif
if (G->numEdges[i+1] - G->numEdges[i] == 0) {
continue;
} else {
num_traversals++;
}
sig[i] = 1;
d[i] = 0;
S[0] = i;
start[0] = 0;
end[0] = 1;
count = 1;
phase_num = 0;
while (end[phase_num] - start[phase_num] > 0) {
for (vert = start[phase_num]; vert < end[phase_num]; vert++) {
v = S[vert];
for (j=G->numEdges[v]; j<G->numEdges[v+1]; j++) {
w = G->endV[j];
if (v != w) {
/* w found for the first time? */
if (d[w] == -1) {
S[count++] = w;
d[w] = d[v] + 1;
sig[w] = sig[v];
P[w].list[P[w].count++] = v;
} else if (d[w] == d[v] + 1) {
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
}
}
}
}
phase_num++;
start[phase_num] = end[phase_num-1];
end[phase_num] = count;
}
phase_num--;
while (phase_num > 0) {
for (j=start[phase_num]; j<end[phase_num]; j++) {
w = S[j];
for (k = 0; k<P[w].count; k++) {
v = P[w].list[k];
del[v] = del[v] + sig[v]*(1+del[w])/sig[w];
}
#ifdef _OPENMP
omp_set_lock(&vLock[w]);
BC[w] += del[w];
omp_unset_lock(&vLock[w]);
#else
BC[w] += del[w];
#endif
}
phase_num--;
}
for (j=0; j<count; j++) {
w = S[j];
d[w] = -1;
del[w] = 0;
P[w].count = 0;
}
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "BC computation time: %lf seconds\n",
elapsed_time_part);
}
#endif
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#endif
free(S);
free(pListMem);
free(P);
free(sig);
free(d);
free(del);
free(start);
free(end);
if (tid == 0) {
#ifdef _OPENMP
free(vLock);
#endif
#if RANDSRCS
free(Srcs);
#endif
#ifdef DIAGNOSTIC
elapsed_time = get_seconds() - elapsed_time;
fprintf(stderr, "Total time taken: %lf seconds\n", elapsed_time);
#endif
}
free_sprng(stream);
#ifdef _OPENMP
#pragma omp barrier
}
#endif
}
int
main (void)
{
double d, e;
int l;
omp_lock_t lck;
omp_nest_lock_t nlck;
d = omp_get_wtime ();
omp_init_lock (&lck);
omp_set_lock (&lck);
if (omp_test_lock (&lck))
abort ();
omp_unset_lock (&lck);
if (! omp_test_lock (&lck))
abort ();
if (omp_test_lock (&lck))
abort ();
omp_unset_lock (&lck);
omp_destroy_lock (&lck);
omp_init_nest_lock (&nlck);
if (omp_test_nest_lock (&nlck) != 1)
abort ();
omp_set_nest_lock (&nlck);
if (omp_test_nest_lock (&nlck) != 3)
abort ();
omp_unset_nest_lock (&nlck);
omp_unset_nest_lock (&nlck);
if (omp_test_nest_lock (&nlck) != 2)
abort ();
omp_unset_nest_lock (&nlck);
omp_unset_nest_lock (&nlck);
omp_destroy_nest_lock (&nlck);
omp_set_dynamic (1);
if (! omp_get_dynamic ())
abort ();
omp_set_dynamic (0);
if (omp_get_dynamic ())
abort ();
omp_set_nested (1);
if (! omp_get_nested ())
abort ();
omp_set_nested (0);
if (omp_get_nested ())
abort ();
omp_set_num_threads (5);
if (omp_get_num_threads () != 1)
abort ();
if (omp_get_max_threads () != 5)
abort ();
if (omp_get_thread_num () != 0)
abort ();
omp_set_num_threads (3);
if (omp_get_num_threads () != 1)
abort ();
if (omp_get_max_threads () != 3)
abort ();
if (omp_get_thread_num () != 0)
abort ();
l = 0;
#pragma omp parallel reduction (|:l)
{
l = omp_get_num_threads () != 3;
l |= omp_get_thread_num () < 0;
l |= omp_get_thread_num () >= 3;
#pragma omp master
l |= omp_get_thread_num () != 0;
}
if (l)
abort ();
if (omp_get_num_procs () <= 0)
abort ();
if (omp_in_parallel ())
abort ();
#pragma omp parallel reduction (|:l)
l = ! omp_in_parallel ();
#pragma omp parallel reduction (|:l) if (1)
l = ! omp_in_parallel ();
if (l)
abort ();
e = omp_get_wtime ();
if (d > e)
abort ();
d = omp_get_wtick ();
/* Negative precision is definitely wrong,
bigger than 1s clock resolution is also strange. */
if (d <= 0 || d > 1)
abort ();
return 0;
}
double betweennessCentrality(graph* G, DOUBLE_T* BC, int filter) {
VERT_T *S; /* stack of vertices in the order of non-decreasing
distance from s. Also used to implicitly
represent the BFS queue */
plist* P; /* predecessors of a vertex v on shortest paths from s */
DOUBLE_T* sig; /* No. of shortest paths */
LONG_T* d; /* Length of the shortest path between every pair */
DOUBLE_T* del; /* dependency of vertices */
LONG_T *in_degree, *numEdges, *pSums;
LONG_T *pListMem;
LONG_T* Srcs;
LONG_T *start, *end;
LONG_T MAX_NUM_PHASES;
LONG_T *psCount;
#ifdef _OPENMP
omp_lock_t* vLock;
LONG_T chunkSize;
#endif
int seed = 2387;
double elapsed_time;
#ifdef _OPENMP
#pragma omp parallel
{
#endif
VERT_T *myS, *myS_t;
LONG_T myS_size;
LONG_T i, j, k, p, count, myCount;
LONG_T v, w, vert;
LONG_T numV, num_traversals, n, m, phase_num;
LONG_T tid, nthreads;
int* stream;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
#ifdef _OPENMP
int myLock;
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
#else
tid = 0;
nthreads = 1;
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds();
}
#endif
/* numV: no. of vertices to run BFS from = 2^K4approx */
numV = 1<<K4approx;
n = G->n;
m = G->m;
/* Permute vertices */
if (tid == 0) {
Srcs = (LONG_T *) malloc(n*sizeof(LONG_T));
#ifdef _OPENMP
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
Srcs[i] = i;
}
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n*sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
k = Srcs[i];
Srcs[i] = Srcs[j];
Srcs[j] = k;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "Vertex ID permutation time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Start timing code from here */
if (tid == 0) {
elapsed_time = get_seconds();
#ifdef VERIFYK4
MAX_NUM_PHASES = 2*sqrt(n);
#else
MAX_NUM_PHASES = 50;
#endif
}
#ifdef _OPENMP
#pragma omp barrier
#endif
/* Initialize predecessor lists */
/* The size of the predecessor list of each vertex is bounded by
its in-degree. So we first compute the in-degree of every
vertex */
if (tid == 0) {
P = (plist *) calloc(n, sizeof(plist));
in_degree = (LONG_T *) calloc(n+1, sizeof(LONG_T));
numEdges = (LONG_T *) malloc((n+1)*sizeof(LONG_T));
pSums = (LONG_T *) malloc(nthreads*sizeof(LONG_T));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
v = G->endV[i];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
in_degree[v]++;
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
prefix_sums(in_degree, numEdges, pSums, n);
if (tid == 0) {
pListMem = (LONG_T *) malloc(m*sizeof(LONG_T));
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<n; i++) {
P[i].list = pListMem + numEdges[i];
P[i].degree = in_degree[i];
P[i].count = 0;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "In-degree computation time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Allocate shared memory */
if (tid == 0) {
free(in_degree);
free(numEdges);
free(pSums);
S = (VERT_T *) malloc(n*sizeof(VERT_T));
sig = (DOUBLE_T *) malloc(n*sizeof(DOUBLE_T));
d = (LONG_T *) malloc(n*sizeof(LONG_T));
del = (DOUBLE_T *) calloc(n, sizeof(DOUBLE_T));
start = (LONG_T *) malloc(MAX_NUM_PHASES*sizeof(LONG_T));
end = (LONG_T *) malloc(MAX_NUM_PHASES*sizeof(LONG_T));
psCount = (LONG_T *) malloc((nthreads+1)*sizeof(LONG_T));
}
/* local memory for each thread */
myS_size = (2*n)/nthreads;
myS = (LONG_T *) malloc(myS_size*sizeof(LONG_T));
num_traversals = 0;
myCount = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
d[i] = -1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "BC initialization time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
for (p=0; p<n; p++) {
i = Srcs[p];
//printf ("%d \n", i);
// i = p;
if (G->numEdges[i+1] - G->numEdges[i] == 0) {
continue;
} else {
num_traversals++;
}
if (num_traversals == numV + 1) {
break;
}
if (tid == 0) {
sig[i] = 1;
d[i] = 0;
S[0] = i;
start[0] = 0;
end[0] = 1;
}
count = 1;
phase_num = 0;
#ifdef _OPENMP
#pragma omp barrier
#endif
while (end[phase_num] - start[phase_num] > 0) {
myCount = 0;
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for schedule(dynamic)
#endif
for (vert = start[phase_num]; vert < end[phase_num]; vert++) {
v = S[vert];
for (j=G->numEdges[v]; j<G->numEdges[v+1]; j++) {
if ((G->weight[j] & 7) == 0 && filter==1) continue;
w = G->endV[j];
if (v != w) {
#ifdef _OPENMP
myLock = omp_test_lock(&vLock[w]);
if (myLock) {
#endif
/* w found for the first time? */
if (d[w] == -1) {
if (myS_size == myCount) {
/* Resize myS */
myS_t = (LONG_T *)
malloc(2*myS_size*sizeof(VERT_T));
memcpy(myS_t, myS, myS_size*sizeof(VERT_T));
free(myS);
myS = myS_t;
myS_size = 2*myS_size;
}
myS[myCount++] = w;
d[w] = d[v] + 1;
sig[w] = sig[v];
P[w].list[P[w].count++] = v;
} else if (d[w] == d[v] + 1) {
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
}
#ifdef _OPENMP
omp_unset_lock(&vLock[w]);
} else {
if ((d[w] == -1) || (d[w] == d[v]+ 1)) {
omp_set_lock(&vLock[w]);
sig[w] += sig[v];
P[w].list[P[w].count++] = v;
omp_unset_lock(&vLock[w]);
}
}
#endif
}
}
}
/* Merge all local stacks for next iteration */
phase_num++;
psCount[tid+1] = myCount;
#ifdef _OPENMP
#pragma omp barrier
#endif
if (tid == 0) {
start[phase_num] = end[phase_num-1];
psCount[0] = start[phase_num];
for(k=1; k<=nthreads; k++) {
psCount[k] = psCount[k-1] + psCount[k];
}
end[phase_num] = psCount[nthreads];
}
#ifdef _OPENMP
#pragma omp barrier
#endif
for (k = psCount[tid]; k < psCount[tid+1]; k++) {
S[k] = myS[k-psCount[tid]];
}
#ifdef _OPENMP
#pragma omp barrier
#endif
count = end[phase_num];
}
phase_num--;
#ifdef _OPENMP
#pragma omp barrier
#endif
//printf ("%d\n", phase_num);
while (phase_num > 0) {
#ifdef _OPENMP
#pragma omp for
#endif
for (j=start[phase_num]; j<end[phase_num]; j++) {
w = S[j];
for (k = 0; k<P[w].count; k++) {
v = P[w].list[k];
#ifdef _OPENMP
omp_set_lock(&vLock[v]);
#endif
del[v] = del[v] + sig[v]*(1+del[w])/sig[w];
#ifdef _OPENMP
omp_unset_lock(&vLock[v]);
#endif
}
BC[w] += del[w];
}
phase_num--;
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef _OPENMP
chunkSize = n/nthreads;
#pragma omp for schedule(static, chunkSize)
#endif
for (j=0; j<count; j++) {
w = S[j];
//fprintf (stderr, "w: %d\n", w);
d[w] = -1;
del[w] = 0;
P[w].count = 0;
}
#ifdef _OPENMP
#pragma omp barrier
#endif
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "BC computation time: %lf seconds\n", elapsed_time_part);
}
#endif
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#endif
free(myS);
if (tid == 0) {
free(S);
free(pListMem);
free(P);
free(sig);
free(d);
free(del);
#ifdef _OPENMP
free(vLock);
#endif
free(start);
free(end);
free(psCount);
elapsed_time = get_seconds() - elapsed_time;
free(Srcs);
}
free_sprng(stream);
#ifdef _OPENMP
}
#endif
/* Verification */
#ifdef VERIFYK4
double BCval;
if (SCALE % 2 == 0) {
BCval = 0.5*pow(2, 3*SCALE/2)-pow(2, SCALE)+1.0;
} else {
BCval = 0.75*pow(2, (3*SCALE-1)/2)-pow(2, SCALE)+1.0;
}
int failed = 0;
for (int i=0; i<G->n; i++) {
if (round(BC[i] - BCval) != 0) {
failed = 1;
break;
}
}
if (failed) {
fprintf(stderr, "Kernel 4 failed validation!\n");
} else {
fprintf(stderr, "Kernel 4 validation successful!\n");
}
#endif
for (int i = 0; i < G->n; i++) printf ("BC: %d %f\n",i, BC[i]);
return elapsed_time;
}
double genScalData(graphSDG* SDGdata) {
VERT_T *src, *dest;
WEIGHT_T *wt;
LONG_T n, m;
VERT_T *permV;
#ifdef _OPENMP
omp_lock_t* vLock;
#endif
double elapsed_time;
int seed;
n = N;
m = M;
/* allocate memory for edge tuples */
src = (VERT_T *) malloc(M*sizeof(VERT_T));
dest = (VERT_T *) malloc(M*sizeof(VERT_T));
assert(src != NULL);
assert(dest != NULL);
/* sprng seed */
seed = 2387;
elapsed_time = get_seconds();
#ifdef _OPENMP
#if PARALLEL_SDG
omp_set_num_threads(omp_get_max_threads());
// omp_set_num_threads(16);
#else
omp_set_num_threads(1);
#endif
#endif
#ifdef _OPENMP
#pragma omp parallel
{
#endif
int tid, nthreads;
#ifdef DIAGNOSTIC
double elapsed_time_part;
#endif
int *stream;
LONG_T i, j, u, v, step;
DOUBLE_T av, bv, cv, dv, p, S, var;
LONG_T tmpVal;
#ifdef _OPENMP
nthreads = omp_get_num_threads();
tid = omp_get_thread_num();
#else
nthreads = 1;
tid = 0;
#endif
/* Initialize RNG stream */
stream = init_sprng(0, tid, nthreads, seed, SPRNG_DEFAULT);
#ifdef DIAGNOSTIC
if (tid == 0)
elapsed_time_part = get_seconds();
#endif
/* Start adding edges */
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<m; i++) {
u = 1;
v = 1;
step = n/2;
av = A;
bv = B;
cv = C;
dv = D;
p = sprng(stream);
if (p < av) {
/* Do nothing */
} else if ((p >= av) && (p < av+bv)) {
v += step;
} else if ((p >= av+bv) && (p < av+bv+cv)) {
u += step;
} else {
u += step;
v += step;
}
for (j=1; j<SCALE; j++) {
step = step/2;
/* Vary a,b,c,d by up to 10% */
var = 0.1;
av *= 0.95 + var * sprng(stream);
bv *= 0.95 + var * sprng(stream);
cv *= 0.95 + var * sprng(stream);
dv *= 0.95 + var * sprng(stream);
S = av + bv + cv + dv;
av = av/S;
bv = bv/S;
cv = cv/S;
dv = dv/S;
/* Choose partition */
p = sprng(stream);
if (p < av) {
/* Do nothing */
} else if ((p >= av) && (p < av+bv)) {
v += step;
} else if ((p >= av+bv) && (p < av+bv+cv)) {
u += step;
} else {
u += step;
v += step;
}
}
src[i] = u-1;
dest[i] = v-1;
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() -elapsed_time_part;
fprintf(stderr, "Tuple generation time: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
/* Generate vertex ID permutations */
if (tid == 0) {
permV = (VERT_T *) malloc(N*sizeof(VERT_T));
assert(permV != NULL);
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<n; i++) {
permV[i] = i;
}
#ifdef _OPENMP
if (tid == 0) {
vLock = (omp_lock_t *) malloc(n*sizeof(omp_lock_t));
assert(vLock != NULL);
}
#pragma omp barrier
#pragma omp for
for (i=0; i<n; i++) {
omp_init_lock(&vLock[i]);
}
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<n; i++) {
j = n*sprng(stream);
if (i != j) {
#ifdef _OPENMP
int l1 = omp_test_lock(&vLock[i]);
if (l1) {
int l2 = omp_test_lock(&vLock[j]);
if (l2) {
#endif
tmpVal = permV[i];
permV[i] = permV[j];
permV[j] = tmpVal;
#ifdef _OPENMP
omp_unset_lock(&vLock[j]);
}
omp_unset_lock(&vLock[i]);
}
#endif
}
}
#ifdef _OPENMP
#pragma omp for
for (i=0; i<n; i++) {
omp_destroy_lock(&vLock[i]);
}
#pragma omp barrier
if (tid == 0) {
free(vLock);
}
#endif
#ifdef _OPENMP
#pragma omp for
#endif
for (i=0; i<m; i++) {
src[i] = permV[src[i]];
dest[i] = permV[dest[i]];
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "Permuting vertex IDs: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
if (tid == 0) {
free(permV);
}
/* Generate edge weights */
if (tid == 0) {
wt = (WEIGHT_T *) malloc(M*sizeof(WEIGHT_T));
assert(wt != NULL);
}
#ifdef _OPENMP
#pragma omp barrier
#pragma omp for
#endif
for (i=0; i<m; i++) {
wt[i] = 1 + MaxIntWeight * sprng(stream);
}
#ifdef DIAGNOSTIC
if (tid == 0) {
elapsed_time_part = get_seconds() - elapsed_time_part;
fprintf(stderr, "Generating edge weights: %lf seconds\n", elapsed_time_part);
elapsed_time_part = get_seconds();
}
#endif
SDGdata->n = n;
SDGdata->m = m;
SDGdata->startVertex = src;
SDGdata->endVertex = dest;
SDGdata->weight = wt;
free_sprng(stream);
#ifdef _OPENMP
}
#endif
elapsed_time = get_seconds() - elapsed_time;
return elapsed_time;
}
int auction_search(int *pr, int *P, int (*a)[2], int *fpr, omp_lock_t* pmux, int nodes, int arcs, int s, int t)
{
int i, length = 1, j = t, k, l;
int la, maxla, argmaxla, cost, path_cost;
// by OL ******************************************************!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int index = -1;
int cost = -1;
List list = createList();
if(s == t) {
printf("s = t, brak sciezki\n");
return 0;
}
for(i = 0; i < nodes; i++) {
P[i] = INF; //sciezka: dla poszczegolnych wezlow wartosc to pozycja w sciezce
pr[i] = 0; //ceny
}
if(t >= 0 && t <= nodes) {
P[t] = 0;
}
else {
printf("Blad, t musi byc z zakresu 0..MAX-1\n");
printf("%d\n", t);
return 0;
}
if(s < 0 || s > nodes) {
printf("Blad, s musi byc z zakresu 0..MAX-1\n");
printf("%d\n", s);
return 0;
}
//dodanie head do listy **************************************************************************************************************************!!!!!!!!!!!!!
list.add(&list, t);
while(P[s] == INF) {
//sprawdzanie wynikow z innych watkow
if (list.isEmpty(&list) == 0)
{
list->setCurrToHead(&list);
do
{
index = list->getCurr(&list);
if (fpr[index] != INF)
{
//zwraca sume kosztu sciezki do i-tego wezla i policzonej w innym watku sciezki z i-tego do s, konczy prace funkcji
return fpr[index] + list->getCurrValue(&list);
}
} while (list->getNext(&list) != -1);
}
//printf("Sciezka: ");
//for(i = 0; i < nodes; i++) {
// printf("%d ", P[i]);
//}
//printf("\n");
maxla = 0 - INF;
argmaxla = -1;
//printf("j = %d\n", j);
k = -1; //indeks poprzedzajacy luki wychodzace z j w tabeli nettab
for(i = 0; i < nodes+arcs; i++) {
if(a[i][0] == 0 && a[i][1] == j) {
k = i;
//printf("i = %d ", i);
break;
}
}
if(k != -1) {
for(i = k + 1; i < nodes+arcs; i++) {
if(a[i][0] == 0) { //przejrzano juz wszystkie luki
break;
}
l = a[i][0];
la = pr[l] - a[i][1]; //cena - koszt dotarcia do wezla
//printf("la: %d %d %d\n", i, nettab[i][1], la);
//l = nettab[i][0];
if(la > maxla && P[l] == INF) { //pomijane sa te, ktore juz sa w P
//printf("nowy max: %d %d\n", l, a[i][1]);
maxla = la;
argmaxla = l; //numer wezla
cost = a[i][1];
}
}
}
//printf("pr[j] = %d, maxla = %d, argmaxla = %d\n", pr[j], maxla, argmaxla);
if(pr[j] > maxla || maxla == -INF) {
//printf("Contracting path\n");
pr[j] = maxla;
if(j != t) {
P[j] = INF;
// usuwanie wezla i zdejmowanie lock********************************************************************************************!!!!!!!!!!!!!!!!!!!!
list.remove(&list, j);
omp_unset_lock(&(pmux[j]));
length = length - 1;
k = j; //zapamietuje j jako k
for(i = 0; i < nodes; i++) { //wraca do poprzedniego j
if(P[i] == length - 1) {
j = i;
break;
}
}
for(i = 0; i < nodes+arcs; i++) {
if(a[i][0] == 0 && a[i][1] == j) {
break;
}
}
while(1) {
i++;
if(a[i][0] == k) {
path_cost = path_cost - a[i][1];
break;
}
}
}
}
else {
//printf("Extending path\n");
P[argmaxla] = length;
j = argmaxla;
path_cost = path_cost + cost;
// dodawanie wezla do list i ustawianie lock, 0 gdy juz ktos blokuje **************************************************************************!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
lockResult = omp_test_lock(&(pmux[j]));
if (lockResult == 0)
{
//odlokowanie blokowanych wezlow
if (list.isEmpty(&list) == 0)
{
list->setCurrToHead(&list);
do
{
index = list->getCurr(&list);
omp_unset_lock(&(pmux[index]));
} while (list->getNext(&list) != -1);
}
//czyszczenie listy
list->clear(&list);
return -2;
}
else if (lockResult == 1)
{
list->add(&list, j, path_cost);
}
length = length + 1;
if(argmaxla == s)
{
//odlobkowanie wszystkich blokad
if (list.isEmpty(&list) == 0)
{
list->setCurrToHead(&list);
do
{
index = list->getCurr(&list);
omp_unset_lock(&(pmux[index]));
} while (list->getNext(&list) != -1);
}
//wyczyszczenie listy
list->clear(&list);
return path_cost;
}
}
}
return 0;
}
int colvarproxy_lammps::smp_trylock()
{
return omp_test_lock(&smp_lock_state) ? COLVARS_OK : COLVARS_ERROR;
}
