kmp_wait_release.h

/*
 * kmp_wait_release.h -- Wait/Release implementation
 */
 
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef KMP_WAIT_RELEASE_H
#define KMP_WAIT_RELEASE_H
 
#include "kmp.h"
#include "kmp_itt.h"
#include "kmp_stats.h"
#if OMPT_SUPPORT
#include "ompt-specific.h"
#endif
 
struct flag_properties {
  unsigned int type : 16;
  unsigned int reserved : 16;
};
 
template <enum flag_type FlagType> struct flag_traits {};
 
template <> struct flag_traits<flag32> {
  typedef kmp_uint32 flag_t;
  static const flag_type t = flag32;
  static inline flag_t tcr(flag_t f) { return TCR_4(f); }
  static inline flag_t test_then_add4(volatile flag_t *f) {
    return KMP_TEST_THEN_ADD4_32(RCAST(volatile kmp_int32 *, f));
  }
  static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_OR32(f, v);
  }
  static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_AND32(f, v);
  }
};
 
template <> struct flag_traits<atomic_flag64> {
  typedef kmp_uint64 flag_t;
  static const flag_type t = atomic_flag64;
  static inline flag_t tcr(flag_t f) { return TCR_8(f); }
  static inline flag_t test_then_add4(volatile flag_t *f) {
    return KMP_TEST_THEN_ADD4_64(RCAST(volatile kmp_int64 *, f));
  }
  static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_OR64(f, v);
  }
  static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_AND64(f, v);
  }
};
 
template <> struct flag_traits<flag64> {
  typedef kmp_uint64 flag_t;
  static const flag_type t = flag64;
  static inline flag_t tcr(flag_t f) { return TCR_8(f); }
  static inline flag_t test_then_add4(volatile flag_t *f) {
    return KMP_TEST_THEN_ADD4_64(RCAST(volatile kmp_int64 *, f));
  }
  static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_OR64(f, v);
  }
  static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_AND64(f, v);
  }
};
 
template <> struct flag_traits<flag_oncore> {
  typedef kmp_uint64 flag_t;
  static const flag_type t = flag_oncore;
  static inline flag_t tcr(flag_t f) { return TCR_8(f); }
  static inline flag_t test_then_add4(volatile flag_t *f) {
    return KMP_TEST_THEN_ADD4_64(RCAST(volatile kmp_int64 *, f));
  }
  static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_OR64(f, v);
  }
  static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
    return KMP_TEST_THEN_AND64(f, v);
  }
};
 
template <flag_type FlagType> class kmp_flag {
protected:
  flag_properties t; 
  kmp_info_t *waiting_threads[1]; 
  kmp_uint32 num_waiting_threads; 
  std::atomic<bool> *sleepLoc;
 
public:
  typedef flag_traits<FlagType> traits_type;
  kmp_flag() : t({FlagType, 0U}), num_waiting_threads(0), sleepLoc(nullptr) {}
  kmp_flag(int nwaiters)
      : t({FlagType, 0U}), num_waiting_threads(nwaiters), sleepLoc(nullptr) {}
  kmp_flag(std::atomic<bool> *sloc)
      : t({FlagType, 0U}), num_waiting_threads(0), sleepLoc(sloc) {}
  flag_type get_type() { return (flag_type)(t.type); }
 
  kmp_info_t *get_waiter(kmp_uint32 i) {
    KMP_DEBUG_ASSERT(i < num_waiting_threads);
    return waiting_threads[i];
  }
  kmp_uint32 get_num_waiters() { return num_waiting_threads; }
  void set_waiter(kmp_info_t *thr) {
    waiting_threads[0] = thr;
    num_waiting_threads = 1;
  }
  enum barrier_type get_bt() { return bs_last_barrier; }
};
 
template <typename PtrType, flag_type FlagType, bool Sleepable>
class kmp_flag_native : public kmp_flag<FlagType> {
protected:
  volatile PtrType *loc;
  PtrType checker; 
  typedef flag_traits<FlagType> traits_type;
 
public:
  typedef PtrType flag_t;
  kmp_flag_native(volatile PtrType *p) : kmp_flag<FlagType>(), loc(p) {}
  kmp_flag_native(volatile PtrType *p, kmp_info_t *thr)
      : kmp_flag<FlagType>(1), loc(p) {
    this->waiting_threads[0] = thr;
  }
  kmp_flag_native(volatile PtrType *p, PtrType c)
      : kmp_flag<FlagType>(), loc(p), checker(c) {}
  kmp_flag_native(volatile PtrType *p, PtrType c, std::atomic<bool> *sloc)
      : kmp_flag<FlagType>(sloc), loc(p), checker(c) {}
  virtual ~kmp_flag_native() {}
  void *operator new(size_t size) { return __kmp_allocate(size); }
  void operator delete(void *p) { __kmp_free(p); }
  volatile PtrType *get() { return loc; }
  void *get_void_p() { return RCAST(void *, CCAST(PtrType *, loc)); }
  void set(volatile PtrType *new_loc) { loc = new_loc; }
  PtrType load() { return *loc; }
  void store(PtrType val) { *loc = val; }
  virtual bool done_check() {
    if (Sleepable && !(this->sleepLoc))
      return (traits_type::tcr(*(this->get())) & ~KMP_BARRIER_SLEEP_STATE) ==
             checker;
    else
      return traits_type::tcr(*(this->get())) == checker;
  }
  virtual bool done_check_val(PtrType old_loc) { return old_loc == checker; }
  virtual bool notdone_check() {
    return traits_type::tcr(*(this->get())) != checker;
  }
  void internal_release() {
    (void)traits_type::test_then_add4((volatile PtrType *)this->get());
  }
  PtrType set_sleeping() {
    if (this->sleepLoc) {
      this->sleepLoc->store(true);
      return *(this->get());
    }
    return traits_type::test_then_or((volatile PtrType *)this->get(),
                                     KMP_BARRIER_SLEEP_STATE);
  }
  void unset_sleeping() {
    if (this->sleepLoc) {
      this->sleepLoc->store(false);
      return;
    }
    traits_type::test_then_and((volatile PtrType *)this->get(),
                               ~KMP_BARRIER_SLEEP_STATE);
  }
  bool is_sleeping_val(PtrType old_loc) {
    if (this->sleepLoc)
      return this->sleepLoc->load();
    return old_loc & KMP_BARRIER_SLEEP_STATE;
  }
  bool is_sleeping() {
    if (this->sleepLoc)
      return this->sleepLoc->load();
    return is_sleeping_val(*(this->get()));
  }
  bool is_any_sleeping() {
    if (this->sleepLoc)
      return this->sleepLoc->load();
    return is_sleeping_val(*(this->get()));
  }
  kmp_uint8 *get_stolen() { return NULL; }
};
 
template <typename PtrType, flag_type FlagType, bool Sleepable>
class kmp_flag_atomic : public kmp_flag<FlagType> {
protected:
  std::atomic<PtrType> *loc; 
  PtrType checker; 
public:
  typedef flag_traits<FlagType> traits_type;
  typedef PtrType flag_t;
  kmp_flag_atomic(std::atomic<PtrType> *p) : kmp_flag<FlagType>(), loc(p) {}
  kmp_flag_atomic(std::atomic<PtrType> *p, kmp_info_t *thr)
      : kmp_flag<FlagType>(1), loc(p) {
    this->waiting_threads[0] = thr;
  }
  kmp_flag_atomic(std::atomic<PtrType> *p, PtrType c)
      : kmp_flag<FlagType>(), loc(p), checker(c) {}
  kmp_flag_atomic(std::atomic<PtrType> *p, PtrType c, std::atomic<bool> *sloc)
      : kmp_flag<FlagType>(sloc), loc(p), checker(c) {}
  std::atomic<PtrType> *get() { return loc; }
  void *get_void_p() { return RCAST(void *, loc); }
  void set(std::atomic<PtrType> *new_loc) { loc = new_loc; }
  PtrType load() { return loc->load(std::memory_order_acquire); }
  void store(PtrType val) { loc->store(val, std::memory_order_release); }
  bool done_check() {
    if (Sleepable && !(this->sleepLoc))
      return (this->load() & ~KMP_BARRIER_SLEEP_STATE) == checker;
    else
      return this->load() == checker;
  }
  bool done_check_val(PtrType old_loc) { return old_loc == checker; }
  bool notdone_check() { return this->load() != checker; }
  void internal_release() { KMP_ATOMIC_ADD(this->get(), 4); }
  PtrType set_sleeping() {
    if (this->sleepLoc) {
      this->sleepLoc->store(true);
      return *(this->get());
    }
    return KMP_ATOMIC_OR(this->get(), KMP_BARRIER_SLEEP_STATE);
  }
  void unset_sleeping() {
    if (this->sleepLoc) {
      this->sleepLoc->store(false);
      return;
    }
    KMP_ATOMIC_AND(this->get(), ~KMP_BARRIER_SLEEP_STATE);
  }
  bool is_sleeping_val(PtrType old_loc) {
    if (this->sleepLoc)
      return this->sleepLoc->load();
    return old_loc & KMP_BARRIER_SLEEP_STATE;
  }
  bool is_sleeping() {
    if (this->sleepLoc)
      return this->sleepLoc->load();
    return is_sleeping_val(this->load());
  }
  bool is_any_sleeping() {
    if (this->sleepLoc)
      return this->sleepLoc->load();
    return is_sleeping_val(this->load());
  }
  kmp_uint8 *get_stolen() { return NULL; }
};
 
#if OMPT_SUPPORT
OMPT_NOINLINE
static void __ompt_implicit_task_end(kmp_info_t *this_thr,
                                     ompt_state_t ompt_state,
                                     ompt_data_t *tId) {
  int ds_tid = this_thr->th.th_info.ds.ds_tid;
  if (ompt_state == ompt_state_wait_barrier_implicit) {
    this_thr->th.ompt_thread_info.state = ompt_state_overhead;
#if OMPT_OPTIONAL
    void *codeptr = NULL;
    if (ompt_enabled.ompt_callback_sync_region_wait) {
      ompt_callbacks.ompt_callback(ompt_callback_sync_region_wait)(
          ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, tId,
          codeptr);
    }
    if (ompt_enabled.ompt_callback_sync_region) {
      ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
          ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, tId,
          codeptr);
    }
#endif
    if (!KMP_MASTER_TID(ds_tid)) {
      if (ompt_enabled.ompt_callback_implicit_task) {
        int flags = this_thr->th.ompt_thread_info.parallel_flags;
        flags = (flags & ompt_parallel_league) ? ompt_task_initial
                                               : ompt_task_implicit;
        ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
            ompt_scope_end, NULL, tId, 0, ds_tid, flags);
      }
      // return to idle state
      this_thr->th.ompt_thread_info.state = ompt_state_idle;
    } else {
      this_thr->th.ompt_thread_info.state = ompt_state_overhead;
    }
  }
}
#endif
 
/* Spin wait loop that first does pause/yield, then sleep. A thread that calls
   __kmp_wait_*  must make certain that another thread calls __kmp_release
   to wake it back up to prevent deadlocks!
 
   NOTE: We may not belong to a team at this point.  */
template <class C, bool final_spin, bool Cancellable = false,
          bool Sleepable = true>
static inline bool
__kmp_wait_template(kmp_info_t *this_thr,
                    C *flag USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
#if USE_ITT_BUILD && USE_ITT_NOTIFY
  volatile void *spin = flag->get();
#endif
  kmp_uint32 spins;
  int th_gtid;
  int tasks_completed = FALSE;
#if !KMP_USE_MONITOR
  kmp_uint64 poll_count;
  kmp_uint64 hibernate_goal;
#else
  kmp_uint32 hibernate;
#endif
  kmp_uint64 time;
 
  KMP_FSYNC_SPIN_INIT(spin, NULL);
  if (flag->done_check()) {
    KMP_FSYNC_SPIN_ACQUIRED(CCAST(void *, spin));
    return false;
  }
  th_gtid = this_thr->th.th_info.ds.ds_gtid;
  if (Cancellable) {
    kmp_team_t *team = this_thr->th.th_team;
    if (team && team->t.t_cancel_request == cancel_parallel)
      return true;
  }
#if KMP_OS_UNIX
  if (final_spin)
    KMP_ATOMIC_ST_REL(&this_thr->th.th_blocking, true);
#endif
  KA_TRACE(20,
           ("__kmp_wait_sleep: T#%d waiting for flag(%p)\n", th_gtid, flag));
#if KMP_STATS_ENABLED
  stats_state_e thread_state = KMP_GET_THREAD_STATE();
#endif
 
/* OMPT Behavior:
THIS function is called from
  __kmp_barrier (2 times)  (implicit or explicit barrier in parallel regions)
            these have join / fork behavior
 
       In these cases, we don't change the state or trigger events in THIS
function.
       Events are triggered in the calling code (__kmp_barrier):
 
                state := ompt_state_overhead
            barrier-begin
            barrier-wait-begin
                state := ompt_state_wait_barrier
          call join-barrier-implementation (finally arrive here)
          {}
          call fork-barrier-implementation (finally arrive here)
          {}
                state := ompt_state_overhead
            barrier-wait-end
            barrier-end
                state := ompt_state_work_parallel
 
 
  __kmp_fork_barrier  (after thread creation, before executing implicit task)
          call fork-barrier-implementation (finally arrive here)
          {} // worker arrive here with state = ompt_state_idle
 
 
  __kmp_join_barrier  (implicit barrier at end of parallel region)
                state := ompt_state_barrier_implicit
            barrier-begin
            barrier-wait-begin
          call join-barrier-implementation (finally arrive here
final_spin=FALSE)
          {
          }
  __kmp_fork_barrier  (implicit barrier at end of parallel region)
          call fork-barrier-implementation (finally arrive here final_spin=TRUE)
 
       Worker after task-team is finished:
            barrier-wait-end
            barrier-end
            implicit-task-end
            idle-begin
                state := ompt_state_idle
 
       Before leaving, if state = ompt_state_idle
            idle-end
                state := ompt_state_overhead
*/
#if OMPT_SUPPORT
  ompt_state_t ompt_entry_state;
  ompt_data_t *tId;
  if (ompt_enabled.enabled) {
    ompt_entry_state = this_thr->th.ompt_thread_info.state;
    if (!final_spin || ompt_entry_state != ompt_state_wait_barrier_implicit ||
        KMP_MASTER_TID(this_thr->th.th_info.ds.ds_tid)) {
      ompt_lw_taskteam_t *team = NULL;
      if (this_thr->th.th_team)
        team = this_thr->th.th_team->t.ompt_serialized_team_info;
      if (team) {
        tId = &(team->ompt_task_info.task_data);
      } else {
        tId = OMPT_CUR_TASK_DATA(this_thr);
      }
    } else {
      tId = &(this_thr->th.ompt_thread_info.task_data);
    }
    if (final_spin && (__kmp_tasking_mode == tskm_immediate_exec ||
                       this_thr->th.th_task_team == NULL)) {
      // implicit task is done. Either no taskqueue, or task-team finished
      __ompt_implicit_task_end(this_thr, ompt_entry_state, tId);
    }
  }
#endif
 
  KMP_INIT_YIELD(spins); // Setup for waiting
  KMP_INIT_BACKOFF(time);
 
  if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME ||
      __kmp_pause_status == kmp_soft_paused) {
#if KMP_USE_MONITOR
// The worker threads cannot rely on the team struct existing at this point.
// Use the bt values cached in the thread struct instead.
#ifdef KMP_ADJUST_BLOCKTIME
    if (__kmp_pause_status == kmp_soft_paused ||
        (__kmp_zero_bt && !this_thr->th.th_team_bt_set))
      // Force immediate suspend if not set by user and more threads than
      // available procs
      hibernate = 0;
    else
      hibernate = this_thr->th.th_team_bt_intervals;
#else
    hibernate = this_thr->th.th_team_bt_intervals;
#endif /* KMP_ADJUST_BLOCKTIME */
 
    /* If the blocktime is nonzero, we want to make sure that we spin wait for
       the entirety of the specified #intervals, plus up to one interval more.
       This increment make certain that this thread doesn't go to sleep too
       soon.  */
    if (hibernate != 0)
      hibernate++;
 
    // Add in the current time value.
    hibernate += TCR_4(__kmp_global.g.g_time.dt.t_value);
    KF_TRACE(20, ("__kmp_wait_sleep: T#%d now=%d, hibernate=%d, intervals=%d\n",
                  th_gtid, __kmp_global.g.g_time.dt.t_value, hibernate,
                  hibernate - __kmp_global.g.g_time.dt.t_value));
#else
    if (__kmp_pause_status == kmp_soft_paused) {
      // Force immediate suspend
      hibernate_goal = KMP_NOW();
    } else
      hibernate_goal = KMP_NOW() + this_thr->th.th_team_bt_intervals;
    poll_count = 0;
    (void)poll_count;
#endif // KMP_USE_MONITOR
  }
 
  KMP_MB();
 
  // Main wait spin loop
  while (flag->notdone_check()) {
    kmp_task_team_t *task_team = NULL;
    if (__kmp_tasking_mode != tskm_immediate_exec) {
      task_team = this_thr->th.th_task_team;
      /* If the thread's task team pointer is NULL, it means one of 3 things:
         1) A newly-created thread is first being released by
         __kmp_fork_barrier(), and its task team has not been set up yet.
         2) All tasks have been executed to completion.
         3) Tasking is off for this region.  This could be because we are in a
         serialized region (perhaps the outer one), or else tasking was manually
         disabled (KMP_TASKING=0).  */