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 /* Access to "children" is normally done inside a task_lock 120 mutex region, but the only way this particular task.children 121 can be set is if this thread's task work function (fn) 122 creates children. So since the setter is *this* thread, we 123 need no barriers here when testing for non-NULL. We can have 124 task.children set by the current thread then changed by a 125 child thread, but seeing a stale non-NULL value is not a 126 problem. Once past the task_lock acquisition, this thread 127 will see the real value of task.children. */ 128 if (task.children != NULL) 129 { 130 gomp_mutex_lock (&team->task_lock); 131 gomp_clear_parent (task.children); 132 gomp_mutex_unlock (&team->task_lock); 133 } 134 gomp_end_task (); 135 } 136 else 137 { 138 struct gomp_task *task; 139 struct gomp_task *parent = thr->task; 140 char *arg; 141 bool do_wake; 142 143 task = gomp_malloc (sizeof (*task) + arg_size + arg_align - 1); 144 arg = (char *) (((uintptr_t) (task + 1) + arg_align - 1) 145 & ~(uintptr_t) (arg_align - 1)); 146 gomp_init_task (task, parent, gomp_icv (false)); 147 task->kind = GOMP_TASK_IFFALSE; 148 task->in_tied_task = parent->in_tied_task; 149 thr->task = task; 150 if (cpyfn) 151 cpyfn (arg, data); 152 else 153 memcpy (arg, data, arg_size); 154 thr->task = parent; 155 task->kind = GOMP_TASK_WAITING; 156 task->fn = fn; 157 task->fn_data = arg; 158 task->in_tied_task = true; 159 task->final_task = (flags & 2) >> 1; 160 gomp_mutex_lock (&team->task_lock); 161 if (parent->children) 162 { 163 task->next_child = parent->children; 164 task->prev_child = parent->children->prev_child; 165 task->next_child->prev_child = task; 166 task->prev_child->next_child = task; 167 } 168 else 169 { 170 task->next_child = task; 171 task->prev_child = task; 172 } 173 parent->children = task; 174 if (team->task_queue) 175 { 176 task->next_queue = team->task_queue; 177 task->prev_queue = team->task_queue->prev_queue; 178 task->next_queue->prev_queue = task; 179 task->prev_queue->next_queue = task; 180 } 181 else 182 { 183 task->next_queue = task; 184 task->prev_queue = task; 185 team->task_queue = task; 186 } 187 ++team->task_count; 188 gomp_team_barrier_set_task_pending (&team->barrier); 189 do_wake = team->task_running_count + !parent->in_tied_task 190 < team->nthreads; 191 gomp_mutex_unlock (&team->task_lock); 192 if (do_wake) 193 gomp_team_barrier_wake (&team->barrier, 1); 194 } 195 } 196 197 void 198 gomp_barrier_handle_tasks (gomp_barrier_state_t state) 199 { 200 struct gomp_thread *thr = gomp_thread (); 201 struct gomp_team *team = thr->ts.team; 202 struct gomp_task *task = thr->task; 203 struct gomp_task *child_task = NULL; 204 struct gomp_task *to_free = NULL; 205 206 gomp_mutex_lock (&team->task_lock); 207 if (gomp_barrier_last_thread (state)) 208 { 209 if (team->task_count == 0) 210 { 211 gomp_team_barrier_done (&team->barrier, state); 212 gomp_mutex_unlock (&team->task_lock); 213 gomp_team_barrier_wake (&team->barrier, 0); 214 return; 215 } 216 gomp_team_barrier_set_waiting_for_tasks (&team->barrier); 217 } 218 219 while (1) 220 { 221 if (team->task_queue != NULL) 222 { 223 struct gomp_task *parent; 224 225 child_task = team->task_queue; 226 parent = child_task->parent; 227 if (parent && parent->children == child_task) 228 parent->children = child_task->next_child; 229 child_task->prev_queue->next_queue = child_task->next_queue; 230 child_task->next_queue->prev_queue = child_task->prev_queue; 231 if (child_task->next_queue != child_task) 232 team->task_queue = child_task->next_queue; 233 else 234 team->task_queue = NULL; 235 child_task->kind = GOMP_TASK_TIED; 236 team->task_running_count++; 237 if (team->task_count == team->task_running_count) 238 gomp_team_barrier_clear_task_pending (&team->barrier); 239 } 240 gomp_mutex_unlock (&team->task_lock); 241 if (to_free) 242 { 243 gomp_finish_task (to_free); 244 free (to_free); 245 to_free = NULL; 246 } 247 if (child_task) 248 { 249 thr->task = child_task; 250 child_task->fn (child_task->fn_data); 251 thr->task = task; 252 } 253 else 254 return; 255 gomp_mutex_lock (&team->task_lock); 256 if (child_task) 257 { 258 struct gomp_task *parent = child_task->parent; 259 if (parent) 260 { 261 child_task->prev_child->next_child = child_task->next_child; 262 child_task->next_child->prev_child = child_task->prev_child; 263 if (parent->children == child_task) 264 { 265 if (child_task->next_child != child_task) 266 parent->children = child_task->next_child; 267 else 268 { 269 /* We access task->children in GOMP_taskwait 270 outside of the task lock mutex region, so 271 need a release barrier here to ensure memory 272 written by child_task->fn above is flushed 273 before the NULL is written. */ 274 __atomic_store_n (&parent->children, NULL, 275 MEMMODEL_RELEASE); 276 if (parent->in_taskwait) 277 gomp_sem_post (&parent->taskwait_sem); 278 } 279 } 280 } 281 gomp_clear_parent (child_task->children); 282 to_free = child_task; 283 child_task = NULL; 284 team->task_running_count--; 285 if (--team->task_count == 0 286 && gomp_team_barrier_waiting_for_tasks (&team->barrier)) 287 { 288 gomp_team_barrier_done (&team->barrier, state); 289 gomp_mutex_unlock (&team->task_lock); 290 gomp_team_barrier_wake (&team->barrier, 0); 291 gomp_mutex_lock (&team->task_lock); 292 } 293 } 294 } 295 } 296 297 /* Called when encountering a taskwait directive. */ 298 299 void 300 GOMP_taskwait (void) 301 { 302 struct gomp_thread *thr = gomp_thread (); 303 struct gomp_team *team = thr->ts.team; 304 struct gomp_task *task = thr->task; 305 struct gomp_task *child_task = NULL; 306 struct gomp_task *to_free = NULL; 307 308 /* The acquire barrier on load of task->children here synchronizes 309 with the write of a NULL in gomp_barrier_handle_tasks. It is 310 not necessary that we synchronize with other non-NULL writes at 311 this point, but we must ensure that all writes to memory by a 312 child thread task work function are seen before we exit from 313 GOMP_taskwait. */ 314 if (task == NULL 315 || __atomic_load_n (&task->children, MEMMODEL_ACQUIRE) == NULL) 316 return; 317 318 gomp_mutex_lock (&team->task_lock); 319 while (1) 320 { 321 if (task->children == NULL) 322 { 323 gomp_mutex_unlock (&team->task_lock); 324 if (to_free) 325 { 326 gomp_finish_task (to_free); 327 free (to_free); 328 } 329 return; 330 } 331 if (task->children->kind == GOMP_TASK_WAITING) 332 { 333 child_task = task->children; 334 task->children = child_task->next_child; 335 child_task->prev_queue->next_queue = child_task->next_queue; 336 child_task->next_queue->prev_queue = child_task->prev_queue; 337 if (team->task_queue == child_task) 338 { 339 if (child_task->next_queue != child_task) 340 team->task_queue = child_task->next_queue; 341 else 342 team->task_queue = NULL; 343 } 344 child_task->kind = GOMP_TASK_TIED; 345 team->task_running_count++; 346 if (team->task_count == team->task_running_count) 347 gomp_team_barrier_clear_task_pending (&team->barrier); 348 } 349 else 350 /* All tasks we are waiting for are already running 351 in other threads. Wait for them. */ 352 task->in_taskwait = true; 353 gomp_mutex_unlock (&team->task_lock); 354 if (to_free) 355 { 356 gomp_finish_task (to_free); 357 free (to_free); 358 to_free = NULL; 359 } 360 if (child_task) 361 { 362 thr->task = child_task; 363 child_task->fn (child_task->fn_data); 364 thr->task = task; 365 } 366 else 367 { 368 gomp_sem_wait (&task->taskwait_sem); 369 task->in_taskwait = false; 370 return; 371 } 372 gomp_mutex_lock (&team->task_lock); 373 if (child_task) 374 { 375 child_task->prev_child->next_child = child_task->next_child; 376 child_task->next_child->prev_child = child_task->prev_child; 377 if (task->children == child_task) 378 { 379 if (child_task->next_child != child_task) 380 task->children = child_task->next_child; 381 else 382 task->children = NULL; 383 } 384 gomp_clear_parent (child_task->children); 385 to_free = child_task; 386 child_task = NULL; 387 team->task_count--; 388 team->task_running_count--; 389 } 390 } 391 } 392 393 /* Called when encountering a taskyield directive. */ 394 395 void 396 GOMP_taskyield (void) 397 { 398 /* Nothing at the moment. */ 399 } 400 401 int 402 omp_in_final (void) 403 { 404 struct gomp_thread *thr = gomp_thread (); 405 return thr->task && thr->task->final_task; 406 } 407 408 ialias (omp_in_final) 409