OpenMP在gcc里是如何启动的？

• • 图片未显示锁竞争（Lock Contention = 0s），表明 PyTorch 或 MKL 可能绕过 GOMP 的全局任务锁，使用原子操作或分区任务。

/* This structure is used to communicate across pthread_create.  */
struct gomp_thread_start_data
{
void (*fn) (void *);
void *fn_data;
struct gomp_team_state ts;
struct gomp_task *task;
struct gomp_thread_pool *thread_pool;
unsigned int place;
unsigned int num_teams;
unsigned int team_num;
bool nested;
pthread_t handle;
};
/* This function is a pthread_create entry point.  This contains the idle
loop in which a thread waits to be called up to become part of a team.  */
static void *
gomp_thread_start (void *xdata)
{
struct gomp_thread_start_data *data = xdata;
struct gomp_thread *thr;
struct gomp_thread_pool *pool;
void (*local_fn) (void *);
void *local_data;
#if defined HAVE_TLS || defined USE_EMUTLS
thr = &gomp_tls_data;
#else
struct gomp_thread local_thr;
thr = &local_thr;
#endif
gomp_sem_init (&thr->release, 0);
/* Extract what we need from data.  */
local_fn = data->fn;
local_data = data->fn_data;
thr->thread_pool = data->thread_pool;
thr->ts = data->ts;
thr->task = data->task;
thr->place = data->place;
thr->num_teams = data->num_teams;
thr->team_num = data->team_num;
#ifdef GOMP_NEEDS_THREAD_HANDLE
thr->handle = data->handle;
#endif
#if !(defined HAVE_TLS || defined USE_EMUTLS)
pthread_setspecific (gomp_tls_key, thr);
#endif
thr->ts.team->ordered_release[thr->ts.team_id] = &thr->release;
/* Make thread pool local. */
pool = thr->thread_pool;
if (data->nested)
{
struct gomp_team *team = thr->ts.team;
struct gomp_task *task = thr->task;
  gomp_barrier_wait (&team->barrier);

  local_fn (local_data);
  gomp_team_barrier_wait_final (&team->barrier);
  gomp_finish_task (task);
  gomp_barrier_wait_last (&team->barrier);
}
else
{
pool->threads[thr->ts.team_id] = thr;
  gomp_simple_barrier_wait (&pool->threads_dock);
  do
{
  struct gomp_team *team = thr->ts.team;
  struct gomp_task *task = thr->task;

  local_fn (local_data);
  gomp_team_barrier_wait_final (&team->barrier);
  gomp_finish_task (task);

  gomp_simple_barrier_wait (&pool->threads_dock);

  local_fn = thr->fn;
  local_data = thr->data;
  thr->fn = NULL;
}
  while (local_fn);
}
gomp_sem_destroy (&thr->release);
pthread_detach (pthread_self ());
thr->thread_pool = NULL;
thr->task = NULL;
return NULL;
}
#endif

• 适用场景：线程属于顶级并行区域，通常与线程池关联。

• 流程：

  1. 注册线程：将当前线程存储到线程池的 threads 数组中，索引为 team_id。
  2. 初始屏障：调用 gomp_simple_barrier_wait，等待线程池中的所有线程到达 threads_dock 屏障。
  3. 循环执行任务：
     • 执行 local_fn(local_data)，运行分配的并行任务。
     • 调用 gomp_team_barrier_wait_final，等待团队完成任务。
     • 调用 gomp_finish_task，清理任务状态。
     • 再次调用 gomp_simple_barrier_wait，等待线程池分配新任务。
     • 更新 local_fn 和 local_data 从 thr->fn 和 thr->data（可能由线程池分配新任务）。
     • 如果 local_fn 非空，循环继续；否则退出。
  • 线程池重用：非嵌套线程在完成任务后不立即退出，而是等待线程池分配新任务，体现了 OpenMP 的线程池优化。

static inline void
gomp_simple_barrier_wait (gomp_simple_barrier_t *bar)
{
  gomp_barrier_wait (&bar->bar);
}

void
gomp_barrier_wait (gomp_barrier_t *barrier)
{
  gomp_barrier_wait_end (barrier, gomp_barrier_wait_start (barrier));
}

void
gomp_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)
{
  unsigned int n;
if (state & BAR_WAS_LAST)
{
n = —bar->arrived;
if (n > 0)
{
do
gomp_sem_post (&bar->sem1);
while (—n != 0);
gomp_sem_wait (&bar->sem2);
}
gomp_mutex_unlock (&bar->mutex1);
}
else
{
gomp_mutex_unlock (&bar->mutex1);
gomp_sem_wait (&bar->sem1);
#ifdef HAVE_SYNC_BUILTINS
n = __sync_add_and_fetch (&bar->arrived, -1);
#else
gomp_mutex_lock (&bar->mutex2);
n = —bar->arrived;
gomp_mutex_unlock (&bar->mutex2);
#endif
  if (n == 0)
gomp_sem_post (&bar->sem2);
}
}