main ()
{
omp_nest_lock_t lck;
int errors = 0;
omp_init_nest_lock (&lck);
omp_set_nest_lock (&lck);
omp_set_nest_lock (&lck);
omp_unset_nest_lock (&lck);
omp_unset_nest_lock (&lck);
omp_destroy_nest_lock (&lck);
omp_init_nest_lock (&lck);
omp_set_nest_lock (&lck);
omp_unset_nest_lock (&lck);
omp_set_nest_lock (&lck);
omp_set_nest_lock (&lck);
omp_unset_nest_lock (&lck);
omp_unset_nest_lock (&lck);
if (errors == 0) {
printf ("omp_unset_nest_lock 001 : SUCCESS\n");
return 0;
} else {
printf ("omp_unset_nest_lock 001 : FAILED\n");
return 1;
}
}
void POMP2_Set_nest_lock(omp_nest_lock_t *s) {
if ( pomp2_tracing ) {
esd_enter(epk_omp_regid[EPK__OMP_SET_NEST_LOCK]);
omp_set_nest_lock(s);
if ( pomp2_tracing > 1 ) esd_omp_alock(epk_lock_id(s));
esd_exit(epk_omp_regid[EPK__OMP_SET_NEST_LOCK]);
} else {
omp_set_nest_lock(s);
}
}
DEF_FPOMP_FUNC(void POMP_Set_nest_lock_f(omp_nest_lock_t *s)) {
if ( IS_POMP_TRACE_ON ) {
uint64_t time = vt_pform_wtime();
vt_enter(&time, vt_omp_regid[VT__OMP_SET_NEST_LOCK]);
omp_set_nest_lock(s);
time = vt_pform_wtime();
vt_omp_alock(&time, vt_lock_id(s));
vt_exit(&time);
} else {
omp_set_nest_lock(s);
}
} VT_GENERATE_F77_BINDINGS(pomp_set_nest_lock, POMP_SET_NEST_LOCK,
void POMP_Set_nest_lock(omp_nest_lock_t *s) {
if ( IS_POMP_TRACE_ON ) {
uint64_t time = vt_pform_wtime();
vt_enter(&time, vt_omp_regid[VT__OMP_SET_NEST_LOCK]);
omp_set_nest_lock(s);
time = vt_pform_wtime();
vt_omp_alock(&time, vt_lock_id(s));
vt_exit(&time);
} else {
omp_set_nest_lock(s);
}
}
VT_DECLDEF(void POMP_Set_nest_lock_f(omp_nest_lock_t *s)) {
if ( IS_POMP_TRACE_ON ) {
uint64_t time;
time = vt_pform_wtime();
vt_enter(VT_CURRENT_THREAD, &time, vt_omp_regid[VT__OMP_SET_NEST_LOCK]);
omp_set_nest_lock(s);
time = vt_pform_wtime();
vt_exit(VT_CURRENT_THREAD, &time);
} else {
omp_set_nest_lock(s);
}
} VT_GENERATE_F77_BINDINGS(pomp_set_nest_lock, POMP_SET_NEST_LOCK,
/* Exm finalization
* Remove any left over allocations, but we don't destroy the lock--XXX
*/
static void
exm_finalize ()
{
#if defined(DEBUG) || defined(DEBUG1)
syslog (LOG_DEBUG, "finalize READY=%d\n", READY);
#endif
struct map *m, *tmp;
pid_t pid;
omp_set_nest_lock (&lock);
READY = 0;
HASH_ITER (hh, flexmap, m, tmp)
{
#if defined(DEBUG) || defined(DEBUG1)
syslog (LOG_DEBUG, "finalize unmap address %p of size %lu\n", m->addr,
(unsigned long int) m->length);
#endif
munmap (m->addr, m->length);
pid = getpid ();
if (pid == m->pid)
{
#if defined(DEBUG) || defined(DEBUG1)
syslog (LOG_DEBUG, "finalize unlink %p:%s\n", m->addr, m->path);
#endif
unlink (m->path);
HASH_DEL (flexmap, m);
freemap (m);
}
}
int test_omp_nest_lock()
{
int nr_threads_in_single = 0;
int result = 0;
int nr_iterations = 0;
int i;
omp_init_nest_lock(&lck);
#pragma omp parallel shared(lck)
{
#pragma omp for
for(i = 0; i < LOOPCOUNT; i++) {
omp_set_nest_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_nest_lock(&lck);
}
}
omp_destroy_nest_lock(&lck);
return ((result == 0) && (nr_iterations == LOOPCOUNT));
}
main ()
{
omp_nest_lock_t lck;
int t;
int errors = 0;
omp_init_nest_lock (&lck); /* 1st initialize */
omp_set_nest_lock (&lck);
omp_unset_nest_lock (&lck);
omp_destroy_nest_lock (&lck);
omp_init_nest_lock (&lck); /* 2nd initialize */
omp_set_nest_lock (&lck);
omp_unset_nest_lock (&lck);
omp_destroy_nest_lock (&lck);
omp_init_nest_lock (&lck); /* 3rd initialize */
t = omp_test_nest_lock (&lck);
if (t == 0) {
errors += 1;
}
omp_unset_nest_lock (&lck);
omp_destroy_nest_lock (&lck);
omp_init_nest_lock (&lck); /* 4th initialize */
t = omp_test_nest_lock (&lck);
if (t != 1) {
errors += 1;
}
t = omp_test_nest_lock (&lck);
if (t != 2) {
errors += 1;
}
omp_unset_nest_lock (&lck);
omp_unset_nest_lock (&lck);
omp_destroy_nest_lock (&lck);
if (errors == 0) {
printf ("omp_init_nest_lock 001 : SUCCESS\n");
return 0;
} else {
printf ("omp_init_nest_lock 001 : FAILED\n");
return 1;
}
}
void
incr_pair (pair * p, int a, int b)
{
omp_set_nest_lock (&p->lck);
incr_a (p, a);
incr_b (p, b);
omp_unset_nest_lock (&p->lck);
}
int main(void)
{
int i;
int *A = malloc(sizeof(int)*SIZE);
int *B = malloc(sizeof(int)*SIZE);
int *C = malloc(sizeof(int)*SIZE);
for(i=0;i<SIZE; i++)
{
A[i]=i*17%7;
B[i]=i*19%7;
C[i]=0;
}
omp_nest_lock_t lock;
omp_init_nest_lock(&lock);
int somme = 0;
//compute for real!
int j;
for(j=0;j<1; j++) {
debug("loop %d\n", j);
debug("\trunning parallel for schedule(static)\n");
#pragma omp parallel for
for(i=0;i<SIZE; i++)
{
C[i]=A[i]+B[i];
if(i%1000 == 0) {
omp_set_nest_lock(&lock);
compute(10);
{
omp_set_nest_lock(&lock);
compute(10);
omp_unset_nest_lock(&lock);
}
somme+= C[i];
omp_unset_nest_lock(&lock);
}
}
}
debug("somme = %d\n", somme);
return 0;
}
void
incr_b (pair * p, int b)
{
/* Called both from incr_pair and elsewhere, */
/* so need a nestable lock. */
omp_set_nest_lock (&p->lck);
p->b += b;
omp_unset_nest_lock (&p->lck);
}
void
_mp_bcs_nest(void)
{
if (!is_init_nest) {
_mp_p(&nest_sem);
if (!is_init_nest) {
omp_init_nest_lock(&nest_lock);
is_init_nest = 1;
}
_mp_v(&nest_sem);
}
omp_set_nest_lock(&nest_lock);
}
int omp_test_nest_lock ( omp_nest_lock_t *arg )
/******************************************************************************/
/*
Purpose:
OMP_TEST_NEST_LOCK tests a nestable lock.
Discussion:
Calling this routine with an uninitialized lock causes an error.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
17 May 2012
Author:
John Burkardt
Reference:
OpenMP Application Program Interface,
Version 3.1,
July 2011.
Parameters:
Input/output, omp_nest_lock_t *ARG, the nestable lock.
If the lock was initialized but not set, it is set by this call.
Output, int OMP_TEST_NEST_LOCK, returns the new nesting count,
if the call was successful. Otherwise, the value 0 is returned.
*/
{
struct __omp_nest_lock *nlock = ( struct __omp_nest_lock * ) arg;
omp_set_nest_lock ( arg) ;
return nlock->count;
}
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;
}
main ()
{
omp_nest_lock_t lck;
int thds;
volatile int i;
int errors = 0;
thds = omp_get_max_threads ();
if (thds == 1) {
printf ("should be run this program on multi thread.\n");
exit (0);
}
omp_init_nest_lock(&lck);
i = 0;
#pragma omp parallel
{
int tmp;
#pragma omp barrier
omp_set_nest_lock (&lck);
#pragma omp flush (i) /* SCASH need flush, here */
i = i + 1;
tmp = i;
waittime(1);
#pragma omp flush (i) /* SCASH need flush, here */
if (i != tmp) {
#pragma omp critical
errors += 1;
}
omp_set_nest_lock (&lck);
omp_unset_nest_lock (&lck);
waittime(1);
#pragma omp flush (i) /* SCASH need flush, here */
if (i != tmp) {
#pragma omp critical
errors += 1;
}
omp_unset_nest_lock (&lck);
}
if (i != thds) {
errors += 1;
}
if (errors == 0) {
printf ("omp_unset_nest_lock 002 : SUCCESS\n");
return 0;
} else {
printf ("omp_unset_nest_lock 002 : FAILED\n");
return 1;
}
}
int
omp_test_nest_lock(omp_nest_lock_t* nlock)
{
omp_set_nest_lock(nlock);
return nlock->count;
}