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; }