dist/libgomp/task.c

166 			 void **depend)
168   size_t ndepend = (uintptr_t) depend[0];
174       /* depend[0] is total # */
175       size_t nout = (uintptr_t) depend[1]; /* # of out: and inout: */
179 	  task->depend[i].addr = depend[2 + i];
180 	  task->depend[i].is_in = i >= nout;
185       ndepend = (uintptr_t) depend[1]; /* total # */
186       size_t nout = (uintptr_t) depend[2]; /* # of out: and inout: */
187       size_t nmutexinoutset = (uintptr_t) depend[3]; /* # of mutexinoutset: */
190       size_t nin = (uintptr_t) depend[4]; /* # of in: */
196 	  void **d = (void **) (uintptr_t) depend[5 + i];
209 	  task->depend[n].addr = d[0];
210 	  task->depend[n++].is_in = 0;
214 	  task->depend[n].addr = depend[5 + i];
215 	  task->depend[n++].is_in = i >= nout + nmutexinoutset;
219 	  void **d = (void **) (uintptr_t) depend[5 + i];
222 	  task->depend[n].addr = d[0];
223 	  task->depend[n++].is_in = 1;
232       task->depend[i].next = NULL;
233       task->depend[i].prev = NULL;
234       task->depend[i].task = task;
235       task->depend[i].redundant = false;
236       task->depend[i].redundant_out = false;
239 					      &task->depend[i], INSERT);
248 	      task->depend[i].redundant = true;
258 	      /* depend(in:...) doesn't depend on earlier depend(in:...).  */
259 	      if (task->depend[i].is_in && ent->is_in)
278 		 depend clause.  */
296 	  task->depend[i].next = *slot;
297 	  (*slot)->prev = &task->depend[i];
299       *slot = &task->depend[i];
301       /* There is no need to store more than one depend({,in}out:) task per
304 	 is enough to record just the last depend({,in}out:).  For depend(in:),
306 	 a later depend({,in}out:) might need to depend on all of them.  So, if
307 	 the new task's clause is depend({,in}out:), we know there is at most
308 	 one other depend({,in}out:) clause in the list (out).  For
312       if (!task->depend[i].is_in && out)
334      if depend[0] is non-zero, then:
335 	depend[0]: number of depend elements.
336 	depend[1]: number of depend elements of type "out/inout".
337 	depend[2..N+1]: address of [1..N]th depend element.
338      otherwise, when depend[0] is zero, then:
339 	depend[1]: number of depend elements.
340 	depend[2]: number of depend elements of type "out/inout".
341 	depend[3]: number of depend elements of type "mutexinoutset".
342 	depend[4]: number of depend elements of type "in".
343 	depend[5..4+depend[2]+depend[3]+depend[4]]: address of depend elements
344 	depend[5+depend[2]+depend[3]+depend[4]..4+depend[1]]: address of
350 	   void **depend, int priority)
392       /* If there are depend clauses and earlier deferred sibling tasks
393 	 with depend clauses, check if there isn't a dependency.  If there
395 	 depend clauses for non-deferred tasks other than this, because
400 	gomp_task_maybe_wait_for_dependencies (depend);
450 	depend_size = ((uintptr_t) (depend[0] ? depend[0] : depend[1])
502 	  gomp_task_handle_depend (task, parent, depend);
505 	      /* Tasks that depend on other tasks are not put into the
680 			 unsigned int flags, void **depend, void **args,
711   if (depend != NULL)
713       depend_cnt = (uintptr_t) (depend[0] ? depend[0] : depend[1]);
746   ttask = (struct gomp_target_task *) &task->depend[depend_cnt];
805       gomp_task_handle_depend (task, parent, depend);
1119     if (!child_task->depend[i].redundant)
1121 	if (child_task->depend[i].next)
1122 	  child_task->depend[i].next->prev = child_task->depend[i].prev;
1123 	if (child_task->depend[i].prev)
1124 	  child_task->depend[i].prev->next = child_task->depend[i].next;
1128 	      = htab_find_slot (&parent->depend_hash, &child_task->depend[i],
1130 	    if (*slot != &child_task->depend[i])
1132 	    if (child_task->depend[i].next)
1133 	      *slot = child_task->depend[i].next;
1577 /* Called when encountering a taskwait directive with depend clause(s).
1581 GOMP_taskwait_depend (void **depend)
1603     gomp_task_maybe_wait_for_dependencies (depend);
1620 gomp_task_maybe_wait_for_dependencies (void **depend)
1627   size_t orig_ndepend = (uintptr_t) depend[0];
1628   size_t nout = (uintptr_t) depend[1];
1641       nout = (uintptr_t) depend[2] + (uintptr_t) depend[3];
1642       normal = nout + (uintptr_t) depend[4];
1648       elem.addr = depend[i + n];