New implementation of OpenMP 5.0 detached tasks.

[AndreyChurbanov]

Summary

Patch by Alex Duran.

It adds new task flag - detachable (bit 6, or 0x40) which can be set by compiler for a detached task;
new external entry omp_fulfill_event(), and new internal entry __kmpc_task_allow_completion_event().

Tests with samples of expected compiler codegen also provided, they use various timings of event notification versus task completion (before/after task completion, or before task start).

[tlwilmar]

LGTM

[protze.joachim]

Are there any plans to add the code for the appropriate OMPT callbacks?

[protze.joachim]

runtime/test/tasking/kmp_detach_tasks_t1.c

73 ↗

(On Diff #201520)

there is omp_my_sleep.h in runtime/tests/
please consider to use that instead

runtime/test/tasking/kmp_detach_tasks_t3.c

21 ↗

(On Diff #201520)

Is there any reason not to include kmp.h for the definition of the structs?

I know, other tests also define them locally.

[AndreyChurbanov]

Addressed Joachim's comments.

runtime/test/tasking/kmp_detach_tasks_t3.c

21 ↗

(On Diff #201520)

This is general position - make tests independent of the library sources. Presence of the built <binaries + public headers> should be enough to run tests.

[AndreyChurbanov]

In D62485#1549749, @protze.joachim wrote:

Are there any plans to add the code for the appropriate OMPT callbacks?

Haven't thought of this yet. I'd actually appreciate somebody's help here. Who is more familiar with OMPT and with tasking events in particular, and with OMPT tests.

[hbae]

Joachim, do you have any specific OMPT callbacks in mind?
I don't think we have any callbacks to insert in the new code.

[ABataev]

Shall the compiler generate the call of omp_fulfill_event after __kmpc_omp_task call? Or is it a user code?

[AndreyChurbanov]

In D62485#1927773, @ABataev wrote:

Shall the compiler generate the call of omp_fulfill_event after __kmpc_omp_task call? Or is it a user code?

User code supposed to call the omp_fulfill_event to signal completion of the corresponding detached task.

Three tests provided to cover three cases: user called omp_fulfill_event (1) after task body completed execution, (2) possibly during execution of the task, and (3) before the task was scheduled for execution.

[ABataev]

In D62485#1928438, @AndreyChurbanov wrote:

In D62485#1927773, @ABataev wrote:

Shall the compiler generate the call of omp_fulfill_event after __kmpc_omp_task call? Or is it a user code?

User code supposed to call the omp_fulfill_event to signal completion of the corresponding detached task.

Three tests provided to cover three cases: user called omp_fulfill_event (1) after task body completed execution, (2) possibly during execution of the task, and (3) before the task was scheduled for execution.

Thanks for the clarification! This is what I thought.

[protze.joachim]

In D62485#1550157, @hbae wrote:

Joachim, do you have any specific OMPT callbacks in mind?
I don't think we have any callbacks to insert in the new code.

Sorry for the late reply.
Two changes are necessary:

• __ompt_task_finish should only set ompt_task_complete, if the task is complete (probably move the call after the bit is updated). Otherwise ompt_task_switchshould be used.
• The task-fulfill event needs implementation (see omp_fulfill_event).

openmp/trunk/runtime/src/dllexports

%ifdef OMP_50
         __kmpc_task_reduction_init          268
         __kmpc_task_reduction_get_th_data   269
 # USED FOR 4.5 __kmpc_critical_with_hint    270
         __kmpc_get_target_offload           271
         __kmpc_omp_reg_task_with_affinity   272
         __kmpc_pause_resource               273
         __kmpc_task_reduction_modifier_init 274
         __kmpc_task_reduction_modifier_fini 275
-      # __kmpc_task_allow_completion_event  276
+        __kmpc_task_allow_completion_event  276
         __kmpc_taskred_init                 277
         __kmpc_taskred_modifier_init        278
     %endif
 %endif
 
 # User API entry points that have both lower- and upper- case versions for Fortran.
 # Number for lowercase version is indicated.  Number for uppercase is obtained by adding 1000.
 # User API entry points are entry points that start with 'kmp_' or 'omp_'.
%ifdef OMP_50
     omp_capture_affinity                    751
     ompc_set_affinity_format                752
     ompc_get_affinity_format                753
     ompc_display_affinity                   754
     ompc_capture_affinity                   755
     omp_pause_resource                      756
     omp_pause_resource_all                  757
     omp_get_supported_active_levels         758
+    omp_fulfill_event                       759
 
     omp_null_allocator                     DATA
     omp_default_mem_alloc                  DATA
     omp_large_cap_mem_alloc                DATA
     omp_const_mem_alloc                    DATA
     omp_high_bw_mem_alloc                  DATA
     omp_low_lat_mem_alloc                  DATA
     omp_cgroup_mem_alloc                   DATA

openmp/trunk/runtime/src/include/50/omp.h.var

 #   endif
 
     /* OpenMP 5.0 Affinity Format */
     extern void __KAI_KMPC_CONVENTION omp_set_affinity_format(char const *);
     extern size_t __KAI_KMPC_CONVENTION omp_get_affinity_format(char *, size_t);
     extern void __KAI_KMPC_CONVENTION omp_display_affinity(char const *);
     extern size_t __KAI_KMPC_CONVENTION omp_capture_affinity(char *, size_t, char const *);
 
+    /* OpenMP 5.0 events */
+#   if defined(_WIN32)
+    // On Windows cl and icl do not support 64-bit enum, let's use integer then.
+    typedef omp_uintptr_t omp_event_handle_t;
+#   else
+    typedef enum omp_event_handle_t { KMP_EVENT_MAX_HANDLE = UINTPTR_MAX } omp_event_handle_t;
+#   endif
+    extern void __KAI_KMPC_CONVENTION omp_fulfill_event ( omp_event_handle_t event );
+
     /* OpenMP 5.0 Pause Resources */
     typedef enum omp_pause_resource_t {
       omp_pause_resume = 0,
       omp_pause_soft = 1,
       omp_pause_hard = 2
     } omp_pause_resource_t;
     extern int __KAI_KMPC_CONVENTION omp_pause_resource(omp_pause_resource_t, int);
     extern int __KAI_KMPC_CONVENTION omp_pause_resource_all(omp_pause_resource_t);

openmp/trunk/runtime/src/include/50/omp_lib.h.var

!
       integer omp_alloctrait_key_kind
       parameter(omp_alloctrait_key_kind=omp_integer_kind)
       integer omp_alloctrait_val_kind
       parameter(omp_alloctrait_val_kind=int_ptr_kind())
       integer omp_pause_resource_kind
       parameter(omp_pause_resource_kind=omp_integer_kind)
       integer omp_depend_kind
       parameter(omp_depend_kind=int_ptr_kind())
+      integer omp_event_handle_kind
+      parameter(omp_event_handle_kind=int_ptr_kind())
 
       integer(kind=omp_integer_kind)openmp_version
       parameter(openmp_version=@LIBOMP_OMP_YEAR_MONTH@)
       integer(kind=omp_integer_kind)kmp_version_major
       parameter(kmp_version_major=@LIBOMP_VERSION_MAJOR@)
       integer(kind=omp_integer_kind)kmp_version_minor
       parameter(kmp_version_minor=@LIBOMP_VERSION_MINOR@)
       integer(kind=omp_integer_kind)kmp_version_build
!       ***
           integer (kind=omp_integer_kind) omp_pause_resource_all
         end function omp_pause_resource_all
 
         function omp_get_supported_active_levels() bind(c)
           import
           integer (kind=omp_integer_kind) omp_get_supported_active_levels
         end function omp_get_supported_active_levels
 
+        subroutine omp_fulfill_event(event) bind(c)
+          import
+          integer (kind=omp_event_handle_kind), value :: event
+        end subroutine omp_fulfill_event
+
         subroutine omp_init_lock(svar) bind(c)
 !DIR$ IF(__INTEL_COMPILER.GE.1400)
 !DIR$ attributes known_intrinsic :: omp_init_lock
 !DIR$ ENDIF
           import
           integer (kind=omp_lock_kind) svar
         end subroutine omp_init_lock
 

 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_default_device
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_is_initial_device
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_initial_device
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_num_devices
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_device_num
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_pause_resource
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_pause_resource_all
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_supported_active_levels
+!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_fulfill_event
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_num_teams
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_team_num
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_init_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_destroy_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_unset_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_test_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_init_nest_lock

 !$omp declare target(omp_set_default_device )
 !$omp declare target(omp_is_initial_device )
 !$omp declare target(omp_get_initial_device )
 !$omp declare target(omp_get_num_devices )
 !$omp declare target(omp_get_device_num )
 !$omp declare target(omp_pause_resource )
 !$omp declare target(omp_pause_resource_all )
 !$omp declare target(omp_get_supported_active_levels )
+!$omp declare target(omp_fulfill_event)
 !$omp declare target(omp_get_num_teams )
 !$omp declare target(omp_get_team_num )
 !$omp declare target(omp_init_lock )
 !$omp declare target(omp_destroy_lock )
 !$omp declare target(omp_set_lock )
 !$omp declare target(omp_unset_lock )
 !$omp declare target(omp_test_lock )
 !$omp declare target(omp_init_nest_lock )

openmp/trunk/runtime/src/include/50/omp_lib.f.var

!dec$ fixedformlinesize:132
 
         type omp_alloctrait
           integer(kind=omp_alloctrait_key_kind) key
           integer(kind=omp_alloctrait_val_kind) value
         end type omp_alloctrait
 
         integer, parameter :: omp_pause_resource_kind = omp_integer_kind
         integer, parameter :: omp_depend_kind = int_ptr_kind()
+        integer, parameter :: omp_event_handle_kind = int_ptr_kind()
 
       end module omp_lib_kinds
 
       module omp_lib
 
         use omp_lib_kinds
 
         integer (kind=omp_integer_kind), parameter :: kmp_version_major = @LIBOMP_VERSION_MAJOR@
!         ***
             integer (kind=omp_integer_kind) omp_pause_resource_all
           end function omp_pause_resource_all
 
           function omp_get_supported_active_levels()
             use omp_lib_kinds
             integer (kind=omp_integer_kind) omp_get_supported_active_levels
           end function omp_get_supported_active_levels
 
+          subroutine omp_fulfill_event(event)
+            use omp_lib_kinds
+            integer (kind=omp_event_handle_kind) event
+          end subroutine omp_fulfill_event
+
           subroutine omp_init_lock(svar)
 !DIR$ IF(__INTEL_COMPILER.GE.1400)
 !DIR$ attributes known_intrinsic :: omp_init_lock
 !DIR$ ENDIF
             use omp_lib_kinds
             integer (kind=omp_lock_kind) svar
           end subroutine omp_init_lock
 

 !dec$ attributes alias:'OMP_GET_CANCELLATION' :: omp_get_cancellation
 !dec$ attributes alias:'OMP_IS_INITIAL_DEVICE' :: omp_is_initial_device
 !dec$ attributes alias:'OMP_GET_INITIAL_DEVICE' :: omp_get_initial_device
 !dec$ attributes alias:'OMP_GET_MAX_TASK_PRIORITY' :: omp_get_max_task_priority
 !dec$ attributes alias:'OMP_GET_DEVICE_NUM' :: omp_get_device_num
 !dec$ attributes alias:'OMP_PAUSE_RESOURCE' :: omp_pause_resource
 !dec$ attributes alias:'OMP_PAUSE_RESOURCE_ALL' :: omp_pause_resource_all
 !dec$ attributes alias:'OMP_GET_SUPPORTED_ACTIVE_LEVELS' :: omp_get_supported_active_levels
+!dec$ attributes alias:'OMP_FULFILL_EVENT' :: omp_fulfill_event
 
 !dec$ attributes alias:'OMP_CONTROL_TOOL' :: omp_control_tool
 !dec$ attributes alias:'OMP_SET_AFFINITY_FORMAT' :: omp_set_affinity_format
 !dec$ attributes alias:'OMP_GET_AFFINITY_FORMAT' :: omp_get_affinity_format
 !dec$ attributes alias:'OMP_DISPLAY_AFFINITY' :: omp_display_affinity
 !dec$ attributes alias:'OMP_CAPTURE_AFFINITY' :: omp_capture_affinity
 
 !dec$ attributes alias:'omp_init_lock' :: omp_init_lock

 !dec$ attributes alias:'_OMP_GET_CANCELLATION' :: omp_get_cancellation
 !dec$ attributes alias:'_OMP_IS_INITIAL_DEVICE' :: omp_is_initial_device
 !dec$ attributes alias:'_OMP_GET_INITIAL_DEVICE' :: omp_get_initial_device
 !dec$ attributes alias:'_OMP_GET_MAX_TASK_PRIORTY' :: omp_get_max_task_priority
 !dec$ attributes alias:'_OMP_GET_DEVICE_NUM' :: omp_get_device_num
 !dec$ attributes alias:'_OMP_PAUSE_RESOURCE' :: omp_pause_resource
 !dec$ attributes alias:'_OMP_PAUSE_RESOURCE_ALL' :: omp_pause_resource_all
 !dec$ attributes alias:'_OMP_GET_SUPPORTED_ACTIVE_LEVELS' :: omp_get_supported_active_levels
+!dec$ attributes alias:'_OMP_FULFILL_EVENT' :: omp_fulfill_event
 
 !dec$ attributes alias:'_OMP_CONTROL_TOOL' :: omp_control_tool
 !dec$ attributes alias:'_OMP_SET_AFFINITY_FORMAT' :: omp_set_affinity_format
 !dec$ attributes alias:'_OMP_GET_AFFINITY_FORMAT' :: omp_get_affinity_format
 !dec$ attributes alias:'_OMP_DISPLAY_AFFINITY' :: omp_display_affinity
 !dec$ attributes alias:'_OMP_CAPTURE_AFFINITY' :: omp_capture_affinity
 
 !dec$ attributes alias:'_omp_init_lock' :: omp_init_lock

 !dec$ attributes alias:'omp_get_cancellation_'::omp_get_cancellation
 !dec$ attributes alias:'omp_is_initial_device_'::omp_is_initial_device
 !dec$ attributes alias:'omp_get_initial_device_'::omp_get_initial_device
 !dec$ attributes alias:'omp_get_max_task_priority_'::omp_get_max_task_priority
 !dec$ attributes alias:'omp_get_device_num_'::omp_get_device_num
 !dec$ attributes alias:'omp_pause_resource_' :: omp_pause_resource
 !dec$ attributes alias:'omp_pause_resource_all_' :: omp_pause_resource_all
 !dec$ attributes alias:'omp_get_supported_active_levels_' :: omp_get_supported_active_levels
+!dec$ attributes alias:'omp_fulfill_event_' :: omp_fulfill_event
 
 !dec$ attributes alias:'omp_set_affinity_format_' :: omp_set_affinity_format
 !dec$ attributes alias:'omp_get_affinity_format_' :: omp_get_affinity_format
 !dec$ attributes alias:'omp_display_affinity_' :: omp_display_affinity
 !dec$ attributes alias:'omp_capture_affinity_' :: omp_capture_affinity
 
 !dec$ attributes alias:'omp_init_lock_'::omp_init_lock
 !dec$ attributes alias:'omp_init_lock_with_hint_'::omp_init_lock_with_hint

 !dec$ attributes alias:'_omp_get_cancellation_'::omp_get_cancellation
 !dec$ attributes alias:'_omp_is_initial_device_'::omp_is_initial_device
 !dec$ attributes alias:'_omp_get_initial_device_'::omp_get_initial_device
 !dec$ attributes alias:'_omp_get_max_task_priorty_'::omp_get_max_task_priority
 !dec$ attributes alias:'_omp_get_device_num_'::omp_get_device_num
 !dec$ attributes alias:'_omp_pause_resource_' :: omp_pause_resource
 !dec$ attributes alias:'_omp_pause_resource_all_' :: omp_pause_resource_all
 !dec$ attributes alias:'_omp_get_supported_active_levels_' :: omp_get_supported_active_levels
+!dec$ attributes alias:'_omp_fulfill_event_' :: omp_fulfill_event
 
 !dec$ attributes alias:'_omp_init_lock_'::omp_init_lock
 !dec$ attributes alias:'_omp_init_lock_with_hint_'::omp_init_lock_with_hint
 !dec$ attributes alias:'_omp_destroy_lock_'::omp_destroy_lock
 !dec$ attributes alias:'_omp_set_lock_'::omp_set_lock
 !dec$ attributes alias:'_omp_unset_lock_'::omp_unset_lock
 !dec$ attributes alias:'_omp_test_lock_'::omp_test_lock
 !dec$ attributes alias:'_omp_init_nest_lock_'::omp_init_nest_lock

openmp/trunk/runtime/src/include/50/omp_lib.f90.var

!
 
         type omp_alloctrait
           integer(kind=omp_alloctrait_key_kind) key
           integer(kind=omp_alloctrait_val_kind) value
         end type omp_alloctrait
 
         integer, parameter :: omp_pause_resource_kind = omp_integer_kind
         integer, parameter :: omp_depend_kind = c_intptr_t
+        integer, parameter :: omp_event_handle_kind = c_intptr_t
 
       end module omp_lib_kinds
 
       module omp_lib
 
         use omp_lib_kinds
 
         integer (kind=omp_integer_kind), parameter :: openmp_version    = @LIBOMP_OMP_YEAR_MONTH@
!         ***
             integer (kind=omp_integer_kind) omp_pause_resource_all
           end function omp_pause_resource_all
 
           function omp_get_supported_active_levels() bind(c)
             use omp_lib_kinds
             integer (kind=omp_integer_kind) omp_get_supported_active_levels
           end function omp_get_supported_active_levels
 
+          subroutine omp_fulfill_event(event) bind(c)
+            use omp_lib_kinds
+            integer (kind=omp_event_handle_kind), value :: event
+          end subroutine omp_fulfill_event
+
           subroutine omp_init_lock(svar) bind(c)
 !DIR$ IF(__INTEL_COMPILER.GE.1400)
 !DIR$ attributes known_intrinsic :: omp_init_lock
 !DIR$ ENDIF
             use omp_lib_kinds
             integer (kind=omp_lock_kind) svar
           end subroutine omp_init_lock
 

openmp/trunk/runtime/src/kmp.h

 #define TASK_NOT_PUSHED 1
 #define TASK_SUCCESSFULLY_PUSHED 0
 #define TASK_TIED 1
 #define TASK_UNTIED 0
 #define TASK_EXPLICIT 1
 #define TASK_IMPLICIT 0
 #define TASK_PROXY 1
 #define TASK_FULL 0
+#define TASK_DETACHABLE 1
+#define TASK_UNDETACHABLE 0
 
 #define KMP_CANCEL_THREADS
 #define KMP_THREAD_ATTR
 
 // Android does not have pthread_cancel.  Undefine KMP_CANCEL_THREADS if being
 // built on Android
 #if defined(__ANDROID__)
 #undef KMP_CANCEL_THREADS
typedef struct kmp_task_affinity_info {
   kmp_intptr_t base_addr;
   size_t len;
   struct {
     bool flag1 : 1;
     bool flag2 : 1;
     kmp_int32 reserved : 30;
   } flags;
 } kmp_task_affinity_info_t;
+
+typedef enum kmp_event_type_t {
+  KMP_EVENT_UNINITIALIZED = 0,
+  KMP_EVENT_ALLOW_COMPLETION = 1
+} kmp_event_type_t;
+
+typedef struct {
+  kmp_event_type_t type;
+  kmp_tas_lock_t lock;
+  union {
+    kmp_task_t *task;
+  } ed;
+} kmp_event_t;
 #endif
 
 #endif
 
 #ifdef BUILD_TIED_TASK_STACK
 
 /* Tied Task stack definitions */
 typedef struct kmp_stack_block {

 #if OMP_40_ENABLED
   unsigned destructors_thunk : 1; /* set if the compiler creates a thunk to
                                      invoke destructors from the runtime */
 #if OMP_45_ENABLED
   unsigned proxy : 1; /* task is a proxy task (it will be executed outside the
                          context of the RTL) */
   unsigned priority_specified : 1; /* set if the compiler provides priority
                                       setting for the task */
-  unsigned reserved : 10; /* reserved for compiler use */
+  unsigned detachable : 1; /* 1 == can detach */
+  unsigned reserved : 9; /* reserved for compiler use */
 #else
   unsigned reserved : 12; /* reserved for compiler use */
 #endif
 #else // OMP_40_ENABLED
   unsigned reserved : 13; /* reserved for compiler use */
 #endif // OMP_40_ENABLED
 
   /* Library flags */ /* Total library flags must be 16 bits */
#if defined(KMP_GOMP_COMPAT)
   kmp_int32 td_size_loop_bounds;
 #endif
 #endif // OMP_45_ENABLED
   kmp_taskdata_t *td_last_tied; // keep tied task for task scheduling constraint
 #if defined(KMP_GOMP_COMPAT) && OMP_45_ENABLED
   // GOMP sends in a copy function for copy constructors
   void (*td_copy_func)(void *, void *);
 #endif
+#if OMP_50_ENABLED
+  kmp_event_t td_allow_completion_event;
+#endif
 #if OMPT_SUPPORT
   ompt_task_info_t ompt_task_info;
 #endif
 }; // struct kmp_taskdata
 
 // Make sure padding above worked
 KMP_BUILD_ASSERT(sizeof(kmp_taskdata_t) % sizeof(void *) == 0);
 
extern kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
                                     size_t sizeof_kmp_task_t,
                                     size_t sizeof_shareds,
                                     kmp_routine_entry_t task_entry);
 extern void __kmp_init_implicit_task(ident_t *loc_ref, kmp_info_t *this_thr,
                                      kmp_team_t *team, int tid,
                                      int set_curr_task);
 extern void __kmp_finish_implicit_task(kmp_info_t *this_thr);
 extern void __kmp_free_implicit_task(kmp_info_t *this_thr);
+
+#ifdef OMP_50_ENABLED
+extern kmp_event_t *__kmpc_task_allow_completion_event(ident_t *loc_ref,
+                                                       int gtid,
+                                                       kmp_task_t *task);
+extern void __kmp_fulfill_event(kmp_event_t *event);
+#endif
+
 int __kmp_execute_tasks_32(kmp_info_t *thread, kmp_int32 gtid,
                            kmp_flag_32 *flag, int final_spin,
                            int *thread_finished,
 #if USE_ITT_BUILD
                            void *itt_sync_obj,
 #endif /* USE_ITT_BUILD */
                            kmp_int32 is_constrained);
 int __kmp_execute_tasks_64(kmp_info_t *thread, kmp_int32 gtid,

openmp/trunk/runtime/src/kmp_ftn_entry.h

 int FTN_STDCALL FTN_GET_SUPPORTED_ACTIVE_LEVELS(void) {
 #ifdef KMP_STUB
   return 1;
 #else
   return KMP_MAX_ACTIVE_LEVELS_LIMIT;
 #endif
 }
 
+void FTN_STDCALL FTN_FULFILL_EVENT(kmp_event_t *event) {
+#ifndef KMP_STUB
+  __kmp_fulfill_event(event);
+#endif
+}
+
 #endif // OMP_50_ENABLED
 
 // GCC compatibility (versioned symbols)
 #ifdef KMP_USE_VERSION_SYMBOLS
 
 /* These following sections create versioned symbols for the
    omp_* routines. The KMP_VERSION_SYMBOL macro expands the API name and
    then maps it to a versioned symbol.

 #endif
 
 #if OMP_50_ENABLED
 // OMP_5.0 versioned symbols
 // KMP_VERSION_SYMBOL(FTN_GET_DEVICE_NUM, 50, "OMP_5.0");
 // KMP_VERSION_SYMBOL(FTN_PAUSE_RESOURCE, 50, "OMP_5.0");
 // KMP_VERSION_SYMBOL(FTN_PAUSE_RESOURCE_ALL, 50, "OMP_5.0");
 // KMP_VERSION_SYMBOL(FTN_GET_SUPPORTED_ACTIVE_LEVELS, 50, "OMP_5.0");
+// KMP_VERSION_SYMBOL(FTN_FULFILL_EVENT, 50, "OMP_5.0");
 #endif
 
 #endif // KMP_USE_VERSION_SYMBOLS
 
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
 
 // end of file //

openmp/trunk/runtime/src/kmp_ftn_os.h

 #define FTN_GET_DEVICE_NUM omp_get_device_num
 #define FTN_SET_AFFINITY_FORMAT omp_set_affinity_format
 #define FTN_GET_AFFINITY_FORMAT omp_get_affinity_format
 #define FTN_DISPLAY_AFFINITY omp_display_affinity
 #define FTN_CAPTURE_AFFINITY omp_capture_affinity
 #define FTN_PAUSE_RESOURCE omp_pause_resource
 #define FTN_PAUSE_RESOURCE_ALL omp_pause_resource_all
 #define FTN_GET_SUPPORTED_ACTIVE_LEVELS omp_get_supported_active_levels
+#define FTN_FULFILL_EVENT omp_fulfill_event
 #endif
 
 #endif /* KMP_FTN_PLAIN */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_APPEND
 

 #define FTN_GET_DEVICE_NUM omp_get_device_num_
 #define FTN_SET_AFFINITY_FORMAT omp_set_affinity_format_
 #define FTN_GET_AFFINITY_FORMAT omp_get_affinity_format_
 #define FTN_DISPLAY_AFFINITY omp_display_affinity_
 #define FTN_CAPTURE_AFFINITY omp_capture_affinity_
 #define FTN_PAUSE_RESOURCE omp_pause_resource_
 #define FTN_PAUSE_RESOURCE_ALL omp_pause_resource_all_
 #define FTN_GET_SUPPORTED_ACTIVE_LEVELS omp_get_supported_active_levels_
+#define FTN_FULFILL_EVENT omp_fulfill_event_
 #endif
 
 #endif /* KMP_FTN_APPEND */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UPPER
 

 #define FTN_GET_DEVICE_NUM OMP_GET_DEVICE_NUM
 #define FTN_SET_AFFINITY_FORMAT OMP_SET_AFFINITY_FORMAT
 #define FTN_GET_AFFINITY_FORMAT OMP_GET_AFFINITY_FORMAT
 #define FTN_DISPLAY_AFFINITY OMP_DISPLAY_AFFINITY
 #define FTN_CAPTURE_AFFINITY OMP_CAPTURE_AFFINITY
 #define FTN_PAUSE_RESOURCE OMP_PAUSE_RESOURCE
 #define FTN_PAUSE_RESOURCE_ALL OMP_PAUSE_RESOURCE_ALL
 #define FTN_GET_SUPPORTED_ACTIVE_LEVELS OMP_GET_SUPPORTED_ACTIVE_LEVELS
+#define FTN_FULFILL_EVENT OMP_FULFILL_EVENT
 #endif
 
 #endif /* KMP_FTN_UPPER */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UAPPEND
 

 #define FTN_GET_DEVICE_NUM OMP_GET_DEVICE_NUM_
 #define FTN_SET_AFFINITY_FORMAT OMP_SET_AFFINITY_FORMAT_
 #define FTN_GET_AFFINITY_FORMAT OMP_GET_AFFINITY_FORMAT_
 #define FTN_DISPLAY_AFFINITY OMP_DISPLAY_AFFINITY_
 #define FTN_CAPTURE_AFFINITY OMP_CAPTURE_AFFINITY_
 #define FTN_PAUSE_RESOURCE OMP_PAUSE_RESOURCE_
 #define FTN_PAUSE_RESOURCE_ALL OMP_PAUSE_RESOURCE_ALL_
 #define FTN_GET_SUPPORTED_ACTIVE_LEVELS OMP_GET_SUPPORTED_ACTIVE_LEVELS_
+#define FTN_FULFILL_EVENT OMP_FULFILL_EVENT_
 #endif
 
 #endif /* KMP_FTN_UAPPEND */
 
 /* -------------------------- GOMP API NAMES ------------------------ */
 // All GOMP_1.0 symbols
 #define KMP_API_NAME_GOMP_ATOMIC_END GOMP_atomic_end
 #define KMP_API_NAME_GOMP_ATOMIC_START GOMP_atomic_start

openmp/trunk/runtime/src/kmp_tasking.cpp

if (node && (node->dn.mtx_num_locks < 0)) {
     node->dn.mtx_num_locks = -node->dn.mtx_num_locks;
     for (int i = node->dn.mtx_num_locks - 1; i >= 0; --i) {
       KMP_DEBUG_ASSERT(node->dn.mtx_locks[i] != NULL);
       __kmp_release_lock(node->dn.mtx_locks[i], gtid);
     }
   }
 
   KMP_DEBUG_ASSERT(taskdata->td_flags.complete == 0);
-  taskdata->td_flags.complete = 1; // mark the task as completed
+  bool detach = false;
+#if OMP_50_ENABLED
+  if (taskdata->td_flags.detachable == TASK_DETACHABLE) {
+    if (taskdata->td_allow_completion_event.type ==
+        KMP_EVENT_ALLOW_COMPLETION) {
+      // event hasn't been fulfilled yet. Try to detach task.
+      __kmp_acquire_tas_lock(&taskdata->td_allow_completion_event.lock, gtid);
+      if (taskdata->td_allow_completion_event.type ==
+          KMP_EVENT_ALLOW_COMPLETION) {
+        taskdata->td_flags.proxy = TASK_PROXY; // proxify!
+        detach = true;
+      }
+      __kmp_release_tas_lock(&taskdata->td_allow_completion_event.lock, gtid);
+    }
+  }
+#endif
   KMP_DEBUG_ASSERT(taskdata->td_flags.started == 1);
   KMP_DEBUG_ASSERT(taskdata->td_flags.freed == 0);
 
+  if (!detach) {
+    taskdata->td_flags.complete = 1; // mark the task as completed
+
     // 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
       children =
           KMP_ATOMIC_DEC(&taskdata->td_parent->td_incomplete_child_tasks) - 1;
       KMP_DEBUG_ASSERT(children >= 0);
 #if OMP_40_ENABLED
       if (taskdata->td_taskgroup)
         KMP_ATOMIC_DEC(&taskdata->td_taskgroup->count);
       __kmp_release_deps(gtid, taskdata);
 #if OMP_45_ENABLED
     } else if (task_team && task_team->tt.tt_found_proxy_tasks) {
       // if we found proxy tasks there could exist a dependency chain
       // with the proxy task as origin
       __kmp_release_deps(gtid, taskdata);
 #endif // OMP_45_ENABLED
 #endif // OMP_40_ENABLED
     }
+  }
 
   // td_flags.executing must be marked as 0 after __kmp_release_deps has been
   // called. Othertwise, if a task is executed immediately from the release_deps
   // code, the flag will be reset to 1 again by this same function
   KMP_DEBUG_ASSERT(taskdata->td_flags.executing == 1);
   taskdata->td_flags.executing = 0; // suspend the finishing task
 
   KA_TRACE(
KMP_DEBUG_ASSERT(resumed_task !=
                      NULL); // verify that resumed task is passed as arguemnt
   }
 
   // Free this task and then ancestor tasks if they have no children.
   // Restore th_current_task first as suggested by John:
   // johnmc: if an asynchronous inquiry peers into the runtime system
   // it doesn't see the freed task as the current task.
   thread->th.th_current_task = resumed_task;
+  if (!detach)
     __kmp_free_task_and_ancestors(gtid, taskdata, thread);
 
   // TODO: GEH - make sure root team implicit task is initialized properly.
   // KMP_DEBUG_ASSERT( resumed_task->td_flags.executing == 0 );
   resumed_task->td_flags.executing = 1; // resume previous task
 
   KA_TRACE(
       10, ("__kmp_task_finish(exit): T#%d finished task %p, resuming task %p\n",
            gtid, taskdata, resumed_task));
#endif
   task->td_flags.executing = 1;
   task->td_flags.complete = 0;
   task->td_flags.freed = 0;
 
 #if OMP_40_ENABLED
   task->td_depnode = NULL;
 #endif
   task->td_last_tied = task;
+#if OMP_50_ENABLED
+  task->td_allow_completion_event.type = KMP_EVENT_UNINITIALIZED;
+#endif
 
   if (set_curr_task) { // only do this init first time thread is created
     KMP_ATOMIC_ST_REL(&task->td_incomplete_child_tasks, 0);
     // Not used: don't need to deallocate implicit task
     KMP_ATOMIC_ST_REL(&task->td_allocated_child_tasks, 0);
 #if OMP_40_ENABLED
     task->td_taskgroup = NULL; // An implicit task does not have taskgroup
     task->td_dephash = NULL;
kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
   }
   if (flags->tiedness == TASK_UNTIED && !team->t.t_serialized) {
     // Untied task encountered causes the TSC algorithm to check entire deque of
     // the victim thread. If no untied task encountered, then checking the head
     // of the deque should be enough.
     KMP_CHECK_UPDATE(thread->th.th_task_team->tt.tt_untied_task_encountered, 1);
   }
 
+#if OMP_50_ENABLED
+  // Detachable tasks are not proxy tasks yet but could be in the future. Doing
+  // the tasking setup
+  // when that happens is too late.
+  if (flags->proxy == TASK_PROXY || flags->detachable == TASK_DETACHABLE) {
+#endif
 #if OMP_45_ENABLED
     if (flags->proxy == TASK_PROXY) {
       flags->tiedness = TASK_UNTIED;
       flags->merged_if0 = 1;
-
+#if OMP_50_ENABLED
+    }
+#endif
     /* are we running in a sequential parallel or tskm_immediate_exec... we need
        tasking support enabled */
     if ((thread->th.th_task_team) == NULL) {
       /* This should only happen if the team is serialized
           setup a task team and propagate it to the thread */
       KMP_DEBUG_ASSERT(team->t.t_serialized);
       KA_TRACE(30,
                ("T#%d creating task team in __kmp_task_alloc for proxy task\n",
#endif
   taskdata->td_flags.tiedness = flags->tiedness;
   taskdata->td_flags.final = flags->final;
   taskdata->td_flags.merged_if0 = flags->merged_if0;
 #if OMP_40_ENABLED
   taskdata->td_flags.destructors_thunk = flags->destructors_thunk;
 #endif // OMP_40_ENABLED
 #if OMP_45_ENABLED
   taskdata->td_flags.proxy = flags->proxy;
+#if OMP_50_ENABLED
+  taskdata->td_flags.detachable = flags->detachable;
+#endif
   taskdata->td_task_team = thread->th.th_task_team;
   taskdata->td_size_alloc = shareds_offset + sizeof_shareds;
 #endif
   taskdata->td_flags.tasktype = TASK_EXPLICIT;
 
   // GEH - TODO: fix this to copy parent task's value of tasking_ser flag
   taskdata->td_flags.tasking_ser = (__kmp_tasking_mode == tskm_immediate_exec);
 
taskdata->td_taskgroup =
       parent_task->td_taskgroup; // task inherits taskgroup from the parent task
   taskdata->td_dephash = NULL;
   taskdata->td_depnode = NULL;
 #endif
   if (flags->tiedness == TASK_UNTIED)
     taskdata->td_last_tied = NULL; // will be set when the task is scheduled
   else
     taskdata->td_last_tied = taskdata;
-
+#if OMP_50_ENABLED
+  taskdata->td_allow_completion_event.type = KMP_EVENT_UNINITIALIZED;
+#endif
 #if OMPT_SUPPORT
   if (UNLIKELY(ompt_enabled.enabled))
     __ompt_task_init(taskdata, gtid);
 #endif
 // Only need to keep track of child task counts if team parallel and tasking not
-// serialized or if it is a proxy task
+// serialized or if it is a proxy or detachable task
 #if OMP_45_ENABLED
   if (flags->proxy == TASK_PROXY ||
+#if OMP_50_ENABLED
+      flags->detachable == TASK_DETACHABLE ||
+#endif
       !(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser))
 #else
   if (!(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser))
 #endif
   {
     KMP_ATOMIC_INC(&parent_task->td_incomplete_child_tasks);
 #if OMP_40_ENABLED
     if (parent_task->td_taskgroup)
kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
                                   kmp_routine_entry_t task_entry) {
   kmp_task_t *retval;
   kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags;
 
   input_flags->native = FALSE;
 // __kmp_task_alloc() sets up all other runtime flags
 
 #if OMP_45_ENABLED
+#if OMP_50_ENABLED
+  KA_TRACE(10, ("__kmpc_omp_task_alloc(enter): T#%d loc=%p, flags=(%s %s %s) "
+                "sizeof_task=%ld sizeof_shared=%ld entry=%p\n",
+                gtid, loc_ref, input_flags->tiedness ? "tied  " : "untied",
+                input_flags->proxy ? "proxy" : "",
+                input_flags->detachable ? "detachable" : "", sizeof_kmp_task_t,
+                sizeof_shareds, task_entry));
+#else
   KA_TRACE(10, ("__kmpc_omp_task_alloc(enter): T#%d loc=%p, flags=(%s %s) "
                 "sizeof_task=%ld sizeof_shared=%ld entry=%p\n",
                 gtid, loc_ref, input_flags->tiedness ? "tied  " : "untied",
                 input_flags->proxy ? "proxy" : "", sizeof_kmp_task_t,
                 sizeof_shareds, task_entry));
+#endif
 #else
   KA_TRACE(10, ("__kmpc_omp_task_alloc(enter): T#%d loc=%p, flags=(%s) "
                 "sizeof_task=%ld sizeof_shared=%ld entry=%p\n",
                 gtid, loc_ref, input_flags->tiedness ? "tied  " : "untied",
                 sizeof_kmp_task_t, sizeof_shareds, task_entry));
 #endif
 
   retval = __kmp_task_alloc(loc_ref, gtid, input_flags, sizeof_kmp_task_t,
void __kmpc_proxy_task_completed_ooo(kmp_task_t *ptask) {
   __kmp_second_top_half_finish_proxy(taskdata);
 
   KA_TRACE(
       10,
       ("__kmp_proxy_task_completed_ooo(exit): proxy task completing ooo %p\n",
        taskdata));
 }
 
+#if OMP_50_ENABLED
+kmp_event_t *__kmpc_task_allow_completion_event(ident_t *loc_ref, int gtid,
+                                                kmp_task_t *task) {
+  kmp_taskdata_t *td = KMP_TASK_TO_TASKDATA(task);
+  if (td->td_allow_completion_event.type == KMP_EVENT_UNINITIALIZED) {
+    td->td_allow_completion_event.type = KMP_EVENT_ALLOW_COMPLETION;
+    td->td_allow_completion_event.ed.task = task;
+    __kmp_init_tas_lock(&td->td_allow_completion_event.lock);
+  }
+  return &td->td_allow_completion_event;
+}
+
+void __kmp_fulfill_event(kmp_event_t *event) {
+  if (event->type == KMP_EVENT_ALLOW_COMPLETION) {
+    kmp_task_t *ptask = event->ed.task;
+    kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(ptask);
+    bool detached = false;
+    int gtid = __kmp_get_gtid();
+
+    if (taskdata->td_flags.proxy == TASK_PROXY) {
+      // The associated task code completed before this call and detached.
+      detached = true;
+      event->type = KMP_EVENT_UNINITIALIZED;
+    } else {
+      // The associated task has not completed but could be completing at this
+      // point.
+      // We need to take the lock to avoid races
+      __kmp_acquire_tas_lock(&event->lock, gtid);
+      if (taskdata->td_flags.proxy == TASK_PROXY)
+        detached = true;
+      event->type = KMP_EVENT_UNINITIALIZED;
+      __kmp_release_tas_lock(&event->lock, gtid);
+    }
+
+    if (detached) {
+      // If the task detached complete the proxy task
+      if (gtid >= 0) {
+        kmp_team_t *team = taskdata->td_team;
+        kmp_info_t *thread = __kmp_get_thread();
+        if (thread->th.th_team == team) {
+          __kmpc_proxy_task_completed(gtid, ptask);
+          return;
+        }
+      }
+
+      // fallback
+      __kmpc_proxy_task_completed_ooo(ptask);
+    }
+  }
+}
+#endif
+
 // __kmp_task_dup_alloc: Allocate the taskdata and make a copy of source task
 // for taskloop
 //
 // thread:   allocating thread
 // task_src: pointer to source task to be duplicated
 // returns:  a pointer to the allocated kmp_task_t structure (task).
 kmp_task_t *__kmp_task_dup_alloc(kmp_info_t *thread, kmp_task_t *task_src) {
   kmp_task_t *task;

openmp/trunk/runtime/test/tasking/kmp_detach_tasks_t1.c

+// RUN: %libomp-compile && env OMP_NUM_THREADS='3' %libomp-run
+// RUN: %libomp-compile && env OMP_NUM_THREADS='1' %libomp-run
+
+#include <stdio.h>
+#include <omp.h>
+#include "omp_my_sleep.h"
+
+// detached untied
+#define PTASK_FLAG_DETACHABLE 0x40
+
+// OpenMP RTL interfaces
+typedef unsigned long long kmp_uint64;
+typedef long long kmp_int64;
+
+typedef struct ID {
+  int reserved_1;
+  int flags;
+  int reserved_2;
+  int reserved_3;
+  char *psource;
+} id;
+
+// Compiler-generated code (emulation)
+typedef struct ident {
+  void* dummy; // not used in the library
+} ident_t;
+
+typedef enum kmp_event_type_t {
+  KMP_EVENT_UNINITIALIZED = 0,
+  KMP_EVENT_ALLOW_COMPLETION = 1
+} kmp_event_type_t;
+
+typedef struct {
+  kmp_event_type_t type;
+  union {
+    void *task;
+  } ed;
+} kmp_event_t;
+
+typedef struct shar { // shareds used in the task
+} *pshareds;
+
+typedef struct task {
+  pshareds shareds;
+  int(*routine)(int,struct task*);
+  int part_id;
+// void *destructor_thunk; // optional, needs flag setting if provided
+// int priority; // optional, needs flag setting if provided
+// ------------------------------
+// privates used in the task:
+  omp_event_handle_t evt;
+} *ptask, kmp_task_t;
+
+typedef int(*task_entry_t)(int, ptask);
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int __kmpc_global_thread_num(void *id_ref);
+extern ptask __kmpc_omp_task_alloc(id *loc, int gtid, int flags,
+                                   size_t sz, size_t shar, task_entry_t rtn);
+extern int __kmpc_omp_task(id *loc, int gtid, ptask task);
+extern omp_event_handle_t __kmpc_task_allow_completion_event(
+                              ident_t *loc_ref, int gtid, ptask task);
+#if __cplusplus
+}
+#endif
+
+int volatile checker;
+
+// User's code, outlined into task entry
+int task_entry(int gtid, ptask task) {
+  checker = 1;
+  return 0;
+}
+
+int main() {
+  int i, j, gtid = __kmpc_global_thread_num(NULL);
+  int nt = omp_get_max_threads();
+  ptask task;
+  pshareds psh;
+  checker = 0;
+  omp_set_dynamic(0);
+  #pragma omp parallel //num_threads(N)
+  {
+    #pragma omp master
+    {
+      int gtid = __kmpc_global_thread_num(NULL);
+      omp_event_handle_t evt;
+/*
+      #pragma omp task detach(evt)
+      {}
+*/
+      task = (ptask)__kmpc_omp_task_alloc(NULL,gtid,PTASK_FLAG_DETACHABLE,sizeof(struct task),sizeof(struct shar),&task_entry);
+      psh = task->shareds;
+      evt = (omp_event_handle_t)__kmpc_task_allow_completion_event(NULL,gtid,task);
+      task->evt = evt;
+
+      __kmpc_omp_task(NULL, gtid, task);
+      my_sleep(2.0);
+      omp_fulfill_event(evt);
+
+    } // end master
+  } // end parallel
+
+  // check results
+  if (checker == 1) {
+    printf("passed\n");
+    return 0;
+  } else {
+    printf("failed\n");
+    return 1;
+  }
+}

openmp/trunk/runtime/test/tasking/kmp_detach_tasks_t2.c

+// RUN: %libomp-compile && env OMP_NUM_THREADS='3' %libomp-run
+// RUN: %libomp-compile && env OMP_NUM_THREADS='1' %libomp-run
+
+#include <stdio.h>
+#include <omp.h>
+#include "omp_my_sleep.h"
+
+// detached tied
+#define PTASK_FLAG_DETACHABLE 0x41
+
+// OpenMP RTL interfaces
+typedef unsigned long long kmp_uint64;
+typedef long long kmp_int64;
+
+typedef struct ID {
+  int reserved_1;
+  int flags;
+  int reserved_2;
+  int reserved_3;
+  char *psource;
+} id;
+
+// Compiler-generated code (emulation)
+typedef struct ident {
+  void* dummy; // not used in the library
+} ident_t;
+
+typedef enum kmp_event_type_t {
+  KMP_EVENT_UNINITIALIZED = 0,
+  KMP_EVENT_ALLOW_COMPLETION = 1
+} kmp_event_type_t;
+
+typedef struct {
+  kmp_event_type_t type;
+  union {
+    void *task;
+  } ed;
+} kmp_event_t;
+
+typedef struct shar { // shareds used in the task
+} *pshareds;
+
+typedef struct task {
+  pshareds shareds;
+  int(*routine)(int,struct task*);
+  int part_id;
+// void *destructor_thunk; // optional, needs flag setting if provided
+// int priority; // optional, needs flag setting if provided
+// ------------------------------
+// privates used in the task:
+  omp_event_handle_t evt;
+} *ptask, kmp_task_t;
+
+typedef int(* task_entry_t)( int, ptask );
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int  __kmpc_global_thread_num(void *id_ref);
+extern int** __kmpc_omp_task_alloc(id *loc, int gtid, int flags,
+                                   size_t sz, size_t shar, task_entry_t rtn);
+extern int __kmpc_omp_task(id *loc, int gtid, kmp_task_t *task);
+extern omp_event_handle_t __kmpc_task_allow_completion_event(
+                              ident_t *loc_ref, int gtid, kmp_task_t *task);
+#ifdef __cplusplus
+}
+#endif
+
+int volatile checker;
+
+// User's code, outlined into task entry
+int task_entry(int gtid, ptask task) {
+  my_sleep(2.0);
+  checker = 1;
+  return 0;
+}
+
+int main() {
+  int i, j, gtid = __kmpc_global_thread_num(NULL);
+  int nt = omp_get_max_threads();
+  ptask task;
+  pshareds psh;
+  checker = 0;
+  omp_set_dynamic(0);
+  #pragma omp parallel //num_threads(N)
+  {
+    #pragma omp master
+    {
+      int gtid = __kmpc_global_thread_num(NULL);
+      omp_event_handle_t evt;
+/*
+      #pragma omp task detach(evt)
+      {}
+*/
+      task = (ptask)__kmpc_omp_task_alloc(NULL,gtid,PTASK_FLAG_DETACHABLE,
+                        sizeof(struct task),sizeof(struct shar),&task_entry);
+      psh = task->shareds;
+      evt = (omp_event_handle_t)__kmpc_task_allow_completion_event(NULL,gtid,task);
+      task->evt = evt;
+      __kmpc_omp_task(NULL, gtid, task);
+      omp_fulfill_event(evt);
+      #pragma omp taskwait
+      ;
+//      printf("after tw %d\n", omp_get_thread_num());
+    } // end master
+  } // end parallel
+
+  // check results
+  if (checker == 1) {
+    printf("passed\n");
+    return 0;
+  } else {
+    printf("failed\n");
+    return 1;
+  }
+}

openmp/trunk/runtime/test/tasking/kmp_detach_tasks_t3.c

+// RUN: %libomp-compile && env OMP_NUM_THREADS='3' %libomp-run
+// RUN: %libomp-compile && env OMP_NUM_THREADS='1' %libomp-run
+// The runtime currently does not get dependency information from GCC.
+// UNSUPPORTED: gcc
+
+#include <stdio.h>
+#include <omp.h>
+#include "omp_my_sleep.h"
+
+// detached untied
+#define PTASK_FLAG_DETACHABLE 0x40
+
+// OpenMP RTL interfaces
+typedef unsigned long long kmp_uint64;
+typedef long long kmp_int64;
+
+typedef struct ID {
+  int reserved_1;
+  int flags;
+  int reserved_2;
+  int reserved_3;
+  char *psource;
+} id;
+
+// Compiler-generated code (emulation)
+typedef struct ident {
+  void* dummy; // not used in the library
+} ident_t;
+
+typedef enum kmp_event_type_t {
+  KMP_EVENT_UNINITIALIZED = 0,
+  KMP_EVENT_ALLOW_COMPLETION = 1
+} kmp_event_type_t;
+
+typedef struct {
+  kmp_event_type_t type;
+  union {
+    void *task;
+  } ed;
+} kmp_event_t;
+
+typedef struct shar { // shareds used in the task
+} *pshareds;
+
+typedef struct task {
+  pshareds shareds;
+  int(*routine)(int,struct task*);
+  int part_id;
+// void *destructor_thunk; // optional, needs flag setting if provided
+// int priority; // optional, needs flag setting if provided
+// ------------------------------
+// privates used in the task:
+  omp_event_handle_t evt;
+} *ptask, kmp_task_t;
+
+typedef struct DEP {
+  size_t addr;
+  size_t len;
+  int flags;
+} dep;
+
+typedef int(* task_entry_t)( int, ptask );
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int  __kmpc_global_thread_num(void *id_ref);
+extern int** __kmpc_omp_task_alloc(id *loc, int gtid, int flags,
+                                   size_t sz, size_t shar, task_entry_t rtn);
+extern int __kmpc_omp_task_with_deps(id *loc, int gtid, ptask task, int nd,
+               dep *dep_lst, int nd_noalias, dep *noalias_dep_lst);
+extern int __kmpc_omp_task(id *loc, int gtid, kmp_task_t *task);
+extern omp_event_handle_t __kmpc_task_allow_completion_event(
+                              ident_t *loc_ref, int gtid, kmp_task_t *task);
+#ifdef __cplusplus
+}
+#endif
+
+int volatile checker;
+
+// User's code, outlined into task entry
+int task_entry(int gtid, ptask task) {
+  checker = 1;
+  return 0;
+}
+
+int main() {
+  int i, j, gtid = __kmpc_global_thread_num(NULL);
+  int nt = omp_get_max_threads();
+  ptask task;
+  pshareds psh;
+  checker = 0;
+  omp_set_dynamic(0);
+  #pragma omp parallel //num_threads(N)
+  {
+    #pragma omp master
+    {
+      #pragma omp task depend(inout:nt)
+      {
+        my_sleep(2.0);
+      }
+      int gtid = __kmpc_global_thread_num(NULL);
+      omp_event_handle_t evt;
+/*
+      #pragma omp task detach(evt)
+      {}
+*/
+      task = (ptask)__kmpc_omp_task_alloc(NULL,gtid,PTASK_FLAG_DETACHABLE,
+                        sizeof(struct task),sizeof(struct shar),&task_entry);
+      psh = task->shareds;
+      evt = (omp_event_handle_t)__kmpc_task_allow_completion_event(NULL,gtid,task);
+      task->evt = evt;
+
+      dep sdep;
+      sdep.addr = (size_t)&nt;
+      sdep.len = 0L;
+      sdep.flags = 3;
+
+      __kmpc_omp_task_with_deps(NULL,gtid,task,1,&sdep,0,0);
+      //__kmpc_omp_task(NULL, gtid, task);
+
+      omp_fulfill_event(evt);
+
+      #pragma omp taskwait
+      ;
+//      printf("after tw %d\n", omp_get_thread_num());
+    } // end master
+  } // end parallel
+
+  // check results
+  if (checker == 1) {
+    printf("passed\n");
+    return 0;
+  } else {
+    printf("failed\n");
+    return 1;
+  }
+}