Esempio n. 1
0
void __ompc_static_init_4 (int global_id, int sched, int *lower,
                           int *upper, int *stride, int inc, int chunk)
{
  int64_t l = (int64_t) *lower;
  int64_t u = (int64_t) *upper;
  int64_t s;

#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug)
    __pmp_debug("CALLS_DEBUG", "__ompc_static_init_4 global_id=%d with "
                "sched=%d, lower=%d, upper=%d, inc=%d, chunk=%d\n",
                global_id, sched, *lower, *upper, inc, chunk);
#endif

  __pmp_sample(PMP_PROFILE_OMPC_STATIC_INIT_4);

  __pmp_static_init(global_id, sched, &l, &u, &s, inc, chunk);
  *lower = (int) l;
  *upper = (int) u;
  *stride = (int) s;

#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug)
    __pmp_debug("CALLS_DEBUG", "__ompc_static_init_4 global_id=%d returns "
                "lower=%d, upper=%d, stride=%d\n",
                global_id, *lower, *upper, *stride);
#endif
}
Esempio n. 2
0
static void __pmp_shared_catch_segv (pmp_thread_t *thread)
{
  static int32_t installing_segv = 0;
  static int32_t installed_segv = 0;

  /* For Linuxthreads this only needs to be done once, since sigaction's are 
   * shared across all of the pthreads. I arrange for it to be set up by the
   * first worker thread that is woken up. This tranfers SEGV catching
   * responsibility from the serial code in libfoobar to libopenmp as
   * soon as parallelism is employed.
   */

  if (__pmp_atomic_cmpxchg32(&installing_segv, 0, 1) == 0) {
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d "
		"is installing the SEGV handler\n", thread->global_id);
    __pmp_catch_segv();
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d "
		"has installed the SEGV handler\n", thread->global_id);
    installed_segv = 1;
  }
  while (installed_segv == 0) {
    /* USER LEVEL SPIN LOCK */
    __pmp_yield();
  }
}
Esempio n. 3
0
int __ompc_schedule_next_4 (int global_id, int *lower, int *upper,
                            int *inc)
{
  int result;
  int64_t l;
  int64_t u;
  int64_t i;

  __pmp_sample(PMP_PROFILE_OMPC_SCHEDULE_NEXT_4);

  result = __pmp_schedule_next(global_id, &l, &u, &i);

  *lower = (int) l;
  *upper = (int) u;
  *inc = (int) i;

#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug) {
    if (result == 0)
      __pmp_debug("CALLS_DEBUG", "__ompc_schedule_next_4 global_id=%d returns "
                  "result=0\n", global_id);
    else
      __pmp_debug("CALLS_DEBUG", "__ompc_schedule_next_4 global_id=%d returns "
                  "lower=%d, upper=%d, inc=%d, result=%d\n",
                  global_id, *lower, *upper, *inc, result);
  }
#endif

  return result;
}
Esempio n. 4
0
void __ompc_copyin_thdprv (int n, ...)
{
  pmp_global_id_t global_id;

  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_copyin_thdprv: n=%d\n", n);
  __pmp_sample(PMP_PROFILE_OMPC_COPYIN_THDPRV);

  if (__pmp_get_param()->disabled) {
    return;
  }

  global_id = __pmp_get_current_global_id();

  va_list ap;
  va_start(ap, n);
  while (n > 0) {
    void *dst = va_arg(ap, void*);
    void *src = va_arg(ap, void*);
    int size = va_arg(ap, int);
    if (dst != src) {
      __pmp_debug(PMP_DEBUG_THREAD, "__ompc_copyin_thdprv: global_id=%d "
                  "dst: %p, src: %p, size: %d\n", global_id, dst, src, size);
      memcpy(dst, src, size);
    }
    n -= 3;
  }
  va_end(ap);
}
Esempio n. 5
0
static inline void __pmp_thread_wake (pmp_thread_t *thread)
{
  int32_t sync = __pmp_atomic_cmpxchg32(&thread->sync, PMP_SYNC_IDLE,
                                        PMP_SYNC_UNBLOCKED);
  assert(sync != PMP_SYNC_UNBLOCKED);

  if (sync == PMP_SYNC_BLOCKED) {
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d is being signaled\n",
                thread->global_id);

    thread->sync = PMP_SYNC_IDLE;

    assert(thread->tid != -1);

    __pmp_sample(PMP_PROFILE_THREAD_RESCHEDULE);
#if (defined PMP_USE_PTHREAD_SIGNALS)
    if (pthread_kill(thread->pthread_id, SIGPMP) != 0) {
      __pmp_fatal("unable to wake thread using pthread_kill\n");
    }
#elif (defined PMP_NO_NPTL)
    if (kill(thread->tid, SIGPMP) != 0) {
      __pmp_fatal("unable to wake thread using kill\n");
    }
#else
    if (tkill(thread->tid, SIGPMP) != 0) {
      __pmp_fatal("unable to wake thread using tkill\n");
    }
#endif
  }
  else {
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d is woken\n",
                thread->global_id);
  }
}
Esempio n. 6
0
static inline void __pmp_thread_wait (pmp_thread_t *thread)
{
  int32_t sync;
  int thread_spin;
  int i;

  if (thread->sync == PMP_SYNC_UNBLOCKED) {
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d does not block (1)\n",
                thread->global_id);
    thread->sync = PMP_SYNC_IDLE;
    return;
  }

  thread_spin = __pmp_get_param()->thread_spin;

  for (i = 0; i < thread_spin; i++) {
    /* USER LEVEL SPIN LOOP */
    if (thread->sync == PMP_SYNC_UNBLOCKED) {
      __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d does not block (2)\n",
                  thread->global_id);
      thread->sync = PMP_SYNC_IDLE;
      return;
    }
    __pmp_yield();
  }

  sync = __pmp_atomic_cmpxchg32(&thread->sync, PMP_SYNC_IDLE,
                                PMP_SYNC_BLOCKED);

  if (sync == PMP_SYNC_IDLE) {
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d is waiting\n",
                thread->global_id);

    __pmp_sample(PMP_PROFILE_THREAD_DESCHEDULE);

#ifdef PMP_USE_PTHREAD_SIGNALS
    {
      int sig;
      do {
        sigwait(&__pmp_manager.mask_block_sigpmp, &sig);
      } while (sig != SIGPMP);
    }
#else
    sigsuspend(&__pmp_manager.mask_unblock_sigpmp);
    /* NOTE: it is unfortunate that sigsuspend does not tell us which
     *       signal has been raised. */
#endif
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d is awake\n",
                thread->global_id);
  }
  else {
    __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d does not block (3)\n",
                thread->global_id);
    thread->sync = PMP_SYNC_IDLE;
  }
}
Esempio n. 7
0
void __pmp_thread_create_main (void)
{
  pmp_thread_t *thread = __pmp_get_main_thread();
  int global_id;
  global_id = __pmp_idstack_pop(&__pmp_manager.idstack);
  assert(global_id == 0);

  thread->pthread_id = pthread_self();
#ifdef PMP_NO_NPTL
  thread->tid = getpid();
#else
  thread->tid = gettid();
#endif
  thread->local_id = 0;

#ifndef PMP_NO_TLS
#ifdef PMP_TLS_THREAD
  __pmp_tls_current_thread = thread;
#endif
#ifdef PMP_TLS_LOCAL_ID
  __pmp_tls_current_local_id = 0;
#endif
#ifdef PMP_TLS_GLOBAL_ID
  __pmp_tls_current_global_id = thread->global_id;
#endif
#endif

#ifdef PMP_USE_PTHREAD_SIGNALS
  if (pthread_sigmask(SIG_BLOCK, &__pmp_manager.mask_block_sigpmp, 
                      NULL) != 0) {
    __pmp_fatal("unable to set thread-specific sigmask\n");
  }
#else
  if (sigprocmask(SIG_BLOCK, &__pmp_manager.mask_block_sigpmp, NULL) != 0) {
    __pmp_fatal("unable to set thread-specific sigmask\n");
  }
#endif

  if (pthread_setspecific(__pmp_manager.thread_key, (void *) thread) != 0) {
    __pmp_fatal("unable to set thread-specific data\n");
  }

  __pmp_thread_bind(thread);		/* early master bind */

  __pmp_debug(PMP_DEBUG_THREAD, "created main thread global_id %d\n",
              thread->global_id);

  __pmp_debug(PMP_DEBUG_THREAD,
              "__pmp_thread_create_main: tid=%d, pthread_id=0x%08x "
              "global_id=%d, local_id=%d\n",
              (int) thread->tid, (int) thread->pthread_id,
              (int) thread->global_id, (int) thread->local_id);
}
Esempio n. 8
0
void __ompc_fork (int nthreads, workfunc_t work, void *fp)
{
  pmp_thread_t *master = __pmp_get_current_thread();
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_fork nthreads=%d, work=%p, fp=%p "
              " (nesting depth = %d)\n",
              nthreads, work, fp, master->nesting_depth);
  __pmp_sample(PMP_PROFILE_OMPC_FORK);
  __pmp_memory_fence();
  __pmp_thread_fork(master, nthreads, work, fp);
  __pmp_memory_fence();
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_fork completed"
              " (nesting depth = %d)\n",
              master->nesting_depth);
}
Esempio n. 9
0
static inline int __pmp_thread_single (pmp_thread_t *thread)
{
  /* NOTE: the compiler optimizes away OMP singles in the serial code
   * so there is no need to optimize that case here. The case of a team
   * with just one thread is not so common, so don't optimize that path either.
   * The most important case is the n-way single where n > 1. However, it
   * is possible for a thread with no team to call this (e.g. orphaned
   * directive) so in that case one has to check to see if there is a team.
   * TODO: allocate a team of 1 thread in the orphaned case to reduce the
   * amount of special case code throughout the library looking for NULL
   * team pointers. */
  pmp_team_t *team = thread->team;
  if (__pmp_get_team_size(team) == 1) {
    return 1;
  }
  else {
    int32_t thread_count = thread->single_count;
    int32_t team_count = __pmp_atomic_cmpxchg32(&team->single_count,
                                                thread_count, 
                                                thread_count + 1);
    thread->single_count++;
    __pmp_debug(PMP_DEBUG_THREAD, "__pmp_thread_single, local_id %d "
                "thread_count=%d team_count=%d %s\n", 
                thread->local_id, thread_count, team_count, 
                (thread_count == team_count) ? "win" : "lose");
    return (thread_count == team_count);
  }
}
Esempio n. 10
0
static inline void __pmp_thread_barrier (pmp_thread_t *thread)
{
  /* NOTE: the compiler optimizes away OMP barriers in the serial code
   * so there is no need to optimize that case here. The case of a team
   * with just one thread is not so common, so ideally don't optimize 
   * that path either. However, it is currently necessary to check
   * (team != NULL) so one might as well check for the 1-thread team too.
   * The most important case is the n-way barrier where n > 1. */
  pmp_team_t *team = thread->team;
  int team_size = __pmp_get_team_size(team);
  if (team_size > 1) {
    int32_t count = __pmp_atomic_xadd32(&team->barrier_count, -1);
    assert(count > 0);
    __pmp_debug(PMP_DEBUG_THREAD, "thread hits barrier with count of %d\n", 
                (int) count);
    if (count > 1) {
      __pmp_thread_wait(thread);
    }
    else {
      pmp_local_id_t local_id = thread->local_id;
      int i;
      team->barrier_count = team_size;
      for (i = 0; i < team_size; i++) {
        pmp_thread_t *t = team->members[i];
        if (i != local_id) {
          __pmp_thread_wake(t);
        }
      }
    }
  }
}
Esempio n. 11
0
static void __pmp_thread_release (pmp_team_t *team, pmp_thread_t *master)
{
  pmp_local_id_t old_local_id;
  pmp_idstack_t *idstack = &__pmp_manager.idstack;
  int nworkers = team->team_size - 1;
  int i;

  __pmp_lock(master->global_id, &__pmp_manager.idlock);

  for (i = nworkers; i >= 1; i--) {
    pmp_thread_t *thread = team->members[i];

    assert(thread != master);
    old_local_id = thread->local_id;
    thread->local_id = -1;
    thread->team = NULL;

    __pmp_idstack_push(idstack, thread->global_id);

    __pmp_debug(PMP_DEBUG_THREAD,
                "released thread global_id %d from local_id %d "
                "of team at %p\n", 
                thread->global_id, old_local_id, team);
  }

  __pmp_unlock(master->global_id, &__pmp_manager.idlock);

  __pmp_atomic_add32(&__ompc_cur_numthreads, -nworkers);

  __pmp_atomic_xadd32(&__pmp_manager.waiting_threads, nworkers);
}
Esempio n. 12
0
int __pmp_thread_acquire (int nthreads)
{
  int count = 1;	/* count from 1 to ignore master thread */

  /* NOTE - in the typical case this while construct does not loop */

  while (count < nthreads) {
    int required = nthreads - count;
    int waiting = __pmp_atomic_xadd32(&__pmp_manager.waiting_threads,
                                      -required);
    if (waiting >= required) {
      count += required;
      break;
    }
    else {
      count += waiting;
      required -= waiting;
      __pmp_atomic_xadd32(&__pmp_manager.waiting_threads, required);
      if (__pmp_manager_create_more_threads(required) == 0) {
        break;
      }
    }
  }

  __pmp_atomic_add32(&__ompc_cur_numthreads, count - 1);

  __pmp_debug(PMP_DEBUG_THREAD, "acquired %d out of %d threads\n",
              count, nthreads);

  return count;
}
Esempio n. 13
0
static inline void __pmp_thread_master_join (pmp_thread_t *master)
{
  pmp_team_t *team = master->team;
  int32_t count;
  int thread_spin = __pmp_get_param()->thread_spin;
  int i;

  /* NOTE: insert a small spin loop here to try to arrange for the master
   *       to arrive just after the last worker thread. If this happens
   *       then we avoid a much more expensive thread synchronization. */

  for (i = 0; i < thread_spin; i++) {
    /* USER LEVEL SPIN LOOP */
    if (team->working_threads == 1) {
      team->working_threads = 0;
      return;
    }
    __pmp_yield();
  }

  count = __pmp_atomic_xadd32(&team->working_threads, -1);
  __pmp_debug(PMP_DEBUG_THREAD, "master thread joins with count of %d\n", 
              (int) count);
  assert(count >= 1);
  if (count > 1) {
    __pmp_thread_wait(master);
  }
}
Esempio n. 14
0
void __ompc_serialized_parallel (void)
{
  pmp_thread_t *thread = __pmp_get_current_thread();
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_serialized_parallel\n");
  __pmp_sample(PMP_PROFILE_OMPC_SERIALIZED_PARALLEL);
  thread->serialized_parallel++;
}
Esempio n. 15
0
int __ompc_get_thread_num (void)
{
  int global_id = __pmp_get_current_global_id();
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_get_thread_num returns %d\n",global_id);
  __pmp_sample(PMP_PROFILE_OMPC_GET_THREAD_NUM);
  return global_id;
}
Esempio n. 16
0
void __ompc_ordered (int global_id)
{
  pmp_thread_t *thread = __pmp_get_thread(global_id);

  if (__pmp_get_team_size(thread->team) > 1) {
    pmp_loop_t *loop = thread->loop;
    int64_t ticket_number = thread->ticket_number;
    int64_t now_serving;

#ifdef SUPER_DEBUG
    if (Enabled_Libomp_Call_Debug)
      __pmp_debug("CALLS_DEBUG", "__ompc_ordered: global_id=%d\n", global_id);
#endif
    __pmp_sample(PMP_PROFILE_OMPC_ORDERED);

    if (loop == NULL || loop->sched <= PMP_SCHED_ORDERED_OFFSET) {
      __pmp_warning("ordered directives must be used inside ordered "
                    "OpenMP loops\n");
      return;
    }

    assert(loop != NULL);

    now_serving = loop->now_serving;

    if (now_serving != ticket_number) {
      if ((loop->inc >= 0) ? (now_serving > ticket_number) :
                             (now_serving < ticket_number)) {
        __pmp_warning("ordered OpenMP loop may result in program deadlock\n");
        __pmp_warning("maybe due to multiple ordered directives "
                      "in a loop iteration\n");
      }
      while (loop->now_serving != ticket_number) {
        /* USER LEVEL SPIN LOOP */
        __pmp_yield();
      }
    }

#ifdef SUPER_DEBUG
    if (Enabled_Libomp_Loop_Debug)
      __pmp_debug("LOOPS_DEBUG", "__ompc_ordered: now serving global_id=%d "
                  " ticket_number=%" PRId64 "\n", global_id, ticket_number);
#endif
  }

  __pmp_memory_fence();
}
Esempio n. 17
0
int __ompc_master (int global_id)
{
  int master = (__pmp_get_thread(global_id)->local_id == 0);
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_master global_id=%d returns %d\n",
              global_id, master);
  __pmp_sample(PMP_PROFILE_OMPC_MASTER);
  return master;
}
Esempio n. 18
0
int __ompc_single (int global_id)
{
  int result = __pmp_thread_single(__pmp_get_thread(global_id));
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_single global_id=%d returns %d\n", 
              global_id, result);
  __pmp_sample(PMP_PROFILE_OMPC_SINGLE);
  return result;
}
Esempio n. 19
0
void __ompc_barrier (void)
{
  pmp_thread_t *thread = __pmp_get_current_thread();
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_barrier\n");
  __pmp_sample(PMP_PROFILE_OMPC_BARRIER);
  __pmp_memory_fence();
  __pmp_thread_barrier(thread);
}
Esempio n. 20
0
static inline void __pmp_thread_work (pmp_thread_t *thread)
{
  pmp_team_t *team = thread->team;
  assert(team != NULL);

  __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d, local_id %d, "
              "team at %p has lots of work to do now\n", 
              thread->global_id, thread->local_id, team);

  /* NOTE: the id passed to the work function is the global_id. This is
   * passed back to certain library routines as the global_id parameter. 
   * It can be used to find the thread structure very quickly. */
  team->work(thread->global_id, team->fp);

  __pmp_debug(PMP_DEBUG_THREAD, "thread global_id %d, local_id %d, "
              "team at %p has no more work to do\n", 
              thread->global_id, thread->local_id, team);
}
Esempio n. 21
0
void __ompc_static_fini (void)
{
#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug)
    __pmp_debug("CALLS_DEBUG", "__ompc_static_fini\n");
#endif
  __pmp_sample(PMP_PROFILE_OMPC_STATIC_FINI);
  /* no work here, NOTE: does not appear to be called by compiler anyway */
}
Esempio n. 22
0
int __ompc_get_local_thread_num (void)
{
  int local_id = __pmp_get_current_local_id();
  assert(local_id != -1);
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_get_local_thread_num returns %d\n",
              local_id);
  __pmp_sample(PMP_PROFILE_OMPC_GET_LOCAL_THREAD_NUM);
  return local_id;
}
Esempio n. 23
0
int __ompc_in_parallel (void)
{
  pmp_thread_t *thread = __pmp_get_current_thread();
  int in_parallel = (thread->team != NULL) || 
                    (thread->serialized_parallel > 0);
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_in_parallel returns %d\n", in_parallel);
  __pmp_sample(PMP_PROFILE_OMPC_IN_PARALLEL);
  return in_parallel;
}
Esempio n. 24
0
void __ompc_static_init_8 (int global_id, int sched, int64_t *lower,
                           int64_t *upper, int64_t *stride, int64_t inc,
                           int64_t chunk)
{
#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug)
    __pmp_debug("CALLS_DEBUG", "__ompc_static_init_8 global_id=%d with "
                "sched=%d, lower=%" PRId64 ", upper=%" PRId64 ", inc=%" PRId64 ", chunk=%" PRId64 "\n",
                global_id, sched, *lower, *upper, inc, chunk);
#endif
  __pmp_sample(PMP_PROFILE_OMPC_STATIC_INIT_8);
  __pmp_static_init(global_id, sched, lower, upper, stride, inc, chunk);
#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug)
    __pmp_debug("CALLS_DEBUG", "__ompc_static_init_8 global_id=%d returns "
                "lower=%" PRId64 ", upper=%" PRId64 ", stride=%" PRId64 "\n",
                global_id, *lower, *upper, *stride);
#endif
}
Esempio n. 25
0
static inline void __pmp_thread_worker_join (pmp_team_t *team)
{
  int32_t count = __pmp_atomic_xadd32(&team->working_threads, -1);
  __pmp_debug(PMP_DEBUG_THREAD, "worker thread joins with count of %d\n", 
              (int) count);
  assert(count >= 1);
  if (count == 1) {
    __pmp_thread_wake(team->members[0]);
  }
}
Esempio n. 26
0
int __ompc_can_fork (void)
{
  int team_size = __pmp_get_new_team_size();
  int has_forked = (__pmp_get_main_thread()->nesting_depth > 0);
  pmp_param_t *param = __pmp_get_param();
  int serial_outline = param->serial_outline;
  int disabled = param->disabled;
  int can_fork = (team_size > 1 || has_forked || serial_outline) && !disabled;
  __pmp_debug(PMP_DEBUG_CALLS, "__ompc_can_fork returns %d\n", can_fork);
  __pmp_sample(PMP_PROFILE_OMPC_CAN_FORK);
  return can_fork;
}
Esempio n. 27
0
void __pmp_thread_assign (pmp_team_t *team, pmp_thread_t *master, int nthreads)
{
  pmp_idstack_t *idstack = &__pmp_manager.idstack;
  int i;

  __pmp_lock(master->global_id, &__pmp_manager.idlock);

  for (i = 1; i < nthreads; i++) {
    int global_id = __pmp_idstack_pop(idstack);
    pmp_thread_t *thread = __pmp_manager.threads + global_id;

    __pmp_debug(PMP_DEBUG_THREAD,
                "assigning thread global_id %d to local_id %d "
                "of team at %p\n", 
                thread->global_id, i, team);

    assert(thread->global_id == global_id);
    assert(thread->local_id == -1);
    assert(thread->team == NULL);

    thread->local_id = i;
    thread->team = team;
    team->members[i] = thread;

    __pmp_debug(PMP_DEBUG_THREAD,
                "assigned thread global_id %d to local_id %d "
                "of team at %p\n", 
                thread->global_id, thread->local_id, team);
  }

  __pmp_unlock(master->global_id, &__pmp_manager.idlock);

  for (i = 1; i < nthreads; i++) {
    /* This is pulled outside the idlock because waking a thread typically
     * involves an inter-CPU synchronization which is relatively expensive.
     */
    __pmp_thread_wake(team->members[i]);
  }
}
Esempio n. 28
0
void __ompc_scheduler_init_8 (int global_id, int sched, int64_t lower,
                              int64_t upper, int64_t inc, int64_t chunk)
{
#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug)
    __pmp_debug("CALLS_DEBUG", "__ompc_scheduler_init_8 global_id=%d with "
                "sched=%d, lower=%" PRId64 ", upper=%" PRId64 ", inc=%" PRId64 ", chunk=%" PRId64 "\n",
                global_id, sched, lower, upper, inc, chunk);
#endif

  __pmp_sample(PMP_PROFILE_OMPC_SCHEDULER_INIT_8);

  __pmp_scheduler_init(global_id, sched, lower, upper, inc, chunk);
}
Esempio n. 29
0
void __ompc_end_ordered (int global_id)
{
  pmp_thread_t *thread = __pmp_get_thread(global_id);

  __pmp_memory_fence();

  if (__pmp_get_team_size(thread->team) > 1) {
    pmp_loop_t *loop = thread->loop;
    int64_t ticket_number = thread->ticket_number;

#ifdef SUPER_DEBUG
    if (Enabled_Libomp_Call_Debug)
      __pmp_debug("CALLS_DEBUG", "__ompc_end_ordered: global_id=%d\n",
                  global_id);
#endif
    __pmp_sample(PMP_PROFILE_OMPC_END_ORDERED);

    if (loop == NULL || loop->sched <= PMP_SCHED_ORDERED_OFFSET) {
      if (thread->global_id == 0)
        __pmp_warning("ordered directives must be used inside ordered "
                      "OpenMP loops\n");
      return;
    }

    assert(loop != NULL);
    assert(loop->now_serving == ticket_number);

#ifdef SUPER_DEBUG
    if (Enabled_Libomp_Loop_Debug)
      __pmp_debug("LOOPS_DEBUG", "__ompc_ordered: stop serving global_id=%d "
                  " ticket_number=%" PRId64 "\n", global_id, ticket_number);
#endif

    loop->now_serving += loop->inc;
    thread->ticket_number = ticket_number + loop->inc;
  }
}
Esempio n. 30
0
void __ompc_scheduler_init_4 (int global_id, int sched, int lower, int upper,
                              int inc, int chunk)
{
#ifdef SUPER_DEBUG
  if (Enabled_Libomp_Call_Debug)
    __pmp_debug("CALLS_DEBUG", "__ompc_scheduler_init_4 global_id=%d with "
                "sched=%d, lower=%d, upper=%d, inc=%d, chunk=%d\n",
                global_id, sched, lower, upper, inc, chunk);
#endif

  __pmp_sample(PMP_PROFILE_OMPC_SCHEDULER_INIT_4);

  __pmp_scheduler_init(global_id, sched, (int64_t) lower, (int64_t) upper,
                       (int64_t) inc, (int64_t) chunk);
}