Add initial OpenMP 4.5 task priority feature

[jlpeyton]

Summary

The maximum task priority value is read from envirable OMP_MAX_TASK_PRIORITY. But as of now, nothing is done with it.
We just handle the environment variable and add the new api: omp_get_max_task_priority() which returns that value or zero if it is not set.

[AndreyChurbanov]

LGTM

runtime/src/dllexports

#omp_curr_proc_bind                      864
     omp_is_initial_device                   869
 %endif # OMP_40
 
 # OpenMP 41
 
 %ifdef OMP_41
     omp_init_lock_with_hint                 870
     omp_init_nest_lock_with_hint            871
+    omp_get_max_task_priority               872
 %endif # OMP_41
 
 %ifndef stub
     # Ordinals between 900 and 999 are reserved
 
     # Ordinals between 1000 and 1999 are reserved
     # for user-callable uppercase Fortran entries.
 

runtime/src/include/41/omp.h.var

omp_sched_auto    = 4
     extern int    __KAI_KMPC_CONVENTION  omp_in_final         (void);
     extern int    __KAI_KMPC_CONVENTION  omp_get_active_level        (void);
     extern int    __KAI_KMPC_CONVENTION  omp_get_level               (void);
     extern int    __KAI_KMPC_CONVENTION  omp_get_ancestor_thread_num (int);
     extern int    __KAI_KMPC_CONVENTION  omp_get_team_size           (int);
     extern int    __KAI_KMPC_CONVENTION  omp_get_thread_limit        (void);
     extern int    __KAI_KMPC_CONVENTION  omp_get_max_active_levels   (void);
     extern void   __KAI_KMPC_CONVENTION  omp_get_schedule            (omp_sched_t *, int *);
+    extern int    __KAI_KMPC_CONVENTION  omp_get_max_task_priority   (void);
 
     /* lock API functions */
     typedef struct omp_lock_t {
         void * _lk;
     } omp_lock_t;
 
     extern void   __KAI_KMPC_CONVENTION  omp_init_lock    (omp_lock_t *);
     extern void   __KAI_KMPC_CONVENTION  omp_set_lock     (omp_lock_t *);

runtime/src/include/41/omp_lib.h.var

 !DIR$ IF(__INTEL_COMPILER.GE.1400)
 !DIR$ attributes known_intrinsic :: omp_test_nest_lock
 !DIR$ ENDIF
           import
           integer (kind=omp_integer_kind) omp_test_nest_lock
           integer (kind=omp_nest_lock_kind) lockvar
         end function omp_test_nest_lock
 
+        function omp_get_max_task_priority() bind(c)
+          import
+          integer (kind=omp_integer_kind) omp_get_max_task_priority
+        end function omp_get_max_task_priority
+
 !       ***
 !       *** kmp_* entry points
 !       ***
 
         subroutine kmp_set_stacksize(size) bind(c)
           import
           integer (kind=omp_integer_kind), value :: size
         end subroutine kmp_set_stacksize

 !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
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_destroy_nest_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_set_nest_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_unset_nest_lock
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_test_nest_lock
+!DIR$ ATTRIBUTES OFFLOAD:MIC :: omp_get_max_task_priority
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_stacksize
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_stacksize_s
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_blocktime
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library_serial
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library_turnaround
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library_throughput
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_library
 !DIR$ ATTRIBUTES OFFLOAD:MIC :: kmp_set_defaults

 !$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 )
 !$omp declare target(omp_destroy_nest_lock )
 !$omp declare target(omp_set_nest_lock )
 !$omp declare target(omp_unset_nest_lock )
 !$omp declare target(omp_test_nest_lock )
+!$omp declare target(omp_get_max_task_priority )
 !$omp declare target(kmp_set_stacksize )
 !$omp declare target(kmp_set_stacksize_s )
 !$omp declare target(kmp_set_blocktime )
 !$omp declare target(kmp_set_library_serial )
 !$omp declare target(kmp_set_library_turnaround )
 !$omp declare target(kmp_set_library_throughput )
 !$omp declare target(kmp_set_library )
 !$omp declare target(kmp_set_defaults )

runtime/src/include/41/omp_lib.f.var

 !DIR$ IF(__INTEL_COMPILER.GE.1400)
 !DIR$ attributes known_intrinsic :: omp_test_nest_lock
 !DIR$ ENDIF
             use omp_lib_kinds
             integer (kind=omp_integer_kind) omp_test_nest_lock
             integer (kind=omp_nest_lock_kind) lockvar
           end function omp_test_nest_lock
 
+          function omp_get_max_task_priority()
+            use omp_lib_kinds
+            integer (kind=omp_integer_kind) omp_get_max_task_priority
+          end function omp_get_max_task_priority
+
 !         ***
 !         *** kmp_* entry points
 !         ***
 
           subroutine kmp_set_stacksize(size)
             use omp_lib_kinds
             integer (kind=omp_integer_kind) size
           end subroutine kmp_set_stacksize

 !dec$ attributes alias:'OMP_GET_WTICK' :: omp_get_wtick
 !dec$ attributes alias:'OMP_GET_DEFAULT_DEVICE' :: omp_get_default_device
 !dec$ attributes alias:'OMP_SET_DEFAULT_DEVICE' :: omp_set_default_device
 !dec$ attributes alias:'OMP_GET_NUM_DEVICES' :: omp_get_num_devices
 !dec$ attributes alias:'OMP_GET_NUM_TEAMS' :: omp_get_num_teams
 !dec$ attributes alias:'OMP_GET_TEAM_NUM' :: omp_get_team_num
 !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_MAX_TASK_PRIORITY' :: omp_get_max_task_priority
 
 !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

 !dec$ attributes alias:'_OMP_GET_WTICK' :: omp_get_wtick
 !dec$ attributes alias:'_OMP_GET_DEFAULT_DEVICE' :: omp_get_default_device
 !dec$ attributes alias:'_OMP_SET_DEFAULT_DEVICE' :: omp_set_default_device
 !dec$ attributes alias:'_OMP_GET_NUM_DEVICES' :: omp_get_num_devices
 !dec$ attributes alias:'_OMP_GET_NUM_TEAMS' :: omp_get_num_teams
 !dec$ attributes alias:'_OMP_GET_TEAM_NUM' :: omp_get_team_num
 !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_MAX_TASK_PRIORTY' :: omp_get_max_task_priority
 
 !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

 !dec$ attributes alias:'omp_get_wtick_'::omp_get_wtick
 !dec$ attributes alias:'omp_get_default_device_'::omp_get_default_device
 !dec$ attributes alias:'omp_set_default_device_'::omp_set_default_device
 !dec$ attributes alias:'omp_get_num_devices_'::omp_get_num_devices
 !dec$ attributes alias:'omp_get_num_teams_'::omp_get_num_teams
 !dec$ attributes alias:'omp_get_team_num_'::omp_get_team_num
 !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_max_task_priority_'::omp_get_max_task_priority
 
 !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

 !dec$ attributes alias:'_omp_get_schedule_'::omp_get_schedule
 !dec$ attributes alias:'_omp_get_proc_bind_' :: omp_get_proc_bind
 !dec$ attributes alias:'_omp_get_wtime_'::omp_get_wtime
 !dec$ attributes alias:'_omp_get_wtick_'::omp_get_wtick
 !dec$ attributes alias:'_omp_get_num_teams_'::omp_get_num_teams
 !dec$ attributes alias:'_omp_get_team_num_'::omp_get_team_num
 !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_max_task_priorty_'::omp_get_max_task_priority
 
 !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

runtime/src/include/41/omp_lib.f90.var

 !DIR$ IF(__INTEL_COMPILER.GE.1400)
 !DIR$ attributes known_intrinsic :: omp_test_nest_lock
 !DIR$ ENDIF
             use omp_lib_kinds
             integer (kind=omp_integer_kind) omp_test_nest_lock
             integer (kind=omp_nest_lock_kind) lockvar
           end function omp_test_nest_lock
 
+          function omp_get_max_task_priority() bind(c)
+            use omp_lib_kinds
+            integer (kind=omp_integer_kind) omp_get_max_task_priority
+          end function omp_get_max_task_priority
+
 !         ***
 !         *** kmp_* entry points
 !         ***
 
           subroutine kmp_set_stacksize(size) bind(c)
             use omp_lib_kinds
             integer (kind=omp_integer_kind), value :: size
           end subroutine kmp_set_stacksize

runtime/src/kmp.h

 #define KMP_MAX_ORDERED         8
 
 #define KMP_MAX_FIELDS          32
 
 #define KMP_MAX_BRANCH_BITS     31
 
 #define KMP_MAX_ACTIVE_LEVELS_LIMIT INT_MAX
 
+#define KMP_MAX_TASK_PRIORITY_LIMIT INT_MAX
+
 /* Minimum number of threads before switch to TLS gtid (experimentally determined) */
 /* josh TODO: what about OS X* tuning? */
 #if   KMP_ARCH_X86 || KMP_ARCH_X86_64
 # define KMP_TLS_GTID_MIN     5
 #else
 # define KMP_TLS_GTID_MIN     INT_MAX
 #endif
 
typedef enum kmp_tasking_mode {
     tskm_immediate_exec = 0,
     tskm_extra_barrier = 1,
     tskm_task_teams = 2,
     tskm_max = 2
 } kmp_tasking_mode_t;
 
 extern kmp_tasking_mode_t __kmp_tasking_mode;         /* determines how/when to execute tasks */
 extern kmp_int32 __kmp_task_stealing_constraint;
+#if OMP_41_ENABLED
+    extern kmp_int32 __kmp_max_task_priority; // Set via OMP_MAX_TASK_PRIORITY if specified, defaults to 0 otherwise
+#endif
 
 /* NOTE: kmp_taskdata_t and kmp_task_t structures allocated in single block with taskdata first */
 #define KMP_TASK_TO_TASKDATA(task)     (((kmp_taskdata_t *) task) - 1)
 #define KMP_TASKDATA_TO_TASK(taskdata) (kmp_task_t *) (taskdata + 1)
 
 // The tt_found_tasks flag is a signal to all threads in the team that tasks were spawned and
 // queued since the previous barrier release.
 #define KMP_TASKING_ENABLED(task_team) \
     (TCR_SYNC_4((task_team)->tt.tt_found_tasks) == TRUE)
 /*!
 @ingroup BASIC_TYPES
 @{
 */
 
 /*!
  */
 typedef kmp_int32 (* kmp_routine_entry_t)( kmp_int32, void * );
 
+#if OMP_40_ENABLED || OMP_41_ENABLED
+typedef union kmp_cmplrdata {
+#if OMP_41_ENABLED
+    kmp_int32           priority;           /**< priority specified by user for the task */
+#endif // OMP_41_ENABLED
+#if OMP_40_ENABLED
+    kmp_routine_entry_t destructors;        /* pointer to function to invoke deconstructors of firstprivate C++ objects */
+#endif // OMP_40_ENABLED
+    /* future data */
+} kmp_cmplrdata_t;
+#endif
+
 /*  sizeof_kmp_task_t passed as arg to kmpc_omp_task call  */
 /*!
  */
 typedef struct kmp_task {                   /* GEH: Shouldn't this be aligned somehow? */
     void *              shareds;            /**< pointer to block of pointers to shared vars   */
     kmp_routine_entry_t routine;            /**< pointer to routine to call for executing task */
     kmp_int32           part_id;            /**< part id for the task                          */
-#if OMP_40_ENABLED
-    kmp_routine_entry_t destructors;        /* pointer to function to invoke deconstructors of firstprivate C++ objects */
-#endif // OMP_40_ENABLED
+#if OMP_40_ENABLED || OMP_41_ENABLED
+    kmp_cmplrdata_t data1;                  /* Two known optional additions: destructors and priority */
+    kmp_cmplrdata_t data2;                  /* Process destructors first, priority second */
+    /* future data */
+#endif
     /*  private vars  */
 } kmp_task_t;
 
 /*!
 @}
 */
 
 #if OMP_40_ENABLED
typedef struct kmp_tasking_flags {          /* Total struct must be exactly 32 bits */
     /* Compiler flags */                    /* Total compiler flags must be 16 bits */
     unsigned tiedness    : 1;               /* task is either tied (1) or untied (0) */
     unsigned final       : 1;               /* task is final(1) so execute immediately */
     unsigned merged_if0  : 1;               /* no __kmpc_task_{begin/complete}_if0 calls in if0 code path */
 #if OMP_40_ENABLED
     unsigned destructors_thunk : 1;         /* set if the compiler creates a thunk to invoke destructors from the runtime */
 #if OMP_41_ENABLED
     unsigned proxy       : 1;               /* task is a proxy task (it will be executed outside the context of the RTL) */
-    unsigned reserved    : 11;              /* reserved for compiler use */
+    unsigned priority_specified :1;         /* set if the compiler provides priority setting for the task */
+    unsigned reserved    : 10;              /* 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 */

runtime/src/kmp_ftn_entry.h

#ifdef KMP_STUB
     return 0 /* false */;
 #else
     return __kmp_get_cancellation_status(cancel_kind);
 #endif
 }
 
 #endif // OMP_40_ENABLED
 
+#if OMP_41_ENABLED
+/* returns the maximum allowed task priority */
+int FTN_STDCALL
+FTN_GET_MAX_TASK_PRIORITY( void )
+{
+#ifdef KMP_STUB
+    return 0;
+#else
+    if ( ! __kmp_init_serial ) {
+        __kmp_serial_initialize();
+    }
+    return __kmp_max_task_priority;
+#endif
+}
+#endif
+
 // GCC compatibility (versioned symbols)
 #ifdef KMP_USE_VERSION_SYMBOLS
 
 /*
     These following sections create function aliases (dummy symbols) for the omp_* routines.
     These aliases will then be versioned according to how libgomp ``versions'' its
     symbols (OMP_1.0, OMP_2.0, OMP_3.0, ...) while also retaining the
     default version which libomp uses: VERSION (defined in exports_so.txt)

runtime/src/kmp_ftn_os.h

#endif
     #define FTN_IS_INITIAL_DEVICE                omp_is_initial_device
 #endif
 
 #if OMP_40_ENABLED
     #define FTN_GET_CANCELLATION                 omp_get_cancellation
     #define FTN_GET_CANCELLATION_STATUS          kmp_get_cancellation_status
 #endif
 
+#if OMP_41_ENABLED
+    #define FTN_GET_MAX_TASK_PRIORITY            omp_get_max_task_priority
+#endif
+
 #endif /* KMP_FTN_PLAIN */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_APPEND
 
     #define FTN_SET_STACKSIZE                    kmp_set_stacksize_
     #define FTN_SET_STACKSIZE_S                  kmp_set_stacksize_s_

 #endif
 
 
 #if OMP_40_ENABLED
     #define FTN_GET_CANCELLATION                 omp_get_cancellation_
     #define FTN_GET_CANCELLATION_STATUS          kmp_get_cancellation_status_
 #endif
 
+#if OMP_41_ENABLED
+    #define FTN_GET_MAX_TASK_PRIORITY            omp_get_max_task_priority_
+#endif
+
 #endif /* KMP_FTN_APPEND */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UPPER
 
     #define FTN_SET_STACKSIZE                    KMP_SET_STACKSIZE
     #define FTN_SET_STACKSIZE_S                  KMP_SET_STACKSIZE_S

 #endif
 
 
 #if OMP_40_ENABLED
     #define FTN_GET_CANCELLATION                 OMP_GET_CANCELLATION
     #define FTN_GET_CANCELLATION_STATUS          KMP_GET_CANCELLATION_STATUS
 #endif
 
+#if OMP_41_ENABLED
+    #define FTN_GET_MAX_TASK_PRIORITY            OMP_GET_MAX_TASK_PRIORITY
+#endif
+
 #endif /* KMP_FTN_UPPER */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UAPPEND
 
     #define FTN_SET_STACKSIZE                    KMP_SET_STACKSIZE_
     #define FTN_SET_STACKSIZE_S                  KMP_SET_STACKSIZE_S_

 #endif
 
 
 #if OMP_40_ENABLED
     #define FTN_GET_CANCELLATION                 OMP_GET_CANCELLATION_
     #define FTN_GET_CANCELLATION_STATUS          KMP_GET_CANCELLATION_STATUS_
 #endif
 
+#if OMP_41_ENABLED
+    #define FTN_GET_MAX_TASK_PRIORITY            OMP_GET_MAX_TASK_PRIORITY_
+#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
 #define KMP_API_NAME_GOMP_BARRIER                      GOMP_barrier

runtime/src/kmp_global.c

 
 int __kmp_place_num_sockets = 0;
 int __kmp_place_socket_offset = 0;
 int __kmp_place_num_cores = 0;
 int __kmp_place_core_offset = 0;
 int __kmp_place_num_threads_per_core = 0;
 
 kmp_tasking_mode_t __kmp_tasking_mode = tskm_task_teams;
+#if OMP_41_ENABLED
+kmp_int32 __kmp_max_task_priority = 0;
+#endif
 
 /* This check ensures that the compiler is passing the correct data type
  * for the flags formal parameter of the function kmpc_omp_task_alloc().
  * If the type is not a 4-byte type, then give an error message about
  * a non-positive length array pointing here.  If that happens, the
  * kmp_tasking_flags_t structure must be redefined to have exactly 32 bits.
  */
 KMP_BUILD_ASSERT( sizeof(kmp_tasking_flags_t) == 4 );

runtime/src/kmp_settings.c

 
 static void
 __kmp_stg_print_task_stealing( kmp_str_buf_t * buffer, char const * name, void * data ) {
     __kmp_stg_print_int( buffer, name, __kmp_task_stealing_constraint );
 } // __kmp_stg_print_task_stealing
 
 static void
 __kmp_stg_parse_max_active_levels( char const * name, char const * value, void * data ) {
-   __kmp_stg_parse_int( name, value, 0, KMP_MAX_ACTIVE_LEVELS_LIMIT, & __kmp_dflt_max_active_levels );
+    __kmp_stg_parse_int( name, value, 0, KMP_MAX_ACTIVE_LEVELS_LIMIT, & __kmp_dflt_max_active_levels );
 } // __kmp_stg_parse_max_active_levels
 
 static void
 __kmp_stg_print_max_active_levels( kmp_str_buf_t * buffer, char const * name, void * data ) {
     __kmp_stg_print_int( buffer, name, __kmp_dflt_max_active_levels );
 } // __kmp_stg_print_max_active_levels
 
+#if OMP_41_ENABLED
+// -------------------------------------------------------------------------------------------------
+// OpenMP 4.5: OMP_MAX_TASK_PRIORITY
+// -------------------------------------------------------------------------------------------------
+static void
+__kmp_stg_parse_max_task_priority(char const *name, char const *value, void *data) {
+    __kmp_stg_parse_int(name, value, 0, KMP_MAX_TASK_PRIORITY_LIMIT, &__kmp_max_task_priority);
+} // __kmp_stg_parse_max_task_priority
+
+static void
+__kmp_stg_print_max_task_priority(kmp_str_buf_t *buffer, char const *name, void *data) {
+    __kmp_stg_print_int(buffer, name, __kmp_max_task_priority);
+} // __kmp_stg_print_max_task_priority
+#endif // OMP_41_ENABLED
+
 #if KMP_NESTED_HOT_TEAMS
 // -------------------------------------------------------------------------------------------------
 // KMP_HOT_TEAMS_MAX_LEVEL, KMP_HOT_TEAMS_MODE
 // -------------------------------------------------------------------------------------------------
 
 static void
 __kmp_stg_parse_hot_teams_level( char const * name, char const * value, void * data ) {
     if ( TCR_4(__kmp_init_parallel) ) {
static kmp_setting_t __kmp_stg_table[] = {
 
     { "OMP_NESTED",                        __kmp_stg_parse_nested,             __kmp_stg_print_nested,             NULL, 0, 0 },
     { "OMP_NUM_THREADS",                   __kmp_stg_parse_num_threads,        __kmp_stg_print_num_threads,        NULL, 0, 0 },
     { "OMP_STACKSIZE",                     __kmp_stg_parse_stacksize,          __kmp_stg_print_stacksize,          NULL, 0, 0 },
 
     { "KMP_TASKING",                       __kmp_stg_parse_tasking,            __kmp_stg_print_tasking,            NULL, 0, 0 },
     { "KMP_TASK_STEALING_CONSTRAINT",      __kmp_stg_parse_task_stealing,      __kmp_stg_print_task_stealing,      NULL, 0, 0 },
     { "OMP_MAX_ACTIVE_LEVELS",             __kmp_stg_parse_max_active_levels,  __kmp_stg_print_max_active_levels,  NULL, 0, 0 },
+#if OMP_41_ENABLED
+    { "OMP_MAX_TASK_PRIORITY",             __kmp_stg_parse_max_task_priority,  __kmp_stg_print_max_task_priority,  NULL, 0, 0 },
+#endif
     { "OMP_THREAD_LIMIT",                  __kmp_stg_parse_all_threads,        __kmp_stg_print_all_threads,        NULL, 0, 0 },
     { "OMP_WAIT_POLICY",                   __kmp_stg_parse_wait_policy,        __kmp_stg_print_wait_policy,        NULL, 0, 0 },
 #if KMP_NESTED_HOT_TEAMS
     { "KMP_HOT_TEAMS_MAX_LEVEL",           __kmp_stg_parse_hot_teams_level,    __kmp_stg_print_hot_teams_level,    NULL, 0, 0 },
     { "KMP_HOT_TEAMS_MODE",                __kmp_stg_parse_hot_teams_mode,     __kmp_stg_print_hot_teams_mode,     NULL, 0, 0 },
 #endif // KMP_NESTED_HOT_TEAMS
 
 #if KMP_HANDLE_SIGNALS

runtime/src/kmp_tasking.c

 
 #if OMP_40_ENABLED
     /* If the tasks' destructor thunk flag has been set, we need to invoke the
        destructor thunk that has been generated by the compiler.
        The code is placed here, since at this point other tasks might have been released
        hence overlapping the destructor invokations with some other work in the
        released tasks.  The OpenMP spec is not specific on when the destructors are
        invoked, so we should be free to choose.
-     */
     if (taskdata->td_flags.destructors_thunk) {
-        kmp_routine_entry_t destr_thunk = task->destructors;
+        kmp_routine_entry_t destr_thunk = task->data1.destructors;
         KMP_ASSERT(destr_thunk);
         destr_thunk(gtid, task);
     }
 #endif // OMP_40_ENABLED
 
     // bookkeeping for resuming task:
     // GEH - note tasking_ser => task_serial
     KMP_DEBUG_ASSERT( (taskdata->td_flags.tasking_ser || taskdata->td_flags.task_serial) ==

runtime/test/lit.cfg

if config.operating_system == 'Darwin':
   out, err = cmd.communicate()
   out = out.strip()
   res = cmd.wait()
   if res == 0 and out:
     config.test_cflags += " -isysroot " + out
 
 # substitutions
 config.substitutions.append(("%libomp-compile-and-run", \
-    "%clang %cflags %s -o %t -lm && %t"))
+    "%libomp-compile && %libomp-run"))
+config.substitutions.append(("%libomp-compile", \
+    "%clang %cflags %s -o %t -lm"))
+config.substitutions.append(("%libomp-run", "%t"))
 config.substitutions.append(("%clang", config.test_compiler))
 config.substitutions.append(("%openmp_flag", config.test_openmp_flag))
 config.substitutions.append(("%cflags", config.test_cflags))
 

runtime/test/tasking/omp_task_priority.c

+// RUN: %libomp-compile && env OMP_MAX_TASK_PRIORITY=42 %libomp-run
+// Test OMP 4.5 task priorities
+// Currently only API function and envirable parsing implemented.
+// Test environment sets envirable: OMP_MAX_TASK_PRIORITY=42 as tested below.
+#include <stdio.h>
+#include <omp.h>
+
+int main (void) {
+    int passed;
+
+    passed = (omp_get_max_task_priority() == 42);    
+    printf("Got %d\n", omp_get_max_task_priority());
+
+    if (passed) {
+       printf("passed\n");
+       return 0;
+    }
+
+    printf("failed\n");
+    return 1;
+}
+