but not yet completed. Once that completes, they will be readded
into the queues as GOMP_TASK_WAITING in order to perform the var
unmapping. */
- GOMP_TASK_ASYNC_RUNNING
+ GOMP_TASK_ASYNC_RUNNING,
+ /* Task that has finished executing but is waiting for its
+ completion event to be fulfilled. */
+ GOMP_TASK_DETACHED
};
struct gomp_task_depend_entry
into the various queues to be scheduled. */
size_t num_dependees;
+ union {
+ /* Valid only if deferred_p is false. */
+ gomp_sem_t *completion_sem;
+ /* Valid only if deferred_p is true. Set to the team that executes the
+ task if the task is detached and the completion event has yet to be
+ fulfilled. */
+ struct gomp_team *detach_team;
+ };
+ bool deferred_p;
+
/* Priority of this task. */
int priority;
/* The priority node for this task in each of the different queues.
entries and the gomp_task in which they reside. */
struct priority_node pnode[3];
- bool detach;
- gomp_sem_t completion_sem;
-
struct gomp_task_icv icv;
void (*fn) (void *);
void *fn_data;
int work_share_cancelled;
int team_cancelled;
- /* Tasks waiting for their completion event to be fulfilled. */
- struct priority_queue task_detach_queue;
+ /* Number of tasks waiting for their completion event to be fulfilled. */
unsigned int task_detach_count;
/* This array contains structures for implicit tasks. */
#include "libgomp.h"
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
#include "gomp-constants.h"
typedef struct gomp_task_depend_entry *hash_entry_type;
benchmark the overhead of creating tasks as there are millions of
tiny tasks created that all run undeferred. */
task->parent = parent_task;
+ priority_queue_init (&task->children_queue);
+ task->taskgroup = NULL;
+ task->dependers = NULL;
+ task->depend_hash = NULL;
+ task->taskwait = NULL;
+ task->depend_count = 0;
+ task->completion_sem = NULL;
+ task->deferred_p = false;
task->icv = *prev_icv;
task->kind = GOMP_TASK_IMPLICIT;
- task->taskwait = NULL;
task->in_tied_task = false;
task->final_task = false;
task->copy_ctors_done = false;
task->parent_depends_on = false;
- priority_queue_init (&task->children_queue);
- task->taskgroup = NULL;
- task->dependers = NULL;
- task->depend_hash = NULL;
- task->depend_count = 0;
- task->detach = false;
}
/* Clean up a task, after completing it. */
}
}
-static bool
-task_fulfilled_p (struct gomp_task *task)
-{
- return gomp_sem_getcount (&task->completion_sem) > 0;
-}
-
/* Called when encountering an explicit task directive. If IF_CLAUSE is
false, then we must not delay in executing the task. If UNTIED is true,
then the task may be executed by any member of the team.
|| team->task_count > 64 * team->nthreads)
{
struct gomp_task task;
+ gomp_sem_t completion_sem;
/* If there are depend clauses and earlier deferred sibling tasks
with depend clauses, check if there isn't a dependency. If there
if ((flags & GOMP_TASK_FLAG_DETACH) != 0)
{
- task.detach = true;
- gomp_sem_init (&task.completion_sem, 0);
- *(void **) detach = &task.completion_sem;
+ gomp_sem_init (&completion_sem, 0);
+ task.completion_sem = &completion_sem;
+ *(void **) detach = &task;
if (data)
- *(void **) data = &task.completion_sem;
+ *(void **) data = &task;
- gomp_debug (0, "New event: %p\n", &task.completion_sem);
+ gomp_debug (0, "Thread %d: new event: %p\n",
+ thr->ts.team_id, &task);
}
if (thr->task)
else
fn (data);
- if (task.detach && !task_fulfilled_p (&task))
- gomp_sem_wait (&task.completion_sem);
+ if ((flags & GOMP_TASK_FLAG_DETACH) != 0)
+ {
+ gomp_sem_wait (&completion_sem);
+ gomp_sem_destroy (&completion_sem);
+ }
/* Access to "children" is normally done inside a task_lock
mutex region, but the only way this particular task.children
task->kind = GOMP_TASK_UNDEFERRED;
task->in_tied_task = parent->in_tied_task;
task->taskgroup = taskgroup;
+ task->deferred_p = true;
if ((flags & GOMP_TASK_FLAG_DETACH) != 0)
{
- task->detach = true;
- gomp_sem_init (&task->completion_sem, 0);
- *(void **) detach = &task->completion_sem;
+ task->detach_team = team;
+
+ *(void **) detach = task;
if (data)
- *(void **) data = &task->completion_sem;
+ *(void **) data = task;
- gomp_debug (0, "New event: %p\n", &task->completion_sem);
+ gomp_debug (0, "Thread %d: new event: %p\n", thr->ts.team_id, task);
}
thr->task = task;
if (cpyfn)
{
bool cancelled = false;
- /* Look for a queued detached task with a fulfilled completion event
- that is ready to finish. */
- child_task = priority_queue_find (PQ_TEAM, &team->task_detach_queue,
- task_fulfilled_p);
- if (child_task)
- {
- priority_queue_remove (PQ_TEAM, &team->task_detach_queue,
- child_task, MEMMODEL_RELAXED);
- --team->task_detach_count;
- gomp_debug (0, "thread %d: found task with fulfilled event %p\n",
- thr->ts.team_id, &child_task->completion_sem);
-
- if (to_free)
- {
- gomp_finish_task (to_free);
- free (to_free);
- to_free = NULL;
- }
- goto finish_cancelled;
- }
-
if (!priority_queue_empty_p (&team->task_queue, MEMMODEL_RELAXED))
{
bool ignored;
team->task_running_count++;
child_task->in_tied_task = true;
}
+ else if (team->task_count == 0
+ && gomp_team_barrier_waiting_for_tasks (&team->barrier))
+ {
+ gomp_team_barrier_done (&team->barrier, state);
+ gomp_mutex_unlock (&team->task_lock);
+ gomp_team_barrier_wake (&team->barrier, 0);
+ if (to_free)
+ {
+ gomp_finish_task (to_free);
+ free (to_free);
+ }
+ return;
+ }
gomp_mutex_unlock (&team->task_lock);
if (do_wake)
{
gomp_mutex_lock (&team->task_lock);
if (child_task)
{
- if (child_task->detach && !task_fulfilled_p (child_task))
+ if (child_task->detach_team)
{
- priority_queue_insert (PQ_TEAM, &team->task_detach_queue,
- child_task, child_task->priority,
- PRIORITY_INSERT_END,
- false, false);
+ assert (child_task->detach_team == team);
+ child_task->kind = GOMP_TASK_DETACHED;
++team->task_detach_count;
- gomp_debug (0, "thread %d: queueing task with event %p\n",
- thr->ts.team_id, &child_task->completion_sem);
+ --team->task_running_count;
+ gomp_debug (0,
+ "thread %d: task with event %p finished without "
+ "completion event fulfilled in team barrier\n",
+ thr->ts.team_id, child_task);
child_task = NULL;
+ continue;
}
- else
+
+ finish_cancelled:;
+ size_t new_tasks
+ = gomp_task_run_post_handle_depend (child_task, team);
+ gomp_task_run_post_remove_parent (child_task);
+ gomp_clear_parent (&child_task->children_queue);
+ gomp_task_run_post_remove_taskgroup (child_task);
+ to_free = child_task;
+ if (!cancelled)
+ team->task_running_count--;
+ child_task = NULL;
+ if (new_tasks > 1)
{
- finish_cancelled:;
- size_t new_tasks
- = gomp_task_run_post_handle_depend (child_task, team);
- gomp_task_run_post_remove_parent (child_task);
- gomp_clear_parent (&child_task->children_queue);
- gomp_task_run_post_remove_taskgroup (child_task);
- to_free = child_task;
- child_task = NULL;
- if (!cancelled)
- team->task_running_count--;
- if (new_tasks > 1)
- {
- do_wake = team->nthreads - team->task_running_count;
- if (do_wake > new_tasks)
- do_wake = new_tasks;
- }
- if (--team->task_count == 0
- && gomp_team_barrier_waiting_for_tasks (&team->barrier))
- {
- gomp_team_barrier_done (&team->barrier, state);
- gomp_mutex_unlock (&team->task_lock);
- gomp_team_barrier_wake (&team->barrier, 0);
- gomp_mutex_lock (&team->task_lock);
- }
+ do_wake = team->nthreads - team->task_running_count;
+ if (do_wake > new_tasks)
+ do_wake = new_tasks;
}
+ --team->task_count;
}
}
}
else
{
/* All tasks we are waiting for are either running in other
- threads, or they are tasks that have not had their
+ threads, are detached and waiting for the completion event to be
+ fulfilled, or they are tasks that have not had their
dependencies met (so they're not even in the queue). Wait
for them. */
if (task->taskwait == NULL)
gomp_mutex_lock (&team->task_lock);
if (child_task)
{
+ if (child_task->detach_team)
+ {
+ assert (child_task->detach_team == team);
+ child_task->kind = GOMP_TASK_DETACHED;
+ ++team->task_detach_count;
+ gomp_debug (0,
+ "thread %d: task with event %p finished without "
+ "completion event fulfilled in taskwait\n",
+ thr->ts.team_id, child_task);
+ child_task = NULL;
+ continue;
+ }
+
finish_cancelled:;
size_t new_tasks
= gomp_task_run_post_handle_depend (child_task, team);
gomp_mutex_lock (&team->task_lock);
if (child_task)
{
+ if (child_task->detach_team)
+ {
+ assert (child_task->detach_team == team);
+ child_task->kind = GOMP_TASK_DETACHED;
+ ++team->task_detach_count;
+ gomp_debug (0,
+ "thread %d: task with event %p finished without "
+ "completion event fulfilled in taskgroup\n",
+ thr->ts.team_id, child_task);
+ child_task = NULL;
+ continue;
+ }
+
finish_cancelled:;
size_t new_tasks
= gomp_task_run_post_handle_depend (child_task, team);
void
omp_fulfill_event (omp_event_handle_t event)
{
- gomp_sem_t *sem = (gomp_sem_t *) event;
- struct gomp_thread *thr = gomp_thread ();
- struct gomp_team *team = thr ? thr->ts.team : NULL;
+ struct gomp_task *task = (struct gomp_task *) event;
+ if (!task->deferred_p)
+ {
+ if (gomp_sem_getcount (task->completion_sem) > 0)
+ gomp_fatal ("omp_fulfill_event: %p event already fulfilled!\n", task);
- if (gomp_sem_getcount (sem) > 0)
- gomp_fatal ("omp_fulfill_event: %p event already fulfilled!\n", sem);
+ gomp_debug (0, "omp_fulfill_event: %p event for undeferred task\n",
+ task);
+ gomp_sem_post (task->completion_sem);
+ return;
+ }
- gomp_debug (0, "omp_fulfill_event: %p\n", sem);
- gomp_sem_post (sem);
- if (team)
- gomp_team_barrier_wake (&team->barrier, 1);
+ struct gomp_team *team = __atomic_load_n (&task->detach_team,
+ MEMMODEL_RELAXED);
+ if (!team)
+ gomp_fatal ("omp_fulfill_event: %p event is invalid or has already "
+ "been fulfilled!\n", task);
+
+ gomp_mutex_lock (&team->task_lock);
+ if (task->kind != GOMP_TASK_DETACHED)
+ {
+ /* The task has not finished running yet. */
+ gomp_debug (0,
+ "omp_fulfill_event: %p event fulfilled for unfinished "
+ "task\n", task);
+ __atomic_store_n (&task->detach_team, NULL, MEMMODEL_RELAXED);
+ gomp_mutex_unlock (&team->task_lock);
+ return;
+ }
+
+ gomp_debug (0, "omp_fulfill_event: %p event fulfilled for finished task\n",
+ task);
+ size_t new_tasks = gomp_task_run_post_handle_depend (task, team);
+ gomp_task_run_post_remove_parent (task);
+ gomp_clear_parent (&task->children_queue);
+ gomp_task_run_post_remove_taskgroup (task);
+ team->task_count--;
+ team->task_detach_count--;
+
+ int do_wake = 0;
+ bool shackled_thread_p = team == gomp_thread ()->ts.team;
+ if (new_tasks > 0)
+ {
+ /* Wake up threads to run new tasks. */
+ do_wake = team->nthreads - team->task_running_count;
+ if (do_wake > new_tasks)
+ do_wake = new_tasks;
+ }
+
+ if (!shackled_thread_p
+ && !do_wake
+ && team->task_detach_count == 0
+ && gomp_team_barrier_waiting_for_tasks (&team->barrier))
+ /* Ensure that at least one thread is woken up to signal that the
+ barrier can finish. */
+ do_wake = 1;
+
+ /* If we are running in an unshackled thread, the team might vanish before
+ gomp_team_barrier_wake is run if we release the lock first, so keep the
+ lock for the call in that case. */
+ if (shackled_thread_p)
+ gomp_mutex_unlock (&team->task_lock);
+ if (do_wake)
+ gomp_team_barrier_wake (&team->barrier, do_wake);
+ if (!shackled_thread_p)
+ gomp_mutex_unlock (&team->task_lock);
+
+ gomp_finish_task (task);
+ free (task);
}
ialias (omp_fulfill_event)
team->work_share_cancelled = 0;
team->team_cancelled = 0;
- priority_queue_init (&team->task_detach_queue);
team->task_detach_count = 0;
return team;
gomp_barrier_destroy (&team->barrier);
gomp_mutex_destroy (&team->task_lock);
priority_queue_free (&team->task_queue);
- priority_queue_free (&team->task_detach_queue);
team_free (team);
}
#pragma omp parallel
#pragma omp single
{
- #pragma omp task detach(detach_event1)
+ #pragma omp task detach (detach_event1)
x++;
- #pragma omp task detach(detach_event2)
+ #pragma omp task detach (detach_event2)
{
y++;
omp_fulfill_event (detach_event1);
--- /dev/null
+/* { dg-do run } */
+
+#include <omp.h>
+#include <assert.h>
+
+/* Test tasks with detach clause on an offload device. Each device
+ thread spawns off a chain of tasks in a taskgroup, that can then
+ be executed by any available thread. */
+
+int main (void)
+{
+ int x = 0, y = 0, z = 0;
+ int thread_count;
+ omp_event_handle_t detach_event1, detach_event2;
+
+ #pragma omp target map (tofrom: x, y, z) map (from: thread_count)
+ #pragma omp parallel private (detach_event1, detach_event2)
+ #pragma omp taskgroup
+ {
+ #pragma omp single
+ thread_count = omp_get_num_threads ();
+
+ #pragma omp task detach (detach_event1) untied
+ #pragma omp atomic update
+ x++;
+
+ #pragma omp task detach (detach_event2) untied
+ {
+ #pragma omp atomic update
+ y++;
+ omp_fulfill_event (detach_event1);
+ }
+
+ #pragma omp task untied
+ {
+ #pragma omp atomic update
+ z++;
+ omp_fulfill_event (detach_event2);
+ }
+ }
+
+ assert (x == thread_count);
+ assert (y == thread_count);
+ assert (z == thread_count);
+}
--- /dev/null
+/* { dg-do run } */
+
+#include <omp.h>
+
+/* Test the detach clause when the task is undeferred. */
+
+int main (void)
+{
+ omp_event_handle_t event;
+
+ #pragma omp task detach (event)
+ omp_fulfill_event (event);
+}
omp_event_handle_t detach_event1, detach_event2;
int x = 0, y = 0, z = 0;
- #pragma omp parallel num_threads(1)
+ #pragma omp parallel num_threads (1)
#pragma omp single
{
- #pragma omp task detach(detach_event1)
+ #pragma omp task detach (detach_event1)
x++;
- #pragma omp task detach(detach_event2)
+ #pragma omp task detach (detach_event2)
{
y++;
omp_fulfill_event (detach_event1);
#pragma omp parallel
#pragma omp single
{
- #pragma omp task depend(out:dep) detach(detach_event)
+ #pragma omp task depend (out:dep) detach (detach_event)
x++;
#pragma omp task
{
y++;
- omp_fulfill_event(detach_event);
+ omp_fulfill_event (detach_event);
}
- #pragma omp task depend(in:dep)
+ #pragma omp task depend (in:dep)
z++;
}
#pragma omp parallel
#pragma omp single
- #pragma omp task detach(detach_event)
+ #pragma omp task detach (detach_event)
{
x++;
- omp_fulfill_event(detach_event);
+ omp_fulfill_event (detach_event);
}
assert (x == 1);
int thread_count;
omp_event_handle_t detach_event1, detach_event2;
- #pragma omp parallel firstprivate(detach_event1, detach_event2)
+ #pragma omp parallel private (detach_event1, detach_event2)
{
#pragma omp single
- thread_count = omp_get_num_threads();
+ thread_count = omp_get_num_threads ();
- #pragma omp task detach(detach_event1) untied
+ #pragma omp task detach (detach_event1) untied
#pragma omp atomic update
x++;
- #pragma omp task detach(detach_event2) untied
+ #pragma omp task detach (detach_event2) untied
{
#pragma omp atomic update
y++;
int thread_count;
omp_event_handle_t detach_event1, detach_event2;
- #pragma omp target map(tofrom: x, y, z) map(from: thread_count)
- #pragma omp parallel firstprivate(detach_event1, detach_event2)
+ #pragma omp target map (tofrom: x, y, z) map (from: thread_count)
+ #pragma omp parallel private (detach_event1, detach_event2)
{
#pragma omp single
- thread_count = omp_get_num_threads();
+ thread_count = omp_get_num_threads ();
#pragma omp task detach(detach_event1) untied
#pragma omp atomic update
z++;
omp_fulfill_event (detach_event2);
}
-
- #pragma omp taskwait
}
assert (x == thread_count);
--- /dev/null
+/* { dg-do run } */
+
+#include <omp.h>
+#include <assert.h>
+
+/* Test tasks with detach clause. Each thread spawns off a chain of tasks,
+ that can then be executed by any available thread. Each thread uses
+ taskwait to wait for the child tasks to complete. */
+
+int main (void)
+{
+ int x = 0, y = 0, z = 0;
+ int thread_count;
+ omp_event_handle_t detach_event1, detach_event2;
+
+ #pragma omp parallel private (detach_event1, detach_event2)
+ {
+ #pragma omp single
+ thread_count = omp_get_num_threads ();
+
+ #pragma omp task detach (detach_event1) untied
+ #pragma omp atomic update
+ x++;
+
+ #pragma omp task detach (detach_event2) untied
+ {
+ #pragma omp atomic update
+ y++;
+ omp_fulfill_event (detach_event1);
+ }
+
+ #pragma omp task untied
+ {
+ #pragma omp atomic update
+ z++;
+ omp_fulfill_event (detach_event2);
+ }
+
+ #pragma omp taskwait
+ }
+
+ assert (x == thread_count);
+ assert (y == thread_count);
+ assert (z == thread_count);
+}
--- /dev/null
+/* { dg-do run } */
+
+#include <omp.h>
+#include <assert.h>
+
+/* Test tasks with detach clause on an offload device. Each device
+ thread spawns off a chain of tasks, that can then be executed by
+ any available thread. Each thread uses taskwait to wait for the
+ child tasks to complete. */
+
+int main (void)
+{
+ int x = 0, y = 0, z = 0;
+ int thread_count;
+ omp_event_handle_t detach_event1, detach_event2;
+
+ #pragma omp target map (tofrom: x, y, z) map (from: thread_count)
+ #pragma omp parallel private (detach_event1, detach_event2)
+ {
+ #pragma omp single
+ thread_count = omp_get_num_threads ();
+
+ #pragma omp task detach (detach_event1) untied
+ #pragma omp atomic update
+ x++;
+
+ #pragma omp task detach (detach_event2) untied
+ {
+ #pragma omp atomic update
+ y++;
+ omp_fulfill_event (detach_event1);
+ }
+
+ #pragma omp task untied
+ {
+ #pragma omp atomic update
+ z++;
+ omp_fulfill_event (detach_event2);
+ }
+
+ #pragma omp taskwait
+ }
+
+ assert (x == thread_count);
+ assert (y == thread_count);
+ assert (z == thread_count);
+}
--- /dev/null
+/* { dg-do run } */
+
+#include <omp.h>
+#include <assert.h>
+
+/* Test tasks with detach clause. Each thread spawns off a chain of tasks
+ in a taskgroup, that can then be executed by any available thread. */
+
+int main (void)
+{
+ int x = 0, y = 0, z = 0;
+ int thread_count;
+ omp_event_handle_t detach_event1, detach_event2;
+
+ #pragma omp parallel private (detach_event1, detach_event2)
+ #pragma omp taskgroup
+ {
+ #pragma omp single
+ thread_count = omp_get_num_threads ();
+
+ #pragma omp task detach (detach_event1) untied
+ #pragma omp atomic update
+ x++;
+
+ #pragma omp task detach (detach_event2) untied
+ {
+ #pragma omp atomic update
+ y++;
+ omp_fulfill_event (detach_event1);
+ }
+
+ #pragma omp task untied
+ {
+ #pragma omp atomic update
+ z++;
+ omp_fulfill_event (detach_event2);
+ }
+ }
+
+ assert (x == thread_count);
+ assert (y == thread_count);
+ assert (z == thread_count);
+}
!$omp parallel
!$omp single
- !$omp task detach(detach_event1)
+ !$omp task detach (detach_event1)
x = x + 1
!$omp end task
- !$omp task detach(detach_event2)
+ !$omp task detach (detach_event2)
y = y + 1
call omp_fulfill_event (detach_event1)
!$omp end task
--- /dev/null
+! { dg-do run }
+
+! Test tasks with detach clause on an offload device. Each device
+! thread spawns off a chain of tasks in a taskgroup, that can then
+! be executed by any available thread.
+
+program task_detach_10
+ use omp_lib
+
+ integer (kind=omp_event_handle_kind) :: detach_event1, detach_event2
+ integer :: x = 0, y = 0, z = 0
+ integer :: thread_count
+
+ !$omp target map (tofrom: x, y, z) map (from: thread_count)
+ !$omp parallel private (detach_event1, detach_event2)
+ !$omp taskgroup
+ !$omp single
+ thread_count = omp_get_num_threads ()
+ !$omp end single
+
+ !$omp task detach (detach_event1) untied
+ !$omp atomic update
+ x = x + 1
+ !$omp end task
+
+ !$omp task detach (detach_event2) untied
+ !$omp atomic update
+ y = y + 1
+ call omp_fulfill_event (detach_event1)
+ !$omp end task
+
+ !$omp task untied
+ !$omp atomic update
+ z = z + 1
+ call omp_fulfill_event (detach_event2)
+ !$omp end task
+ !$omp end taskgroup
+ !$omp end parallel
+ !$omp end target
+
+ if (x /= thread_count) stop 1
+ if (y /= thread_count) stop 2
+ if (z /= thread_count) stop 3
+end program
--- /dev/null
+! { dg-do run }
+
+! Test the detach clause when the task is undeferred.
+
+program task_detach_11
+ use omp_lib
+
+ integer (kind=omp_event_handle_kind) :: detach_event
+
+ !$omp task detach (detach_event)
+ call omp_fulfill_event (detach_event)
+ !$omp end task
+end program
integer (kind=omp_event_handle_kind) :: detach_event1, detach_event2
integer :: x = 0, y = 0, z = 0
- !$omp parallel num_threads(1)
+ !$omp parallel num_threads (1)
!$omp single
- !$omp task detach(detach_event1)
+ !$omp task detach (detach_event1)
x = x + 1
!$omp end task
- !$omp task detach(detach_event2)
+ !$omp task detach (detach_event2)
y = y + 1
call omp_fulfill_event (detach_event1)
!$omp end task
!$omp parallel
!$omp single
- !$omp task depend(out:dep) detach(detach_event)
+ !$omp task depend (out:dep) detach (detach_event)
x = x + 1
!$omp end task
!$omp task
y = y + 1
- call omp_fulfill_event(detach_event)
+ call omp_fulfill_event (detach_event)
!$omp end task
- !$omp task depend(in:dep)
+ !$omp task depend (in:dep)
z = z + 1
!$omp end task
!$omp end single
!$omp parallel
!$omp single
- !$omp task detach(detach_event)
+ !$omp task detach (detach_event)
x = x + 1
- call omp_fulfill_event(detach_event)
+ call omp_fulfill_event (detach_event)
!$omp end task
!$omp end single
!$omp end parallel
integer :: x = 0, y = 0, z = 0
integer :: thread_count
- !$omp parallel firstprivate(detach_event1, detach_event2)
+ !$omp parallel private (detach_event1, detach_event2)
!$omp single
- thread_count = omp_get_num_threads()
+ thread_count = omp_get_num_threads ()
!$omp end single
- !$omp task detach(detach_event1) untied
+ !$omp task detach (detach_event1) untied
!$omp atomic update
x = x + 1
!$omp end task
- !$omp task detach(detach_event2) untied
+ !$omp task detach (detach_event2) untied
!$omp atomic update
y = y + 1
call omp_fulfill_event (detach_event1);
integer :: x = 0, y = 0, z = 0
integer :: thread_count
- !$omp target map(tofrom: x, y, z) map(from: thread_count)
- !$omp parallel firstprivate(detach_event1, detach_event2)
+ !$omp target map (tofrom: x, y, z) map (from: thread_count)
+ !$omp parallel private (detach_event1, detach_event2)
!$omp single
- thread_count = omp_get_num_threads()
+ thread_count = omp_get_num_threads ()
!$omp end single
- !$omp task detach(detach_event1) untied
+ !$omp task detach (detach_event1) untied
!$omp atomic update
x = x + 1
!$omp end task
- !$omp task detach(detach_event2) untied
+ !$omp task detach (detach_event2) untied
!$omp atomic update
y = y + 1
- call omp_fulfill_event (detach_event1);
+ call omp_fulfill_event (detach_event1)
!$omp end task
!$omp task untied
!$omp atomic update
z = z + 1
- call omp_fulfill_event (detach_event2);
+ call omp_fulfill_event (detach_event2)
!$omp end task
-
- !$omp taskwait
!$omp end parallel
!$omp end target
--- /dev/null
+! { dg-do run }
+
+! Test tasks with detach clause. Each thread spawns off a chain of tasks,
+! that can then be executed by any available thread. Each thread uses
+! taskwait to wait for the child tasks to complete.
+
+program task_detach_7
+ use omp_lib
+
+ integer (kind=omp_event_handle_kind) :: detach_event1, detach_event2
+ integer :: x = 0, y = 0, z = 0
+ integer :: thread_count
+
+ !$omp parallel private (detach_event1, detach_event2)
+ !$omp single
+ thread_count = omp_get_num_threads()
+ !$omp end single
+
+ !$omp task detach (detach_event1) untied
+ !$omp atomic update
+ x = x + 1
+ !$omp end task
+
+ !$omp task detach (detach_event2) untied
+ !$omp atomic update
+ y = y + 1
+ call omp_fulfill_event (detach_event1)
+ !$omp end task
+
+ !$omp task untied
+ !$omp atomic update
+ z = z + 1
+ call omp_fulfill_event (detach_event2)
+ !$omp end task
+
+ !$omp taskwait
+ !$omp end parallel
+
+ if (x /= thread_count) stop 1
+ if (y /= thread_count) stop 2
+ if (z /= thread_count) stop 3
+end program
--- /dev/null
+! { dg-do run }
+
+! Test tasks with detach clause on an offload device. Each device
+! thread spawns off a chain of tasks, that can then be executed by
+! any available thread. Each thread uses taskwait to wait for the
+! child tasks to complete.
+
+program task_detach_8
+ use omp_lib
+
+ integer (kind=omp_event_handle_kind) :: detach_event1, detach_event2
+ integer :: x = 0, y = 0, z = 0
+ integer :: thread_count
+
+ !$omp target map (tofrom: x, y, z) map (from: thread_count)
+ !$omp parallel private (detach_event1, detach_event2)
+ !$omp single
+ thread_count = omp_get_num_threads ()
+ !$omp end single
+
+ !$omp task detach (detach_event1) untied
+ !$omp atomic update
+ x = x + 1
+ !$omp end task
+
+ !$omp task detach (detach_event2) untied
+ !$omp atomic update
+ y = y + 1
+ call omp_fulfill_event (detach_event1)
+ !$omp end task
+
+ !$omp task untied
+ !$omp atomic update
+ z = z + 1
+ call omp_fulfill_event (detach_event2)
+ !$omp end task
+
+ !$omp taskwait
+ !$omp end parallel
+ !$omp end target
+
+ if (x /= thread_count) stop 1
+ if (y /= thread_count) stop 2
+ if (z /= thread_count) stop 3
+end program
--- /dev/null
+! { dg-do run }
+
+! Test tasks with detach clause. Each thread spawns off a chain of tasks
+! in a taskgroup, that can then be executed by any available thread.
+
+program task_detach_9
+ use omp_lib
+
+ integer (kind=omp_event_handle_kind) :: detach_event1, detach_event2
+ integer :: x = 0, y = 0, z = 0
+ integer :: thread_count
+
+ !$omp parallel private (detach_event1, detach_event2)
+ !$omp taskgroup
+ !$omp single
+ thread_count = omp_get_num_threads ()
+ !$omp end single
+
+ !$omp task detach (detach_event1) untied
+ !$omp atomic update
+ x = x + 1
+ !$omp end task
+
+ !$omp task detach (detach_event2) untied
+ !$omp atomic update
+ y = y + 1
+ call omp_fulfill_event (detach_event1);
+ !$omp end task
+
+ !$omp task untied
+ !$omp atomic update
+ z = z + 1
+ call omp_fulfill_event (detach_event2);
+ !$omp end task
+ !$omp end taskgroup
+ !$omp end parallel
+
+ if (x /= thread_count) stop 1
+ if (y /= thread_count) stop 2
+ if (z /= thread_count) stop 3
+end program
projects / platform / upstream / gcc.git / commitdiff