libgomp/task.c

   1 /* Copyright (C) 2007, 2008, 2009 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->children = NULL;
  45   gomp_sem_init (&task->taskwait_sem, 0);
  46 }
  47
  48 /* Clean up a task, after completing it.  */
  49
  50 void
  51 gomp_end_task (void)
  52 {
  53   struct gomp_thread *thr = gomp_thread ();
  54   struct gomp_task *task = thr->task;
  55
  56   gomp_finish_task (task);
  57   thr->task = task->parent;
  58 }
  59
  60 static inline void
  61 gomp_clear_parent (struct gomp_task *children)
  62 {
  63   struct gomp_task *task = children;
  64
  65   if (task)
  66     do
  67       {
  68         task->parent = NULL;
  69         task = task->next_child;
  70       }
  71     while (task != children);
  72 }
  73
  74 /* Called when encountering an explicit task directive.  If IF_CLAUSE is
  75    false, then we must not delay in executing the task.  If UNTIED is true,
  76    then the task may be executed by any member of the team.  */
  77
  78 void
  79 GOMP_task (void (*fn) (void *), void *data, void (*cpyfn) (void *, void *),
  80            long arg_size, long arg_align, bool if_clause,
  81            unsigned flags __attribute__((unused)))
  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       || team->task_count > 64 * team->nthreads)
  99     {
 100       struct gomp_task task;
 101
 102       gomp_init_task (&task, thr->task, gomp_icv (false));
 103       task.kind = GOMP_TASK_IFFALSE;
 104       if (thr->task)
 105         task.in_tied_task = thr->task->in_tied_task;
 106       thr->task = &task;
 107       if (__builtin_expect (cpyfn != NULL, 0))
 108         {
 109           char buf[arg_size + arg_align - 1];
 110           char *arg = (char *) (((uintptr_t) buf + arg_align - 1)
 111                                 & ~(uintptr_t) (arg_align - 1));
 112           cpyfn (arg, data);
 113           fn (arg);
 114         }
 115       else
 116         fn (data);
 117       if (task.children)
 118         {
 119           gomp_mutex_lock (&team->task_lock);
 120           gomp_clear_parent (task.children);
 121           gomp_mutex_unlock (&team->task_lock);
 122         }
 123       gomp_end_task ();
 124     }
 125   else
 126     {
 127       struct gomp_task *task;
 128       struct gomp_task *parent = thr->task;
 129       char *arg;
 130       bool do_wake;
 131
 132       task = gomp_malloc (sizeof (*task) + arg_size + arg_align - 1);
 133       arg = (char *) (((uintptr_t) (task + 1) + arg_align - 1)
 134                       & ~(uintptr_t) (arg_align - 1));
 135       gomp_init_task (task, parent, gomp_icv (false));
 136       task->kind = GOMP_TASK_IFFALSE;
 137       task->in_tied_task = parent->in_tied_task;
 138       thr->task = task;
 139       if (cpyfn)
 140         cpyfn (arg, data);
 141       else
 142         memcpy (arg, data, arg_size);
 143       thr->task = parent;
 144       task->kind = GOMP_TASK_WAITING;
 145       task->fn = fn;
 146       task->fn_data = arg;
 147       task->in_tied_task = true;
 148       gomp_mutex_lock (&team->task_lock);
 149       if (parent->children)
 150         {
 151           task->next_child = parent->children;
 152           task->prev_child = parent->children->prev_child;
 153           task->next_child->prev_child = task;
 154           task->prev_child->next_child = task;
 155         }
 156       else
 157         {
 158           task->next_child = task;
 159           task->prev_child = task;
 160         }
 161       parent->children = task;
 162       if (team->task_queue)
 163         {
 164           task->next_queue = team->task_queue;
 165           task->prev_queue = team->task_queue->prev_queue;
 166           task->next_queue->prev_queue = task;
 167           task->prev_queue->next_queue = task;
 168         }
 169       else
 170         {
 171           task->next_queue = task;
 172           task->prev_queue = task;
 173           team->task_queue = task;
 174         }
 175       ++team->task_count;
 176       gomp_team_barrier_set_task_pending (&team->barrier);
 177       do_wake = team->task_running_count + !parent->in_tied_task
 178                 < team->nthreads;
 179       gomp_mutex_unlock (&team->task_lock);
 180       if (do_wake)
 181         gomp_team_barrier_wake (&team->barrier, 1);
 182     }
 183 }
 184
 185 void
 186 gomp_barrier_handle_tasks (gomp_barrier_state_t state)
 187 {
 188   struct gomp_thread *thr = gomp_thread ();
 189   struct gomp_team *team = thr->ts.team;
 190   struct gomp_task *task = thr->task;
 191   struct gomp_task *child_task = NULL;
 192   struct gomp_task *to_free = NULL;
 193
 194   gomp_mutex_lock (&team->task_lock);
 195   if (gomp_barrier_last_thread (state))
 196     {
 197       if (team->task_count == 0)
 198         {
 199           gomp_team_barrier_done (&team->barrier, state);
 200           gomp_mutex_unlock (&team->task_lock);
 201           gomp_team_barrier_wake (&team->barrier, 0);
 202           return;
 203         }
 204       gomp_team_barrier_set_waiting_for_tasks (&team->barrier);
 205     }
 206
 207   while (1)
 208     {
 209       if (team->task_queue != NULL)
 210         {
 211           struct gomp_task *parent;
 212
 213           child_task = team->task_queue;
 214           parent = child_task->parent;
 215           if (parent && parent->children == child_task)
 216             parent->children = child_task->next_child;
 217           child_task->prev_queue->next_queue = child_task->next_queue;
 218           child_task->next_queue->prev_queue = child_task->prev_queue;
 219           if (child_task->next_queue != child_task)
 220             team->task_queue = child_task->next_queue;
 221           else
 222             team->task_queue = NULL;
 223           child_task->kind = GOMP_TASK_TIED;
 224           team->task_running_count++;
 225           if (team->task_count == team->task_running_count)
 226             gomp_team_barrier_clear_task_pending (&team->barrier);
 227         }
 228       gomp_mutex_unlock (&team->task_lock);
 229       if (to_free)
 230         {
 231           gomp_finish_task (to_free);
 232           free (to_free);
 233           to_free = NULL;
 234         }
 235       if (child_task)
 236         {
 237           thr->task = child_task;
 238           child_task->fn (child_task->fn_data);
 239           thr->task = task;
 240         }
 241       else
 242         return;
 243       gomp_mutex_lock (&team->task_lock);
 244       if (child_task)
 245         {
 246           struct gomp_task *parent = child_task->parent;
 247           if (parent)
 248             {
 249               child_task->prev_child->next_child = child_task->next_child;
 250               child_task->next_child->prev_child = child_task->prev_child;
 251               if (parent->children == child_task)
 252                 {
 253                   if (child_task->next_child != child_task)
 254                     parent->children = child_task->next_child;
 255                   else
 256                     {
 257                       parent->children = NULL;
 258                       if (parent->in_taskwait)
 259                         gomp_sem_post (&parent->taskwait_sem);
 260                     }
 261                 }
 262             }
 263           gomp_clear_parent (child_task->children);
 264           to_free = child_task;
 265           child_task = NULL;
 266           team->task_running_count--;
 267           if (--team->task_count == 0
 268               && gomp_team_barrier_waiting_for_tasks (&team->barrier))
 269             {
 270               gomp_team_barrier_done (&team->barrier, state);
 271               gomp_mutex_unlock (&team->task_lock);
 272               gomp_team_barrier_wake (&team->barrier, 0);
 273             }
 274         }
 275     }
 276 }
 277
 278 /* Called when encountering a taskwait directive.  */
 279
 280 void
 281 GOMP_taskwait (void)
 282 {
 283   struct gomp_thread *thr = gomp_thread ();
 284   struct gomp_team *team = thr->ts.team;
 285   struct gomp_task *task = thr->task;
 286   struct gomp_task *child_task = NULL;
 287   struct gomp_task *to_free = NULL;
 288
 289   if (task == NULL || task->children == NULL)
 290     return;
 291   gomp_mutex_lock (&team->task_lock);
 292   while (1)
 293     {
 294       if (task->children == NULL)
 295         {
 296           gomp_mutex_unlock (&team->task_lock);
 297           if (to_free)
 298             {
 299               gomp_finish_task (to_free);
 300               free (to_free);
 301             }
 302           return;
 303         }
 304       if (task->children->kind == GOMP_TASK_WAITING)
 305         {
 306           child_task = task->children;
 307           task->children = child_task->next_child;
 308           child_task->prev_queue->next_queue = child_task->next_queue;
 309           child_task->next_queue->prev_queue = child_task->prev_queue;
 310           if (team->task_queue == child_task)
 311             {
 312               if (child_task->next_queue != child_task)
 313                 team->task_queue = child_task->next_queue;
 314               else
 315                 team->task_queue = NULL;
 316             }
 317           child_task->kind = GOMP_TASK_TIED;
 318           team->task_running_count++;
 319           if (team->task_count == team->task_running_count)
 320             gomp_team_barrier_clear_task_pending (&team->barrier);
 321         }
 322       else
 323         /* All tasks we are waiting for are already running
 324            in other threads.  Wait for them.  */
 325         task->in_taskwait = true;
 326       gomp_mutex_unlock (&team->task_lock);
 327       if (to_free)
 328         {
 329           gomp_finish_task (to_free);
 330           free (to_free);
 331           to_free = NULL;
 332         }
 333       if (child_task)
 334         {
 335           thr->task = child_task;
 336           child_task->fn (child_task->fn_data);
 337           thr->task = task;
 338         }
 339       else
 340         {
 341           gomp_sem_wait (&task->taskwait_sem);
 342           task->in_taskwait = false;
 343           return;
 344         }
 345       gomp_mutex_lock (&team->task_lock);
 346       if (child_task)
 347         {
 348           child_task->prev_child->next_child = child_task->next_child;
 349           child_task->next_child->prev_child = child_task->prev_child;
 350           if (task->children == child_task)
 351             {
 352               if (child_task->next_child != child_task)
 353                 task->children = child_task->next_child;
 354               else
 355                 task->children = NULL;
 356             }
 357           gomp_clear_parent (child_task->children);
 358           to_free = child_task;
 359           child_task = NULL;
 360           team->task_count--;
 361           team->task_running_count--;
 362         }
 363     }
 364 }