libgomp/task.c

   1 /* Copyright (C) 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
   2    Contributed by Richard Henderson <rth@redhat.com>.
   3
   4    This file is part of the GNU OpenMP Library (libgomp).
   5
   6    Libgomp is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  12    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14    more details.
  15
  16    Under Section 7 of GPL version 3, you are granted additional
  17    permissions described in the GCC Runtime Library Exception, version
  18    3.1, as published by the Free Software Foundation.
  19
  20    You should have received a copy of the GNU General Public License and
  21    a copy of the GCC Runtime Library Exception along with this program;
  22    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23    <http://www.gnu.org/licenses/>.  */
  24
  25 /* This file handles the maintainence of tasks in response to task
  26    creation and termination.  */
  27
  28 #include "libgomp.h"
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32
  33 /* Create a new task data structure.  */
  34
  35 void
  36 gomp_init_task (struct gomp_task *task, struct gomp_task *parent_task,
  37                 struct gomp_task_icv *prev_icv)
  38 {
  39   task->parent = parent_task;
  40   task->icv = *prev_icv;
  41   task->kind = GOMP_TASK_IMPLICIT;
  42   task->in_taskwait = false;
  43   task->in_tied_task = false;
  44   task->final_task = false;
  45   task->children = NULL;
  46   gomp_sem_init (&task->taskwait_sem, 0);
  47 }
  48
  49 /* Clean up a task, after completing it.  */
  50
  51 void
  52 gomp_end_task (void)
  53 {
  54   struct gomp_thread *thr = gomp_thread ();
  55   struct gomp_task *task = thr->task;
  56
  57   gomp_finish_task (task);
  58   thr->task = task->parent;
  59 }
  60
  61 static inline void
  62 gomp_clear_parent (struct gomp_task *children)
  63 {
  64   struct gomp_task *task = children;
  65
  66   if (task)
  67     do
  68       {
  69         task->parent = NULL;
  70         task = task->next_child;
  71       }
  72     while (task != children);
  73 }
  74
  75 /* Called when encountering an explicit task directive.  If IF_CLAUSE is
  76    false, then we must not delay in executing the task.  If UNTIED is true,
  77    then the task may be executed by any member of the team.  */
  78
  79 void
  80 GOMP_task (void (*fn) (void *), void *data, void (*cpyfn) (void *, void *),
  81            long arg_size, long arg_align, bool if_clause, unsigned flags)
  82 {
  83   struct gomp_thread *thr = gomp_thread ();
  84   struct gomp_team *team = thr->ts.team;
  85
  86 #ifdef HAVE_BROKEN_POSIX_SEMAPHORES
  87   /* If pthread_mutex_* is used for omp_*lock*, then each task must be
  88      tied to one thread all the time.  This means UNTIED tasks must be
  89      tied and if CPYFN is non-NULL IF(0) must be forced, as CPYFN
  90      might be running on different thread than FN.  */
  91   if (cpyfn)
  92     if_clause = false;
  93   if (flags & 1)
  94     flags &= ~1;
  95 #endif
  96
  97   if (!if_clause || team == NULL
  98       || (thr->task && thr->task->final_task)
  99       || team->task_count > 64 * team->nthreads)
 100     {
 101       struct gomp_task task;
 102
 103       gomp_init_task (&task, thr->task, gomp_icv (false));
 104       task.kind = GOMP_TASK_IFFALSE;
 105       task.final_task = (thr->task && thr->task->final_task) || (flags & 2);
 106       if (thr->task)
 107         task.in_tied_task = thr->task->in_tied_task;
 108       thr->task = &task;
 109       if (__builtin_expect (cpyfn != NULL, 0))
 110         {
 111           char buf[arg_size + arg_align - 1];
 112           char *arg = (char *) (((uintptr_t) buf + arg_align - 1)
 113                                 & ~(uintptr_t) (arg_align - 1));
 114           cpyfn (arg, data);
 115           fn (arg);
 116         }
 117       else
 118         fn (data);
 119       if (team != NULL)
 120         {
 121           gomp_mutex_lock (&team->task_lock);
 122           if (task.children != NULL)
 123             gomp_clear_parent (task.children);
 124           gomp_mutex_unlock (&team->task_lock);
 125         }
 126       gomp_end_task ();
 127     }
 128   else
 129     {
 130       struct gomp_task *task;
 131       struct gomp_task *parent = thr->task;
 132       char *arg;
 133       bool do_wake;
 134
 135       task = gomp_malloc (sizeof (*task) + arg_size + arg_align - 1);
 136       arg = (char *) (((uintptr_t) (task + 1) + arg_align - 1)
 137                       & ~(uintptr_t) (arg_align - 1));
 138       gomp_init_task (task, parent, gomp_icv (false));
 139       task->kind = GOMP_TASK_IFFALSE;
 140       task->in_tied_task = parent->in_tied_task;
 141       thr->task = task;
 142       if (cpyfn)
 143         cpyfn (arg, data);
 144       else
 145         memcpy (arg, data, arg_size);
 146       thr->task = parent;
 147       task->kind = GOMP_TASK_WAITING;
 148       task->fn = fn;
 149       task->fn_data = arg;
 150       task->in_tied_task = true;
 151       task->final_task = (flags & 2) >> 1;
 152       gomp_mutex_lock (&team->task_lock);
 153       if (parent->children)
 154         {
 155           task->next_child = parent->children;
 156           task->prev_child = parent->children->prev_child;
 157           task->next_child->prev_child = task;
 158           task->prev_child->next_child = task;
 159         }
 160       else
 161         {
 162           task->next_child = task;
 163           task->prev_child = task;
 164         }
 165       parent->children = task;
 166       if (team->task_queue)
 167         {
 168           task->next_queue = team->task_queue;
 169           task->prev_queue = team->task_queue->prev_queue;
 170           task->next_queue->prev_queue = task;
 171           task->prev_queue->next_queue = task;
 172         }
 173       else
 174         {
 175           task->next_queue = task;
 176           task->prev_queue = task;
 177           team->task_queue = task;
 178         }
 179       ++team->task_count;
 180       gomp_team_barrier_set_task_pending (&team->barrier);
 181       do_wake = team->task_running_count + !parent->in_tied_task
 182                 < team->nthreads;
 183       gomp_mutex_unlock (&team->task_lock);
 184       if (do_wake)
 185         gomp_team_barrier_wake (&team->barrier, 1);
 186     }
 187 }
 188
 189 void
 190 gomp_barrier_handle_tasks (gomp_barrier_state_t state)
 191 {
 192   struct gomp_thread *thr = gomp_thread ();
 193   struct gomp_team *team = thr->ts.team;
 194   struct gomp_task *task = thr->task;
 195   struct gomp_task *child_task = NULL;
 196   struct gomp_task *to_free = NULL;
 197
 198   gomp_mutex_lock (&team->task_lock);
 199   if (gomp_barrier_last_thread (state))
 200     {
 201       if (team->task_count == 0)
 202         {
 203           gomp_team_barrier_done (&team->barrier, state);
 204           gomp_mutex_unlock (&team->task_lock);
 205           gomp_team_barrier_wake (&team->barrier, 0);
 206           return;
 207         }
 208       gomp_team_barrier_set_waiting_for_tasks (&team->barrier);
 209     }
 210
 211   while (1)
 212     {
 213       if (team->task_queue != NULL)
 214         {
 215           struct gomp_task *parent;
 216
 217           child_task = team->task_queue;
 218           parent = child_task->parent;
 219           if (parent && parent->children == child_task)
 220             parent->children = child_task->next_child;
 221           child_task->prev_queue->next_queue = child_task->next_queue;
 222           child_task->next_queue->prev_queue = child_task->prev_queue;
 223           if (child_task->next_queue != child_task)
 224             team->task_queue = child_task->next_queue;
 225           else
 226             team->task_queue = NULL;
 227           child_task->kind = GOMP_TASK_TIED;
 228           team->task_running_count++;
 229           if (team->task_count == team->task_running_count)
 230             gomp_team_barrier_clear_task_pending (&team->barrier);
 231         }
 232       gomp_mutex_unlock (&team->task_lock);
 233       if (to_free)
 234         {
 235           gomp_finish_task (to_free);
 236           free (to_free);
 237           to_free = NULL;
 238         }
 239       if (child_task)
 240         {
 241           thr->task = child_task;
 242           child_task->fn (child_task->fn_data);
 243           thr->task = task;
 244         }
 245       else
 246         return;
 247       gomp_mutex_lock (&team->task_lock);
 248       if (child_task)
 249         {
 250           struct gomp_task *parent = child_task->parent;
 251           if (parent)
 252             {
 253               child_task->prev_child->next_child = child_task->next_child;
 254               child_task->next_child->prev_child = child_task->prev_child;
 255               if (parent->children == child_task)
 256                 {
 257                   if (child_task->next_child != child_task)
 258                     parent->children = child_task->next_child;
 259                   else
 260                     {
 261                       parent->children = NULL;
 262                       if (parent->in_taskwait)
 263                         gomp_sem_post (&parent->taskwait_sem);
 264                     }
 265                 }
 266             }
 267           gomp_clear_parent (child_task->children);
 268           to_free = child_task;
 269           child_task = NULL;
 270           team->task_running_count--;
 271           if (--team->task_count == 0
 272               && gomp_team_barrier_waiting_for_tasks (&team->barrier))
 273             {
 274               gomp_team_barrier_done (&team->barrier, state);
 275               gomp_mutex_unlock (&team->task_lock);
 276               gomp_team_barrier_wake (&team->barrier, 0);
 277               gomp_mutex_lock (&team->task_lock);
 278             }
 279         }
 280     }
 281 }
 282
 283 /* Called when encountering a taskwait directive.  */
 284
 285 void
 286 GOMP_taskwait (void)
 287 {
 288   struct gomp_thread *thr = gomp_thread ();
 289   struct gomp_team *team = thr->ts.team;
 290   struct gomp_task *task = thr->task;
 291   struct gomp_task *child_task = NULL;
 292   struct gomp_task *to_free = NULL;
 293
 294   if (task == NULL || team == NULL)
 295     return;
 296
 297   gomp_mutex_lock (&team->task_lock);
 298   while (1)
 299     {
 300       if (task->children == NULL)
 301         {
 302           gomp_mutex_unlock (&team->task_lock);
 303           if (to_free)
 304             {
 305               gomp_finish_task (to_free);
 306               free (to_free);
 307             }
 308           return;
 309         }
 310       if (task->children->kind == GOMP_TASK_WAITING)
 311         {
 312           child_task = task->children;
 313           task->children = child_task->next_child;
 314           child_task->prev_queue->next_queue = child_task->next_queue;
 315           child_task->next_queue->prev_queue = child_task->prev_queue;
 316           if (team->task_queue == child_task)
 317             {
 318               if (child_task->next_queue != child_task)
 319                 team->task_queue = child_task->next_queue;
 320               else
 321                 team->task_queue = NULL;
 322             }
 323           child_task->kind = GOMP_TASK_TIED;
 324           team->task_running_count++;
 325           if (team->task_count == team->task_running_count)
 326             gomp_team_barrier_clear_task_pending (&team->barrier);
 327         }
 328       else
 329         /* All tasks we are waiting for are already running
 330            in other threads.  Wait for them.  */
 331         task->in_taskwait = true;
 332       gomp_mutex_unlock (&team->task_lock);
 333       if (to_free)
 334         {
 335           gomp_finish_task (to_free);
 336           free (to_free);
 337           to_free = NULL;
 338         }
 339       if (child_task)
 340         {
 341           thr->task = child_task;
 342           child_task->fn (child_task->fn_data);
 343           thr->task = task;
 344         }
 345       else
 346         {
 347           gomp_sem_wait (&task->taskwait_sem);
 348           task->in_taskwait = false;
 349           return;
 350         }
 351       gomp_mutex_lock (&team->task_lock);
 352       if (child_task)
 353         {
 354           child_task->prev_child->next_child = child_task->next_child;
 355           child_task->next_child->prev_child = child_task->prev_child;
 356           if (task->children == child_task)
 357             {
 358               if (child_task->next_child != child_task)
 359                 task->children = child_task->next_child;
 360               else
 361                 task->children = NULL;
 362             }
 363           gomp_clear_parent (child_task->children);
 364           to_free = child_task;
 365           child_task = NULL;
 366           team->task_count--;
 367           team->task_running_count--;
 368         }
 369     }
 370 }
 371
 372 /* Called when encountering a taskyield directive.  */
 373
 374 void
 375 GOMP_taskyield (void)
 376 {
 377   /* Nothing at the moment.  */
 378 }
 379
 380 int
 381 omp_in_final (void)
 382 {
 383   struct gomp_thread *thr = gomp_thread ();
 384   return thr->task && thr->task->final_task;
 385 }
 386
 387 ialias (omp_in_final)