Runtime support for untied tasks

[jlpeyton]

Summary

Introduced a counter of parts of an untied task submitted for execution. The counter controls whether all parts of the task are already finished. The compiler should generate re-submission of partially executed untied task by itself before exiting of each task part except for the lexical last part.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp.h

 struct kmp_taskdata {                                 /* aligned during dynamic allocation       */
     kmp_int32               td_task_id;               /* id, assigned by debugger                */
     kmp_tasking_flags_t     td_flags;                 /* task flags                              */
     kmp_team_t *            td_team;                  /* team for this task                      */
     kmp_info_p *            td_alloc_thread;          /* thread that allocated data structures   */
                                                       /* Currently not used except for perhaps IDB */
     kmp_taskdata_t *        td_parent;                /* parent task                             */
     kmp_int32               td_level;                 /* task nesting level                      */
+    kmp_int32               td_untied_count;          /* untied task active parts counter        */
     ident_t *               td_ident;                 /* task identifier                         */
                             // Taskwait data.
     ident_t *               td_taskwait_ident;
     kmp_uint32              td_taskwait_counter;
     kmp_int32               td_taskwait_thread;       /* gtid + 1 of thread encountered taskwait */
     KMP_ALIGN_CACHE kmp_internal_control_t  td_icvs;  /* Internal control variables for the task */
     volatile kmp_uint32     td_allocated_child_tasks;  /* Child tasks (+ current task) not yet deallocated */
     volatile kmp_uint32     td_incomplete_child_tasks; /* Child tasks not yet complete */

openmp/trunk/runtime/src/kmp_tasking.c

__kmp_push_task(kmp_int32 gtid, kmp_task_t * task )
     kmp_info_t *        thread = __kmp_threads[ gtid ];
     kmp_taskdata_t *    taskdata = KMP_TASK_TO_TASKDATA(task);
     kmp_task_team_t *   task_team = thread->th.th_task_team;
     kmp_int32           tid = __kmp_tid_from_gtid( gtid );
     kmp_thread_data_t * thread_data;
 
     KA_TRACE(20, ("__kmp_push_task: T#%d trying to push task %p.\n", gtid, taskdata ) );
 
+    if ( taskdata->td_flags.tiedness == TASK_UNTIED ) {
+        // untied task needs to increment counter so that the task structure is not freed prematurely
+        kmp_int32 counter = 1 + KMP_TEST_THEN_INC32(&taskdata->td_untied_count);
+        KA_TRACE(20, ( "__kmp_push_task: T#%d untied_count (%d) incremented for task %p\n",
+                       gtid, counter, taskdata ) );
+    }
+
     // The first check avoids building task_team thread data if serialized
     if ( taskdata->td_flags.task_serial ) {
         KA_TRACE(20, ( "__kmp_push_task: T#%d team serialized; returning TASK_NOT_PUSHED for task %p\n",
                        gtid, taskdata ) );
         return TASK_NOT_PUSHED;
     }
 
     // Now that serialized tasks have returned, we can assume that we are not in immediate exec mode
#ifdef BUILD_TIED_TASK_STACK
     {
         __kmp_push_task_stack( gtid, thread, taskdata );
     }
 #endif /* BUILD_TIED_TASK_STACK */
 
     // mark starting task as executing and as current task
     thread -> th.th_current_task = taskdata;
 
-    KMP_DEBUG_ASSERT( taskdata -> td_flags.started == 0 );
-    KMP_DEBUG_ASSERT( taskdata -> td_flags.executing == 0 );
+    KMP_DEBUG_ASSERT( taskdata->td_flags.started == 0 || taskdata->td_flags.tiedness == TASK_UNTIED );
+    KMP_DEBUG_ASSERT( taskdata->td_flags.executing == 0 || taskdata->td_flags.tiedness == TASK_UNTIED );
     taskdata -> td_flags.started = 1;
     taskdata -> td_flags.executing = 1;
     KMP_DEBUG_ASSERT( taskdata -> td_flags.complete == 0 );
     KMP_DEBUG_ASSERT( taskdata -> td_flags.freed == 0 );
 
     // GEH TODO: shouldn't we pass some sort of location identifier here?
     // APT: yes, we will pass location here.
     // need to store current thread state (in a thread or taskdata structure)

 __kmpc_omp_task_begin_if0( ident_t *loc_ref, kmp_int32 gtid, kmp_task_t * task )
 {
     kmp_taskdata_t * taskdata = KMP_TASK_TO_TASKDATA(task);
     kmp_taskdata_t * current_task = __kmp_threads[ gtid ] -> th.th_current_task;
 
     KA_TRACE(10, ("__kmpc_omp_task_begin_if0(enter): T#%d loc=%p task=%p current_task=%p\n",
                   gtid, loc_ref, taskdata, current_task ) );
 
+    if ( taskdata->td_flags.tiedness == TASK_UNTIED ) {
+        // untied task needs to increment counter so that the task structure is not freed prematurely
+        kmp_int32 counter = 1 + KMP_TEST_THEN_INC32(&taskdata->td_untied_count);
+        KA_TRACE(20, ( "__kmpc_omp_task_begin_if0: T#%d untied_count (%d) incremented for task %p\n",
+                       gtid, counter, taskdata ) );
+    }
+
     taskdata -> td_flags.task_serial = 1;  // Execute this task immediately, not deferred.
     __kmp_task_start( gtid, task, current_task );
 
     KA_TRACE(10, ("__kmpc_omp_task_begin_if0(exit): T#%d loc=%p task=%p,\n",
                   gtid, loc_ref, taskdata ) );
 
     return;
 }
#endif
     // Pop task from stack if tied
 #ifdef BUILD_TIED_TASK_STACK
     if ( taskdata -> td_flags.tiedness == TASK_TIED )
     {
         __kmp_pop_task_stack( gtid, thread, taskdata );
     }
 #endif /* BUILD_TIED_TASK_STACK */
 
+    if ( taskdata->td_flags.tiedness == TASK_UNTIED ) {
+        // untied task needs to check the counter so that the task structure is not freed prematurely
+        kmp_int32 counter = KMP_TEST_THEN_DEC32(&taskdata->td_untied_count) - 1;
+        KA_TRACE(20, ( "__kmp_task_finish: T#%d untied_count (%d) decremented for task %p\n",
+                       gtid, counter, taskdata ) );
+        if ( counter > 0 ) {
+            // untied task is not done, to be continued possibly by other thread, do not free it now
+            if (resumed_task == NULL) {
+                KMP_DEBUG_ASSERT( taskdata->td_flags.task_serial );
+                resumed_task = taskdata->td_parent;  // In a serialized task, the resumed task is the parent
+            }
+            thread->th.th_current_task = resumed_task; // restore current_task
+            resumed_task->td_flags.executing = 1;  // resume previous task
+            KA_TRACE(10, ("__kmp_task_finish(exit): T#%d partially done task %p, resuming task %p\n",
+                          gtid, taskdata, resumed_task) );
+            return;
+        }
+    }
+
     KMP_DEBUG_ASSERT( taskdata -> td_flags.complete == 0 );
     taskdata -> td_flags.complete = 1;   // mark the task as completed
     KMP_DEBUG_ASSERT( taskdata -> td_flags.started == 1 );
     KMP_DEBUG_ASSERT( taskdata -> td_flags.freed == 0 );
 
     // Only need to keep track of count if team parallel and tasking not serialized
     if ( !( taskdata -> td_flags.team_serial || taskdata -> td_flags.tasking_ser ) ) {
         // Predecrement simulated by "- 1" calculation
#endif
     task->routine             = task_entry;
     task->part_id             = 0;      // AC: Always start with 0 part id
 
     taskdata->td_task_id      = KMP_GEN_TASK_ID();
     taskdata->td_team         = team;
     taskdata->td_alloc_thread = thread;
     taskdata->td_parent       = parent_task;
     taskdata->td_level        = parent_task->td_level + 1; // increment nesting level
+    taskdata->td_untied_count = 0;
     taskdata->td_ident        = loc_ref;
     taskdata->td_taskwait_ident   = NULL;
     taskdata->td_taskwait_counter = 0;
     taskdata->td_taskwait_thread  = 0;
     KMP_DEBUG_ASSERT( taskdata->td_parent != NULL );
 #if OMP_41_ENABLED
     // avoid copying icvs for proxy tasks
     if ( flags->proxy == TASK_FULL )