Esempio n. 1
0
int main ( int argc, char **argv )
{
   int result = 0;
   int i;
   nanos_wd_props_t props = {
     .mandatory_creation = true,
     .tied = false
   };

   int level = omp_get_level();
   int ancestor_num = omp_get_ancestor_thread_num( level );
   int team_size = omp_get_team_size(level);
   int active_level = omp_get_active_level();
   int in_final = omp_in_final();


   printf ( " OpenMP API calls simple test:\n" );
   printf ( "\tomp_get_level() = %d\n", level );
   printf ( "\tomp_get_ancestor_thread_num(%d) = %d\n", level, ancestor_num );
   printf ( "\tomp_get_team_size(%d) = %d\n", level, team_size );
   printf ( "\tomp_get_active_level() = %d\n", active_level );
   printf ( "\tomp_in_final() = %d\n", in_final );

   if ( in_final != 0 )
      result = 1;
   if ( active_level != 0 )
      result = 2;
   if ( level != 0 )
      result = 3;
   if ( ancestor_num != 0 )
      result = 4;

   return result;
}
Esempio n. 2
0
int
test_random_generator()
{
#if !defined(NDEBUG)

    std::cout << std::hex;

    {
        const int first = rand();
        const int second = rand();

        std::cout << first << " " << second << std::endl;
    }

    {
        int random_buffer[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        std::random_shuffle(random_buffer, random_buffer+10);
        for (size_t kk=0; kk<10; kk++)
            std::cout << random_buffer[kk] << " ";
        std::cout << std::endl;
    }

    int total_good = 0;
    int total_bad = 0;
    #pragma omp parallel default(none) shared(std::cout, total_good, total_bad)
    {
        const int first = rand();
        #pragma omp critical
        std::cout << "thread " << omp_get_thread_num() << "/" << omp_get_team_size(1) << " " << omp_get_level() << " " << first << std::endl;
        #pragma omp for
        for (size_t kk=0; kk<10; kk++)
        {
            const int second = rand();
            #pragma omp critical
            std::cout << "  in for " << omp_get_thread_num() << " " << omp_get_level() << " " << second << " " << kk << std::endl;
            called_function(kk);
            #pragma omp atomic update
            total_good++;
            total_bad++;
        }
    }

    std::cout << std::dec;
    std::cout << "good " << total_good << " bad " << total_bad << std::endl;

#endif
    return rand();
}
Esempio n. 3
0
int32_t
omp_get_team_size_8_ (const int64_t *level)
{
  return omp_get_team_size (TO_INT (*level));
}
Esempio n. 4
0
int32_t
omp_get_team_size_ (const int32_t *level)
{
  return omp_get_team_size (*level);
}
Esempio n. 5
0
int
main (void)
{
  int e[3];

  memset (e, '\0', sizeof (e));
  omp_set_nested (1);
  omp_set_dynamic (0);
  if (omp_in_parallel ()
      || omp_get_level () != 0
      || omp_get_ancestor_thread_num (0) != 0
      || omp_get_ancestor_thread_num (-1) != -1
      || omp_get_ancestor_thread_num (1) != -1
      || omp_get_team_size (0) != 1
      || omp_get_team_size (-1) != -1
      || omp_get_team_size (1) != -1
      || omp_get_active_level () != 0)
    abort ();
#pragma omp parallel num_threads (4)
  {
    int tn1 = omp_get_thread_num ();
    if (omp_in_parallel () != 1
	|| omp_get_num_threads () != 4
	|| tn1 >= 4 || tn1 < 0
	|| omp_get_level () != 1
	|| omp_get_ancestor_thread_num (0) != 0
	|| omp_get_ancestor_thread_num (1) != tn1
	|| omp_get_ancestor_thread_num (-1) != -1
	|| omp_get_ancestor_thread_num (2) != -1
	|| omp_get_team_size (0) != 1
	|| omp_get_team_size (1) != omp_get_num_threads ()
	|| omp_get_team_size (-1) != -1
	|| omp_get_team_size (2) != -1
	|| omp_get_active_level () != 1)
      #pragma omp atomic
	e[0] += 1;
    #pragma omp parallel if (0) num_threads(5) firstprivate(tn1)
    {
      int tn2 = omp_get_thread_num ();
      if (omp_in_parallel () != 1
	  || omp_get_num_threads () != 1
	  || tn2 != 0
	  || omp_get_level () != 2
	  || omp_get_ancestor_thread_num (0) != 0
	  || omp_get_ancestor_thread_num (1) != tn1
	  || omp_get_ancestor_thread_num (2) != tn2
	  || omp_get_ancestor_thread_num (-1) != -1
	  || omp_get_ancestor_thread_num (3) != -1
	  || omp_get_team_size (0) != 1
	  || omp_get_team_size (1) != 4
	  || omp_get_team_size (2) != 1
	  || omp_get_team_size (-1) != -1
	  || omp_get_team_size (3) != -1
	  || omp_get_active_level () != 1)
	#pragma omp atomic
	  e[1] += 1;
      #pragma omp parallel num_threads(2) firstprivate(tn1, tn2)
      {
	int tn3 = omp_get_thread_num ();
	if (omp_in_parallel () != 1
	    || omp_get_num_threads () != 2
	    || tn3 > 1 || tn3 < 0
	    || omp_get_level () != 3
	    || omp_get_ancestor_thread_num (0) != 0
	    || omp_get_ancestor_thread_num (1) != tn1
	    || omp_get_ancestor_thread_num (2) != tn2
	    || omp_get_ancestor_thread_num (3) != tn3
	    || omp_get_ancestor_thread_num (-1) != -1
	    || omp_get_ancestor_thread_num (4) != -1
	    || omp_get_team_size (0) != 1
	    || omp_get_team_size (1) != 4
	    || omp_get_team_size (2) != 1
	    || omp_get_team_size (3) != 2
	    || omp_get_team_size (-1) != -1
	    || omp_get_team_size (4) != -1
	    || omp_get_active_level () != 2)
	  #pragma omp atomic
	    e[2] += 1;
      }
    }
  }
  if (e[0] || e[1] || e[2])
    abort ();
  return 0;
}