[OpenMP] Initial implementation of OMP 5.0 Memory Management routines

[jlpeyton]

Summary

Implemented omp_alloc, omp_free, omp_{set,get}_default_allocator entries,
and OMP_ALLOCATOR environment variable.

Added support for HBW memory on Linux if libmemkind.so library is accessible
(dynamic library only, no support for static libraries).
Only used stable API (hbwmalloc) of the memkind library
though we may consider using experimental API in future.

The ICV def-allocator-var is implemented per implicit task similar to place-partition-var.
In the absence of a requested allocator, the uses the default allocator.

Predefined allocators (the only ones currently available) are made similar
for C and Fortran, - pointers (long integers) with values 1 to 8.

Patch by Andrey Churbanov

[Hahnfeld]

runtime/src/kmp_alloc.cpp

1318–1323 ↗

(On Diff #162465)

Does that mean we return NULL if allocator == omp_high_bw_mem_alloc && !__kmp_hbw_mem_available? Would it make sense to fallback to omp_default_mem_alloc in this case?

runtime/tools/generate-def.pl

113–123 ↗

(On Diff #162465)

Can the commented lines be removed?

[AndreyChurbanov]

runtime/src/kmp_alloc.cpp

1318–1323 ↗

(On Diff #162465)

The "return NULL" id the requirement of the current OpenMP spec TRF6 (Nov 2017) which current change is related to. Next version - TR7 draft (and the following OpenMP 5.0 to be released in Nov 2018) - does not have this requirement, but also has some extensions to implement in runtime (custom memory allocators). So the plan is to consider the different default policy with future patch that implements OpenMP 5.0 extensions. Next versions of the specification will have further extensions (custom memory spaces); we won't start implementing them until we get more details.

[Hahnfeld]

runtime/src/kmp_alloc.cpp

1318–1323 ↗

(On Diff #162465)

I see: The fallback trait is an extension of TR7. For reference its default value appears to be default_mem_fb (so my intuition was correct) but that doesn't matter if this patch implements the behavior defined by TR6.

[jlpeyton]

Removed commented lines from generate-def.pl

[hbae]

LGTM.

[pawosm01]

This commit is bit damaging for those who want to use libomp.a for -static built applications. As KMP_DYNAMIC_LIB is hardcoded to 1 in kmp_config.h.cmake, dlopen will always be used causing following link-time warning:

warning: Using 'dlopen' in statically linked applications requires at runtime the shared libraries from the glibc version used for linking

This makes virtually impossible to copy libomp.a across various Linux boxes or shipping libomp.a in binary libomp packages addressed to various Linux systems.

openmp/trunk/runtime/src/dllexports

%ifdef stub
         omp_target_memcpy_rect              887
         omp_target_associate_ptr            888
         omp_target_disassociate_ptr         889
     %endif
 %endif # OMP_45
 
 kmp_set_disp_num_buffers                    890
 
+%ifdef OMP_50
+    omp_control_tool                        891
+    omp_set_default_allocator               892
+    omp_get_default_allocator               893
+    omp_alloc                               894
+    omp_free                                895
+
+    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
+    omp_pteam_mem_alloc                    DATA
+    omp_thread_mem_alloc                   DATA
+%endif # OMP_50
+
 %ifndef stub
     # Ordinals between 900 and 999 are reserved
 
     # Ordinals between 1000 and 1999 are reserved
     # for user-callable uppercase Fortran entries.
 
 
     # ATOMIC entries

openmp/trunk/runtime/src/exports_so.txt

 VERSION {
 
     global: # Exported symbols.
 
         #
         # "Normal" symbols.
         #
         omp_*;     # Standard OpenMP functions.
+        OMP_*;     # Standard OpenMP symbols.
 
         #
         # OMPT API
         #
         ompt_start_tool;     # OMPT start interface
 
         # icc drops weak attribute at linking step without the following line:
         Annotate*;           # TSAN annotation

openmp/trunk/runtime/src/i18n/en_US.txt

OBSOLETE                     "%1$s: overrides %3$s specified before"
                                  # %1, %2 -- name and value of the overriding variable, %3 -- name of overriden variable.
 AffTilesNoHWLOC              "%1$s: Tiles are only supported if KMP_TOPOLOGY_METHOD=hwloc, using granularity=package instead"
 AffTilesNoTiles              "%1$s: Tiles requested but were not detected on this HW, using granularity=package instead"
 TopologyExtraTile            "%1$s: %2$d packages x %3$d tiles/pkg x %4$d cores/tile x %5$d threads/core (%6$d total cores)"
 TopologyExtraNode            "%1$s: %2$d packages x %3$d nodes/pkg x %4$d cores/node x %5$d threads/core (%6$d total cores)"
 TopologyExtraNoTi            "%1$s: %2$d packages x %3$d nodes/pkg x %4$d tiles/node x %5$d cores/tile x %6$d threads/core (%7$d total cores)"
 OmptOutdatedWorkshare        "OMPT: Cannot determine workshare type; using the default (loop) instead. "
                              "This issue is fixed in an up-to-date compiler."
+OmpNoAllocator               "Allocator %1$s is not available, will use default allocator."
 
 # --- OpenMP errors detected at runtime ---
 #
 #    %1 is the name of OpenMP construct (formatted with "Pragma" format).
 #
 CnsBoundToWorksharing        "%1$s must be bound to a work-sharing or work-queuing construct with an \"ordered\" clause"
 CnsDetectedEnd               "Detected end of %1$s without first executing a corresponding beginning."
 CnsIterationRangeTooLarge    "Iteration range too large in %1$s."

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

 #   define KMP_BUILD_DATE       "@LIBOMP_BUILD_DATE@"
 
 #   ifdef __cplusplus
     extern "C" {
 #   endif
 
 #   if defined(_WIN32)
 #       define __KAI_KMPC_CONVENTION __cdecl
+#       ifndef __KMP_IMP
+#           define __KMP_IMP __declspec(dllimport)
+#       endif
 #   else
 #       define __KAI_KMPC_CONVENTION
+#       ifndef __KMP_IMP
+#           define __KMP_IMP
+#       endif
 #   endif
 
     /* schedule kind constants */
     typedef enum omp_sched_t {
   omp_sched_static  = 1,
   omp_sched_dynamic = 2,
   omp_sched_guided  = 3,
   omp_sched_auto    = 4
typedef enum omp_control_tool_t {
         omp_control_tool_start = 1,
         omp_control_tool_pause = 2,
         omp_control_tool_flush = 3,
         omp_control_tool_end = 4
     } omp_control_tool_t;
     
     extern int __KAI_KMPC_CONVENTION omp_control_tool(int, int, void*);
 
+    /* OpenMP 5.0 Memory Management */
+    typedef void *omp_allocator_t;
+    extern __KMP_IMP const omp_allocator_t *OMP_NULL_ALLOCATOR;
+    extern __KMP_IMP const omp_allocator_t *omp_default_mem_alloc;
+    extern __KMP_IMP const omp_allocator_t *omp_large_cap_mem_alloc;
+    extern __KMP_IMP const omp_allocator_t *omp_const_mem_alloc;
+    extern __KMP_IMP const omp_allocator_t *omp_high_bw_mem_alloc;
+    extern __KMP_IMP const omp_allocator_t *omp_low_lat_mem_alloc;
+    extern __KMP_IMP const omp_allocator_t *omp_cgroup_mem_alloc;
+    extern __KMP_IMP const omp_allocator_t *omp_pteam_mem_alloc;
+    extern __KMP_IMP const omp_allocator_t *omp_thread_mem_alloc;
+
+    extern void __KAI_KMPC_CONVENTION omp_set_default_allocator(const omp_allocator_t *);
+    extern const omp_allocator_t * __KAI_KMPC_CONVENTION omp_get_default_allocator(void);
+#ifdef __cplusplus
+    extern void *__KAI_KMPC_CONVENTION omp_alloc(size_t size, const omp_allocator_t *allocator = OMP_NULL_ALLOCATOR);
+    extern void __KAI_KMPC_CONVENTION omp_free(void * ptr, const omp_allocator_t *allocator = OMP_NULL_ALLOCATOR);
+#else
+    extern void *__KAI_KMPC_CONVENTION omp_alloc(size_t size, const omp_allocator_t *allocator);
+    extern void __KAI_KMPC_CONVENTION omp_free(void *ptr, const omp_allocator_t *allocator);
+#endif
+
 #   undef __KAI_KMPC_CONVENTION
+#   undef __KMP_IMP
 
     /* Warning:
        The following typedefs are not standard, deprecated and will be removed in a future release.
     */
     typedef int     omp_int_t;
     typedef double  omp_wtime_t;
 
 #   ifdef __cplusplus
     }
 #   endif
 
 #endif /* __OMP_H */
 

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

!
       integer kmp_affinity_mask_kind
       parameter(kmp_affinity_mask_kind=int_ptr_kind())
       integer omp_lock_hint_kind
       parameter(omp_lock_hint_kind=omp_integer_kind)
       integer omp_control_tool_kind
       parameter(omp_control_tool_kind=omp_integer_kind)
       integer omp_control_tool_result_kind
       parameter(omp_control_tool_result_kind=omp_integer_kind)
+      integer omp_allocator_kind
+      parameter(omp_allocator_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
!
       parameter(omp_control_tool_notool=-2)
       integer(kind=omp_integer_kind)omp_control_tool_nocallback
       parameter(omp_control_tool_nocallback=-1)
       integer(kind=omp_control_tool_result_kind)omp_control_tool_success
       parameter(omp_control_tool_success=0)
       integer(kind=omp_control_tool_result_kind)omp_control_tool_ignored
       parameter(omp_control_tool_ignored=1)
 
+      integer (kind=omp_allocator_kind), parameter :: omp_null_allocator = 0
+      integer (kind=omp_allocator_kind), parameter :: omp_default_mem_alloc = 1
+      integer (kind=omp_allocator_kind), parameter :: omp_large_cap_mem_alloc = 2
+      integer (kind=omp_allocator_kind), parameter :: omp_const_mem_alloc = 3
+      integer (kind=omp_allocator_kind), parameter :: omp_high_bw_mem_alloc = 4
+      integer (kind=omp_allocator_kind), parameter :: omp_low_lat_mem_alloc = 5
+      integer (kind=omp_allocator_kind), parameter :: omp_cgroup_mem_alloc = 6
+      integer (kind=omp_allocator_kind), parameter :: omp_pteam_mem_alloc = 7
+      integer (kind=omp_allocator_kind), parameter :: omp_thread_mem_alloc = 8
+
       interface
 
 !       ***
 !       *** omp_* entry points
 !       ***
 
         subroutine omp_set_num_threads(num_threads) bind(c)
           import
!DIR$ ENDIF
           integer (kind=omp_nest_lock_kind) nvar
         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
 
+        subroutine omp_set_default_allocator(svar) bind(c)
+          import
+          integer (kind=omp_allocator_kind), value :: svar
+        end subroutine omp_set_default_allocator
+
+        function omp_get_default_allocator() bind(c)
+          import
+          integer (kind=omp_allocator_kind) omp_get_default_allocator
+        end function omp_get_default_allocator
+
 !       ***
 !       *** kmp_* entry points
 !       ***
 
         subroutine kmp_set_stacksize(size) bind(c)
           import
           integer (kind=omp_integer_kind), value :: size
         end subroutine kmp_set_stacksize

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

!dec$ fixedformlinesize:132
         integer, parameter :: omp_proc_bind_kind     = omp_integer_kind
         integer, parameter :: kmp_pointer_kind       = int_ptr_kind()
         integer, parameter :: kmp_size_t_kind        = int_ptr_kind()
         integer, parameter :: kmp_affinity_mask_kind = int_ptr_kind()
         integer, parameter :: kmp_cancel_kind        = omp_integer_kind
         integer, parameter :: omp_lock_hint_kind     = omp_integer_kind
         integer, parameter :: omp_control_tool_kind  = omp_integer_kind
         integer, parameter :: omp_control_tool_result_kind = omp_integer_kind
+        integer, parameter :: omp_allocator_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@
!dec$ fixedformlinesize:132
         integer (kind=omp_lock_hint_kind), parameter :: omp_lock_hint_uncontended    = 1
         integer (kind=omp_lock_hint_kind), parameter :: omp_lock_hint_contended      = 2
         integer (kind=omp_lock_hint_kind), parameter :: omp_lock_hint_nonspeculative = 4
         integer (kind=omp_lock_hint_kind), parameter :: omp_lock_hint_speculative    = 8
         integer (kind=omp_lock_hint_kind), parameter :: kmp_lock_hint_hle            = 65536
         integer (kind=omp_lock_hint_kind), parameter :: kmp_lock_hint_rtm            = 131072
         integer (kind=omp_lock_hint_kind), parameter :: kmp_lock_hint_adaptive       = 262144
 
+        integer (kind=omp_allocator_kind), parameter :: omp_null_allocator = 0
+        integer (kind=omp_allocator_kind), parameter :: omp_default_mem_alloc = 1
+        integer (kind=omp_allocator_kind), parameter :: omp_large_cap_mem_alloc = 2
+        integer (kind=omp_allocator_kind), parameter :: omp_const_mem_alloc = 3
+        integer (kind=omp_allocator_kind), parameter :: omp_high_bw_mem_alloc = 4
+        integer (kind=omp_allocator_kind), parameter :: omp_low_lat_mem_alloc = 5
+        integer (kind=omp_allocator_kind), parameter :: omp_cgroup_mem_alloc = 6
+        integer (kind=omp_allocator_kind), parameter :: omp_pteam_mem_alloc = 7
+        integer (kind=omp_allocator_kind), parameter :: omp_thread_mem_alloc = 8
+
         interface
 
 !         ***
 !         *** omp_* entry points
 !         ***
 
           subroutine omp_set_num_threads(num_threads)
             use omp_lib_kinds
!DIR$ ENDIF
             integer (kind=omp_nest_lock_kind) nvar
           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
 
+          subroutine omp_set_default_allocator(svar)
+            use omp_lib_kinds
+            integer (kind=omp_allocator_kind) svar
+          end subroutine omp_set_default_allocator
+
+          function omp_get_default_allocator()
+            use omp_lib_kinds
+            integer (kind=omp_allocator_kind) omp_get_default_allocator
+          end function omp_get_default_allocator
+
 !         ***
 !         *** kmp_* entry points
 !         ***
 
           subroutine kmp_set_stacksize(size)
             use omp_lib_kinds
             integer (kind=omp_integer_kind) size
           end subroutine kmp_set_stacksize

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

!
         integer, parameter :: omp_proc_bind_kind     = omp_integer_kind
         integer, parameter :: kmp_pointer_kind       = c_intptr_t
         integer, parameter :: kmp_size_t_kind        = c_size_t
         integer, parameter :: kmp_affinity_mask_kind = c_intptr_t
         integer, parameter :: kmp_cancel_kind        = omp_integer_kind
         integer, parameter :: omp_lock_hint_kind     = omp_integer_kind
         integer, parameter :: omp_control_tool_kind  = omp_integer_kind
         integer, parameter :: omp_control_tool_result_kind = omp_integer_kind
+        integer, parameter :: omp_allocator_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_control_tool_kind), parameter :: omp_control_tool_flush = 3
         integer (kind=omp_control_tool_kind), parameter :: omp_control_tool_end = 4
 
         integer (kind=omp_control_tool_result_kind), parameter :: omp_control_tool_notool = -2
         integer (kind=omp_control_tool_result_kind), parameter :: omp_control_tool_nocallback = -1
         integer (kind=omp_control_tool_result_kind), parameter :: omp_control_tool_success = 0
         integer (kind=omp_control_tool_result_kind), parameter :: omp_control_tool_ignored = 1
 
+        integer (kind=omp_allocator_kind), parameter :: omp_null_allocator = 0
+        integer (kind=omp_allocator_kind), parameter :: omp_default_mem_alloc = 1
+        integer (kind=omp_allocator_kind), parameter :: omp_large_cap_mem_alloc = 2
+        integer (kind=omp_allocator_kind), parameter :: omp_const_mem_alloc = 3
+        integer (kind=omp_allocator_kind), parameter :: omp_high_bw_mem_alloc = 4
+        integer (kind=omp_allocator_kind), parameter :: omp_low_lat_mem_alloc = 5
+        integer (kind=omp_allocator_kind), parameter :: omp_cgroup_mem_alloc = 6
+        integer (kind=omp_allocator_kind), parameter :: omp_pteam_mem_alloc = 7
+        integer (kind=omp_allocator_kind), parameter :: omp_thread_mem_alloc = 8
+
         interface
 
 !         ***
 !         *** omp_* entry points
 !         ***
 
           subroutine omp_set_num_threads(num_threads) bind(c)
             use omp_lib_kinds
!DIR$ ENDIF
             integer (kind=omp_nest_lock_kind) nvar
           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
 
+          subroutine omp_set_default_allocator(svar) bind(c)
+            use omp_lib_kinds
+            integer (kind=omp_allocator_kind), value :: svar
+          end subroutine omp_set_default_allocator
+
+          function omp_get_default_allocator() bind(c)
+            use omp_lib_kinds
+            integer (kind=omp_allocator_kind) omp_get_default_allocator
+          end function omp_get_default_allocator
+
 !         ***
 !         *** 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

openmp/trunk/runtime/src/kmp.h

 // We need to avoid using -1 as a GTID as +1 is added to the gtid
 // when storing it in a lock, and the value 0 is reserved.
 #define KMP_GTID_DNE (-2) /* Does not exist */
 #define KMP_GTID_SHUTDOWN (-3) /* Library is shutting down */
 #define KMP_GTID_MONITOR (-4) /* Monitor thread ID */
 #define KMP_GTID_UNKNOWN (-5) /* Is not known */
 #define KMP_GTID_MIN (-6) /* Minimal gtid for low bound check in DEBUG */
 
+#if OMP_50_ENABLED
+/* OpenMP 5.0 Memory Management support */
+extern int __kmp_memkind_available;
+extern int __kmp_hbw_mem_available;
+typedef void *omp_allocator_t;
+extern const omp_allocator_t *OMP_NULL_ALLOCATOR;
+extern const omp_allocator_t *omp_default_mem_alloc;
+extern const omp_allocator_t *omp_large_cap_mem_alloc;
+extern const omp_allocator_t *omp_const_mem_alloc;
+extern const omp_allocator_t *omp_high_bw_mem_alloc;
+extern const omp_allocator_t *omp_low_lat_mem_alloc;
+extern const omp_allocator_t *omp_cgroup_mem_alloc;
+extern const omp_allocator_t *omp_pteam_mem_alloc;
+extern const omp_allocator_t *omp_thread_mem_alloc;
+extern const omp_allocator_t *__kmp_def_allocator;
+
+extern void __kmpc_set_default_allocator(int gtid, const omp_allocator_t *al);
+extern const omp_allocator_t *__kmpc_get_default_allocator(int gtid);
+extern void *__kmpc_alloc(int gtid, size_t sz, const omp_allocator_t *al);
+extern void __kmpc_free(int gtid, void *ptr, const omp_allocator_t *al);
+
+extern void __kmp_init_memkind();
+extern void __kmp_fini_memkind();
+#endif // OMP_50_ENABLED
+
 /* ------------------------------------------------------------------------ */
 
 #define KMP_UINT64_MAX                                                         \
   (~((kmp_uint64)1 << ((sizeof(kmp_uint64) * (1 << 3)) - 1)))
 
 #define KMP_MIN_NTH 1
 
 #ifndef KMP_MAX_NTH
#if KMP_USE_MONITOR
   int th_team_bt_set;
 #else
   kmp_uint64 th_team_bt_intervals;
 #endif
 
 #if KMP_AFFINITY_SUPPORTED
   kmp_affin_mask_t *th_affin_mask; /* thread's current affinity mask */
 #endif
-
+#if OMP_50_ENABLED
+  void *const *th_def_allocator; /* per implicit task default allocator */
+#endif
   /* The data set by the master at reinit, then R/W by the worker */
   KMP_ALIGN_CACHE int
       th_set_nproc; /* if > 0, then only use this request for the next fork */
 #if KMP_NESTED_HOT_TEAMS
   kmp_hot_team_ptr_t *th_hot_teams; /* array of hot teams */
 #endif
 #if OMP_40_ENABLED
   kmp_proc_bind_t
#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
   int t_active_level; // nested active parallel level
   kmp_r_sched_t t_sched; // run-time schedule for the team
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
   int t_first_place; // first & last place in parent thread's partition.
   int t_last_place; // Restore these values to master after par region.
 #endif // OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
   int t_size_changed; // team size was changed?: 0: no, 1: yes, -1: changed via
 // omp_set_num_threads() call
+#if OMP_50_ENABLED
+  void *const *t_def_allocator; /* per implicit task default allocator */
+#endif
 
 // Read/write by workers as well
 #if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
   // Using CACHE_LINE=64 reduces memory footprint, but causes a big perf
   // regression of epcc 'parallel' and 'barrier' on fxe256lin01. This extra
   // padding serves to fix the performance of epcc 'parallel' and 'barrier' when
   // CACHE_LINE=64. TODO: investigate more and get rid if this padding.
   char dummy_padding[1024];

openmp/trunk/runtime/src/kmp_alloc.cpp

KE_TRACE(30, ("-> __kmp_thread_free( %p, %p ) called from %s:%d\n", th,
                 ptr KMP_SRC_LOC_PARM));
   if (ptr != NULL) {
     __kmp_bget_dequeue(th); /* Release any queued buffers */
     brel(th, ptr);
   }
   KE_TRACE(30, ("<- __kmp_thread_free()\n"));
 }
 
+#if OMP_50_ENABLED
+/* OMP 5.0 Memory Management support */
+static int (*p_hbw_check)(void);
+static void *(*p_hbw_malloc)(size_t);
+static void (*p_hbw_free)(void *);
+static int (*p_hbw_set_policy)(int);
+static const char *kmp_mk_lib_name;
+static void *h_memkind;
+
+void __kmp_init_memkind() {
+#if KMP_OS_UNIX && KMP_DYNAMIC_LIB
+  kmp_mk_lib_name = "libmemkind.so";
+  h_memkind = dlopen(kmp_mk_lib_name, RTLD_LAZY);
+  if (h_memkind) {
+    p_hbw_check = (int (*)())dlsym(h_memkind, "hbw_check_available");
+    p_hbw_malloc = (void *(*)(size_t))dlsym(h_memkind, "hbw_malloc");
+    p_hbw_free = (void (*)(void *))dlsym(h_memkind, "hbw_free");
+    p_hbw_set_policy = (int (*)(int))dlsym(h_memkind, "hbw_set_policy");
+    if (p_hbw_check && p_hbw_malloc && p_hbw_free && p_hbw_set_policy) {
+      __kmp_memkind_available = 1;
+      if (p_hbw_check() == 0) {
+        p_hbw_set_policy(1); // return NULL is not enough memory
+        __kmp_hbw_mem_available = 1; // found HBW memory available
+      }
+      return; // success - all symbols resolved
+    }
+    dlclose(h_memkind); // failure
+    h_memkind = NULL;
+  }
+  p_hbw_check = NULL;
+  p_hbw_malloc = NULL;
+  p_hbw_free = NULL;
+  p_hbw_set_policy = NULL;
+#else
+  kmp_mk_lib_name = "";
+  h_memkind = NULL;
+  p_hbw_check = NULL;
+  p_hbw_malloc = NULL;
+  p_hbw_free = NULL;
+  p_hbw_set_policy = NULL;
+#endif
+}
+
+void __kmp_fini_memkind() {
+#if KMP_OS_UNIX && KMP_DYNAMIC_LIB
+  if (h_memkind) {
+    dlclose(h_memkind);
+    h_memkind = NULL;
+  }
+  p_hbw_check = NULL;
+  p_hbw_malloc = NULL;
+  p_hbw_free = NULL;
+  p_hbw_set_policy = NULL;
+#endif
+}
+
+void __kmpc_set_default_allocator(int gtid, const omp_allocator_t *allocator) {
+  if (allocator == OMP_NULL_ALLOCATOR)
+    allocator = omp_default_mem_alloc;
+  KMP_DEBUG_ASSERT(
+      allocator == omp_default_mem_alloc ||
+      allocator == omp_large_cap_mem_alloc ||
+      allocator == omp_const_mem_alloc || allocator == omp_high_bw_mem_alloc ||
+      allocator == omp_low_lat_mem_alloc || allocator == omp_cgroup_mem_alloc ||
+      allocator == omp_pteam_mem_alloc || allocator == omp_thread_mem_alloc);
+  __kmp_threads[gtid]->th.th_def_allocator = allocator;
+}
+const omp_allocator_t *__kmpc_get_default_allocator(int gtid) {
+  return __kmp_threads[gtid]->th.th_def_allocator;
+}
+
+typedef struct kmp_mem_desc { // Memory block descriptor
+  void *ptr_alloc; // Pointer returned by allocator
+  size_t size_a; // Size of allocated memory block (initial+descriptor+align)
+  void *ptr_align; // Pointer to aligned memory, returned
+  const omp_allocator_t *allocator; // allocator
+} kmp_mem_desc_t;
+static int alignment = sizeof(void *); // let's align to pointer size
+
+void *__kmpc_alloc(int gtid, size_t size, const omp_allocator_t *allocator) {
+  KMP_DEBUG_ASSERT(__kmp_init_serial);
+  if (allocator == OMP_NULL_ALLOCATOR)
+    allocator = __kmp_threads[gtid]->th.th_def_allocator;
+
+  int sz_desc = sizeof(kmp_mem_desc_t);
+  void *ptr = NULL;
+  kmp_mem_desc_t desc;
+  kmp_uintptr_t addr; // address returned by allocator
+  kmp_uintptr_t addr_align; // address to return to caller
+  kmp_uintptr_t addr_descr; // address of memory block descriptor
+
+  KE_TRACE(25, ("__kmpc_alloc: T#%d (%d, %p)\n", gtid, (int)size, allocator));
+
+  desc.size_a = size + sz_desc + alignment;
+  if (allocator == omp_default_mem_alloc)
+    ptr = __kmp_allocate(desc.size_a);
+  if (allocator == omp_high_bw_mem_alloc && __kmp_hbw_mem_available) {
+    KMP_DEBUG_ASSERT(p_hbw_malloc != NULL);
+    ptr = p_hbw_malloc(desc.size_a);
+  }
+
+  KE_TRACE(10, ("__kmpc_alloc: T#%d %p=alloc(%d) hbw %d\n", gtid, ptr,
+                desc.size_a, __kmp_hbw_mem_available));
+  if (ptr == NULL)
+    return NULL;
+
+  addr = (kmp_uintptr_t)ptr;
+  addr_align = (addr + sz_desc + alignment - 1) & ~(alignment - 1);
+  addr_descr = addr_align - sz_desc;
+
+  desc.ptr_alloc = ptr;
+  desc.ptr_align = (void *)addr_align;
+  desc.allocator = allocator;
+  *((kmp_mem_desc_t *)addr_descr) = desc; // save descriptor contents
+  KMP_MB();
+
+  KE_TRACE(25, ("__kmpc_alloc returns %p, T#%d\n", desc.ptr_align, gtid));
+  return desc.ptr_align;
+}
+
+void __kmpc_free(int gtid, void *ptr, const omp_allocator_t *allocator) {
+  KE_TRACE(25, ("__kmpc_free: T#%d free(%p,%p)\n", gtid, ptr, allocator));
+  if (ptr == NULL)
+    return;
+
+  kmp_mem_desc_t desc;
+  kmp_uintptr_t addr_align; // address to return to caller
+  kmp_uintptr_t addr_descr; // address of memory block descriptor
+
+  addr_align = (kmp_uintptr_t)ptr;
+  addr_descr = addr_align - sizeof(kmp_mem_desc_t);
+  desc = *((kmp_mem_desc_t *)addr_descr); // read descriptor
+
+  KMP_DEBUG_ASSERT(desc.ptr_align == ptr);
+  if (allocator) {
+    KMP_DEBUG_ASSERT(desc.allocator == allocator);
+  } else {
+    allocator = desc.allocator;
+  }
+  KMP_DEBUG_ASSERT(allocator);
+
+  if (allocator == omp_default_mem_alloc)
+    __kmp_free(desc.ptr_alloc);
+  if (allocator == omp_high_bw_mem_alloc && __kmp_hbw_mem_available) {
+    KMP_DEBUG_ASSERT(p_hbw_free != NULL);
+    p_hbw_free(desc.ptr_alloc);
+  }
+  KE_TRACE(10, ("__kmpc_free: T#%d freed %p (%p)\n", gtid, desc.ptr_alloc,
+                allocator));
+}
+
+#endif
+
 /* If LEAK_MEMORY is defined, __kmp_free() will *not* free memory. It causes
    memory leaks, but it may be useful for debugging memory corruptions, used
    freed pointers, etc. */
 /* #define LEAK_MEMORY */
 struct kmp_mem_descr { // Memory block descriptor.
   void *ptr_allocated; // Pointer returned by malloc(), subject for free().
   size_t size_allocated; // Size of allocated memory block.
   void *ptr_aligned; // Pointer to aligned memory, to be used by client code.

openmp/trunk/runtime/src/kmp_barrier.cpp

if (this_thr->th.th_new_place == this_thr->th.th_current_place) {
       KA_TRACE(100, ("__kmp_fork_barrier: T#%d already in correct place %d\n",
                      __kmp_gtid_from_thread(this_thr),
                      this_thr->th.th_current_place));
     } else {
       __kmp_affinity_set_place(gtid);
     }
   }
 #endif
+#if OMP_50_ENABLED
+  if (!KMP_MASTER_TID(tid))
+    KMP_CHECK_UPDATE(this_thr->th.th_def_allocator, team->t.t_def_allocator);
+#endif
 
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
   if (__itt_sync_create_ptr || KMP_ITT_DEBUG) {
     if (!KMP_MASTER_TID(tid)) {
       // Get correct barrier object
       itt_sync_obj = __kmp_itt_barrier_object(gtid, bs_forkjoin_barrier);
       __kmp_itt_barrier_finished(gtid, itt_sync_obj); // Workers call acquired
     } // (prepare called inside barrier_release)

openmp/trunk/runtime/src/kmp_csupport.cpp

 /*
  * kmp_csupport.cpp -- kfront linkage support for OpenMP.
  */
 
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
+#define __KMP_IMP
 #include "omp.h" /* extern "C" declarations of user-visible routines */
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
 
#endif
   KMP_DEBUG_ASSERT(serial_team->t.t_dispatch->th_disp_buffer);
   {
     dispatch_private_info_t *disp_buffer =
         serial_team->t.t_dispatch->th_disp_buffer;
     serial_team->t.t_dispatch->th_disp_buffer =
         serial_team->t.t_dispatch->th_disp_buffer->next;
     __kmp_free(disp_buffer);
   }
+#if OMP_50_ENABLED
+  this_thr->th.th_def_allocator = serial_team->t.t_def_allocator; // restore
+#endif
 
   --serial_team->t.t_serialized;
   if (serial_team->t.t_serialized == 0) {
 
 /* return to the parallel section */
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
     if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) {

openmp/trunk/runtime/src/kmp_ftn_entry.h

#else
   kmp_info_t *this_thr = __kmp_threads[__kmp_entry_gtid()];
   ompt_task_info_t *parent_task_info = OMPT_CUR_TASK_INFO(this_thr);
   parent_task_info->frame.enter_frame = OMPT_GET_FRAME_ADDRESS(1);
   int ret = __kmp_control_tool(command, modifier, arg);
   parent_task_info->frame.enter_frame = 0;
   return ret;
 #endif
 }
+
+/* OpenMP 5.0 Memory Management support */
+void FTN_STDCALL FTN_SET_DEFAULT_ALLOCATOR(const omp_allocator_t *allocator) {
+#ifndef KMP_STUB
+  __kmpc_set_default_allocator(__kmp_entry_gtid(), allocator);
+#endif
+}
+const omp_allocator_t *FTN_STDCALL FTN_GET_DEFAULT_ALLOCATOR(void) {
+#ifdef KMP_STUB
+  return NULL;
+#else
+  return __kmpc_get_default_allocator(__kmp_entry_gtid());
 #endif
+}
+void *FTN_STDCALL FTN_ALLOC(size_t size, const omp_allocator_t *allocator) {
+#ifdef KMP_STUB
+  return malloc(size);
+#else
+  return __kmpc_alloc(__kmp_entry_gtid(), size, allocator);
+#endif
+}
+void FTN_STDCALL FTN_FREE(void *ptr, const omp_allocator_t *allocator) {
+#ifdef KMP_STUB
+  free(ptr);
+#else
+  __kmpc_free(__kmp_entry_gtid(), ptr, allocator);
+#endif
+}
+#endif /* OMP_50_ENABLED */
 
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_THREAD_NUM)(void) {
 #ifdef KMP_STUB
   return 0;
 #else
   int gtid;
 
 #if KMP_OS_DARWIN || KMP_OS_FREEBSD || KMP_OS_NETBSD
void *FTN_STDCALL FTN_CALLOC(size_t KMP_DEREF nelem, size_t KMP_DEREF elsize) {
   return kmpc_calloc(KMP_DEREF nelem, KMP_DEREF elsize);
 }
 
 void *FTN_STDCALL FTN_REALLOC(void *KMP_DEREF ptr, size_t KMP_DEREF size) {
   // kmpc_realloc initializes the library if needed
   return kmpc_realloc(KMP_DEREF ptr, KMP_DEREF size);
 }
 
-void FTN_STDCALL FTN_FREE(void *KMP_DEREF ptr) {
+void FTN_STDCALL FTN_KFREE(void *KMP_DEREF ptr) {
   // does nothing if the library is not initialized
   kmpc_free(KMP_DEREF ptr);
 }
 
 void FTN_STDCALL FTN_SET_WARNINGS_ON(void) {
 #ifndef KMP_STUB
   __kmp_generate_warnings = kmp_warnings_explicit;
 #endif

openmp/trunk/runtime/src/kmp_ftn_os.h

 #define FTN_SET_AFFINITY_MASK_PROC kmp_set_affinity_mask_proc
 #define FTN_UNSET_AFFINITY_MASK_PROC kmp_unset_affinity_mask_proc
 #define FTN_GET_AFFINITY_MASK_PROC kmp_get_affinity_mask_proc
 
 #define FTN_MALLOC kmp_malloc
 #define FTN_ALIGNED_MALLOC kmp_aligned_malloc
 #define FTN_CALLOC kmp_calloc
 #define FTN_REALLOC kmp_realloc
-#define FTN_FREE kmp_free
+#define FTN_KFREE kmp_free
 
 #define FTN_GET_NUM_KNOWN_THREADS kmp_get_num_known_threads
 
 #define FTN_SET_NUM_THREADS omp_set_num_threads
 #define FTN_GET_NUM_THREADS omp_get_num_threads
 #define FTN_GET_MAX_THREADS omp_get_max_threads
 #define FTN_GET_THREAD_NUM omp_get_thread_num
 #define FTN_GET_NUM_PROCS omp_get_num_procs

 #define FTN_TARGET_MEMCPY_RECT omp_target_memcpy_rect
 #define FTN_TARGET_ASSOCIATE_PTR omp_target_associate_ptr
 #define FTN_TARGET_DISASSOCIATE_PTR omp_target_disassociate_ptr
 #endif
 #endif
 
 #if OMP_50_ENABLED
 #define FTN_CONTROL_TOOL omp_control_tool
+#define FTN_SET_DEFAULT_ALLOCATOR omp_set_default_allocator
+#define FTN_GET_DEFAULT_ALLOCATOR omp_get_default_allocator
+#define FTN_ALLOC omp_alloc
+#define FTN_FREE omp_free
 #endif
 
 #endif /* KMP_FTN_PLAIN */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_APPEND
 

 #define FTN_SET_AFFINITY_MASK_PROC kmp_set_affinity_mask_proc_
 #define FTN_UNSET_AFFINITY_MASK_PROC kmp_unset_affinity_mask_proc_
 #define FTN_GET_AFFINITY_MASK_PROC kmp_get_affinity_mask_proc_
 
 #define FTN_MALLOC kmp_malloc_
 #define FTN_ALIGNED_MALLOC kmp_aligned_malloc_
 #define FTN_CALLOC kmp_calloc_
 #define FTN_REALLOC kmp_realloc_
-#define FTN_FREE kmp_free_
+#define FTN_KFREE kmp_free_
 
 #define FTN_GET_NUM_KNOWN_THREADS kmp_get_num_known_threads_
 
 #define FTN_SET_NUM_THREADS omp_set_num_threads_
 #define FTN_GET_NUM_THREADS omp_get_num_threads_
 #define FTN_GET_MAX_THREADS omp_get_max_threads_
 #define FTN_GET_THREAD_NUM omp_get_thread_num_
 #define FTN_GET_NUM_PROCS omp_get_num_procs_

 #define FTN_TARGET_MEMCPY omp_target_memcpy_
 #define FTN_TARGET_MEMCPY_RECT omp_target_memcpy_rect_
 #define FTN_TARGET_ASSOCIATE_PTR omp_target_associate_ptr_
 #define FTN_TARGET_DISASSOCIATE_PTR omp_target_disassociate_ptr_
 #endif
 #endif
 
 #if OMP_50_ENABLED
-#define FTN_CONTROL_TOOL OMP_CONTROL_TOOL
+#define FTN_CONTROL_TOOL omp_control_tool_
+#define FTN_SET_DEFAULT_ALLOCATOR omp_set_default_allocator_
+#define FTN_GET_DEFAULT_ALLOCATOR omp_get_default_allocator_
+#define FTN_ALLOC omp_alloc_
+#define FTN_FREE omp_free_
 #endif
 
 #endif /* KMP_FTN_APPEND */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UPPER
 

 #define FTN_SET_AFFINITY_MASK_PROC KMP_SET_AFFINITY_MASK_PROC
 #define FTN_UNSET_AFFINITY_MASK_PROC KMP_UNSET_AFFINITY_MASK_PROC
 #define FTN_GET_AFFINITY_MASK_PROC KMP_GET_AFFINITY_MASK_PROC
 
 #define FTN_MALLOC KMP_MALLOC
 #define FTN_ALIGNED_MALLOC KMP_ALIGNED_MALLOC
 #define FTN_CALLOC KMP_CALLOC
 #define FTN_REALLOC KMP_REALLOC
-#define FTN_FREE KMP_FREE
+#define FTN_KFREE KMP_FREE
 
 #define FTN_GET_NUM_KNOWN_THREADS KMP_GET_NUM_KNOWN_THREADS
 
 #define FTN_SET_NUM_THREADS OMP_SET_NUM_THREADS
 #define FTN_GET_NUM_THREADS OMP_GET_NUM_THREADS
 #define FTN_GET_MAX_THREADS OMP_GET_MAX_THREADS
 #define FTN_GET_THREAD_NUM OMP_GET_THREAD_NUM
 #define FTN_GET_NUM_PROCS OMP_GET_NUM_PROCS

 #define FTN_TARGET_MEMCPY_RECT OMP_TARGET_MEMCPY_RECT
 #define FTN_TARGET_ASSOCIATE_PTR OMP_TARGET_ASSOCIATE_PTR
 #define FTN_TARGET_DISASSOCIATE_PTR OMP_TARGET_DISASSOCIATE_PTR
 #endif
 #endif
 
 #if OMP_50_ENABLED
 #define FTN_CONTROL_TOOL OMP_CONTROL_TOOL
+#define FTN_SET_DEFAULT_ALLOCATOR OMP_SET_DEFAULT_ALLOCATOR
+#define FTN_GET_DEFAULT_ALLOCATOR OMP_GET_DEFAULT_ALLOCATOR
+#define FTN_ALLOC OMP_ALLOC
+#define FTN_FREE OMP_FREE
 #endif
 
 #endif /* KMP_FTN_UPPER */
 
 /* ------------------------------------------------------------------------ */
 
 #if KMP_FTN_ENTRIES == KMP_FTN_UAPPEND
 

 #define FTN_SET_AFFINITY_MASK_PROC KMP_SET_AFFINITY_MASK_PROC_
 #define FTN_UNSET_AFFINITY_MASK_PROC KMP_UNSET_AFFINITY_MASK_PROC_
 #define FTN_GET_AFFINITY_MASK_PROC KMP_GET_AFFINITY_MASK_PROC_
 
 #define FTN_MALLOC KMP_MALLOC_
 #define FTN_ALIGNED_MALLOC KMP_ALIGNED_MALLOC_
 #define FTN_CALLOC KMP_CALLOC_
 #define FTN_REALLOC KMP_REALLOC_
-#define FTN_FREE KMP_FREE_
+#define FTN_KFREE KMP_FREE_
 
 #define FTN_GET_NUM_KNOWN_THREADS KMP_GET_NUM_KNOWN_THREADS_
 
 #define FTN_SET_NUM_THREADS OMP_SET_NUM_THREADS_
 #define FTN_GET_NUM_THREADS OMP_GET_NUM_THREADS_
 #define FTN_GET_MAX_THREADS OMP_GET_MAX_THREADS_
 #define FTN_GET_THREAD_NUM OMP_GET_THREAD_NUM_
 #define FTN_GET_NUM_PROCS OMP_GET_NUM_PROCS_

 #define FTN_TARGET_MEMCPY_RECT OMP_TARGET_MEMCPY_RECT_
 #define FTN_TARGET_ASSOCIATE_PTR OMP_TARGET_ASSOCIATE_PTR_
 #define FTN_TARGET_DISASSOCIATE_PTR OMP_TARGET_DISASSOCIATE_PTR_
 #endif
 #endif
 
 #if OMP_50_ENABLED
 #define FTN_CONTROL_TOOL OMP_CONTROL_TOOL_
+#define FTN_SET_DEFAULT_ALLOCATOR OMP_SET_DEFAULT_ALLOCATOR_
+#define FTN_GET_DEFAULT_ALLOCATOR OMP_GET_DEFAULT_ALLOCATOR_
+#define FTN_ALLOC OMP_ALLOC_
+#define FTN_FREE OMP_FREE_
 #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_global.cpp

 #endif
 
 kmp_tasking_mode_t __kmp_tasking_mode = tskm_task_teams;
 #if OMP_45_ENABLED
 kmp_int32 __kmp_max_task_priority = 0;
 kmp_uint64 __kmp_taskloop_min_tasks = 0;
 #endif
 
+#if OMP_50_ENABLED
+int __kmp_memkind_available = 0;
+int __kmp_hbw_mem_available = 0;
+const omp_allocator_t *OMP_NULL_ALLOCATOR = NULL;
+const omp_allocator_t *omp_default_mem_alloc = (const omp_allocator_t *)1;
+const omp_allocator_t *omp_large_cap_mem_alloc = (const omp_allocator_t *)2;
+const omp_allocator_t *omp_const_mem_alloc = (const omp_allocator_t *)3;
+const omp_allocator_t *omp_high_bw_mem_alloc = (const omp_allocator_t *)4;
+const omp_allocator_t *omp_low_lat_mem_alloc = (const omp_allocator_t *)5;
+const omp_allocator_t *omp_cgroup_mem_alloc = (const omp_allocator_t *)6;
+const omp_allocator_t *omp_pteam_mem_alloc = (const omp_allocator_t *)7;
+const omp_allocator_t *omp_thread_mem_alloc = (const omp_allocator_t *)8;
+void *const *__kmp_def_allocator = omp_default_mem_alloc;
+#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);
 
 int __kmp_task_stealing_constraint = 1; /* Constrain task stealing by default */

openmp/trunk/runtime/src/kmp_runtime.cpp

__kmp_print_storage_map_gtid(-1, &team->t.t_disp_buffer[0],
                                sizeof(dispatch_shared_info_t) * num_disp_buff,
                                "%s_%d.t_disp_buffer", header, team_id);
 
   __kmp_print_storage_map_gtid(-1, &team->t.t_taskq, &team->t.t_copypriv_data,
                                sizeof(kmp_taskq_t), "%s_%d.t_taskq", header,
                                team_id);
 }
 
-static void __kmp_init_allocator() {}
-static void __kmp_fini_allocator() {}
+static void __kmp_init_allocator() {
+#if OMP_50_ENABLED
+  __kmp_init_memkind();
+#endif
+}
+static void __kmp_fini_allocator() {
+#if OMP_50_ENABLED
+  __kmp_fini_memkind();
+#endif
+}
 
 /* ------------------------------------------------------------------------ */
 
 #ifdef KMP_DYNAMIC_LIB
 #if KMP_OS_WINDOWS
 
 static void __kmp_reset_lock(kmp_bootstrap_lock_t *lck) {
   // TODO: Change to __kmp_break_bootstrap_lock().
#endif
 
     /* set thread cache values */
     this_thr->th.th_team_nproc = 1;
     this_thr->th.th_team_master = this_thr;
     this_thr->th.th_team_serialized = 1;
 
     serial_team->t.t_level = serial_team->t.t_parent->t.t_level + 1;
     serial_team->t.t_active_level = serial_team->t.t_parent->t.t_active_level;
+#if OMP_50_ENABLED
+    serial_team->t.t_def_allocator = this_thr->th.th_def_allocator; // save
+#endif
 
     propagateFPControl(serial_team);
 
     /* check if we need to allocate dispatch buffers stack */
     KMP_DEBUG_ASSERT(serial_team->t.t_dispatch);
     if (!serial_team->t.t_dispatch->th_disp_buffer) {
       serial_team->t.t_dispatch->th_disp_buffer =
           (dispatch_private_info_t *)__kmp_allocate(
#endif
         return TRUE;
       }
 
       parent_team->t.t_pkfn = microtask;
       parent_team->t.t_invoke = invoker;
       KMP_ATOMIC_INC(&root->r.r_in_parallel);
       parent_team->t.t_active_level++;
       parent_team->t.t_level++;
+#if OMP_50_ENABLED
+      parent_team->t.t_def_allocator = master_th->th.th_def_allocator; // save
+#endif
 
       /* Change number of threads in the team if requested */
       if (master_set_numthreads) { // The parallel has num_threads clause
         if (master_set_numthreads < master_th->th.th_teams_size.nth) {
           // AC: only can reduce number of threads dynamically, can't increase
           kmp_info_t **other_threads = parent_team->t.t_threads;
           parent_team->t.t_nproc = master_set_numthreads;
           for (i = 0; i < master_set_numthreads; ++i) {

 #endif /* OMP_40_ENABLED */
     kmp_r_sched_t new_sched = get__sched_2(parent_team, master_tid);
     // set master's schedule as new run-time schedule
     KMP_CHECK_UPDATE(team->t.t_sched.sched, new_sched.sched);
 
 #if OMP_40_ENABLED
     KMP_CHECK_UPDATE(team->t.t_cancel_request, cancel_noreq);
 #endif
+#if OMP_50_ENABLED
+    KMP_CHECK_UPDATE(team->t.t_def_allocator, master_th->th.th_def_allocator);
+#endif
 
     // Update the floating point rounding in the team if required.
     propagateFPControl(team);
 
     if (__kmp_tasking_mode != tskm_immediate_exec) {
       // Set master's task team to team's task team. Unless this is hot team, it
       // should be NULL.
       KMP_DEBUG_ASSERT(master_th->th.th_task_team ==
KF_TRACE(10, ("__kmp_join_call1: T#%d, this_thread=%p team=%p\n", 0,
                 master_th, team));
   __kmp_pop_current_task_from_thread(master_th);
 
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
   // Restore master thread's partition.
   master_th->th.th_first_place = team->t.t_first_place;
   master_th->th.th_last_place = team->t.t_last_place;
 #endif /* OMP_40_ENABLED */
+#if OMP_50_ENABLED
+  master_th->th.th_def_allocator = team->t.t_def_allocator;
+#endif
 
   updateHWFPControl(team);
 
   if (root->r.r_active != master_active)
     root->r.r_active = master_active;
 
   __kmp_free_team(root, team USE_NESTED_HOT_ARG(
                             master_th)); // this will free worker threads

 
 #if KMP_AFFINITY_SUPPORTED
 #if OMP_40_ENABLED
   root_thread->th.th_current_place = KMP_PLACE_UNDEFINED;
   root_thread->th.th_new_place = KMP_PLACE_UNDEFINED;
   root_thread->th.th_first_place = KMP_PLACE_UNDEFINED;
   root_thread->th.th_last_place = KMP_PLACE_UNDEFINED;
 #endif
-
   if (TCR_4(__kmp_init_middle)) {
     __kmp_affinity_set_init_mask(gtid, TRUE);
   }
 #endif /* KMP_AFFINITY_SUPPORTED */
+#if OMP_50_ENABLED
+  root_thread->th.th_def_allocator = __kmp_def_allocator;
+#endif
 
   __kmp_root_counter++;
 
 #if OMPT_SUPPORT
   if (!initial_thread && ompt_enabled.enabled) {
 
     ompt_thread_t *root_thread = ompt_get_thread();
 

 #endif
 
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
   new_thr->th.th_current_place = KMP_PLACE_UNDEFINED;
   new_thr->th.th_new_place = KMP_PLACE_UNDEFINED;
   new_thr->th.th_first_place = KMP_PLACE_UNDEFINED;
   new_thr->th.th_last_place = KMP_PLACE_UNDEFINED;
 #endif
+#if OMP_50_ENABLED
+  new_thr->th.th_def_allocator = __kmp_def_allocator;
+#endif
 
   TCW_4(new_thr->th.th_in_pool, FALSE);
   new_thr->th.th_active_in_pool = FALSE;
   TCW_4(new_thr->th.th_active, TRUE);
 
   /* adjust the global counters */
   __kmp_all_nth++;
   __kmp_nth++;

openmp/trunk/runtime/src/kmp_settings.cpp

for (i = 0; i < nelem; i++) {
       }
     }
     __kmp_str_buf_print(buffer, "'\n");
   }
 }
 
 #endif /* OMP_40_ENABLED */
 
+#if OMP_50_ENABLED
+
+// OMP_ALLOCATOR sets default allocator
+static void __kmp_stg_parse_allocator(char const *name, char const *value,
+                                      void *data) {
+  /*
+    The value can be any predefined allocator:
+    omp_default_mem_alloc = 1;
+    omp_large_cap_mem_alloc = 2;
+    omp_const_mem_alloc = 3;
+    omp_high_bw_mem_alloc = 4;
+    omp_low_lat_mem_alloc = 5;
+    omp_cgroup_mem_alloc = 6;
+    omp_pteam_mem_alloc = 7;
+    omp_thread_mem_alloc = 8;
+    Acceptable value is either a digit or a string.
+  */
+  const char *buf = value;
+  const char *next;
+  int num;
+  SKIP_WS(buf);
+  if ((*buf > '0') && (*buf < '9')) {
+    next = buf;
+    SKIP_DIGITS(next);
+    num = __kmp_str_to_int(buf, *next);
+    KMP_ASSERT(num > 0);
+    switch (num) {
+    case 4:
+      if (__kmp_hbw_mem_available) {
+        __kmp_def_allocator = omp_high_bw_mem_alloc;
+      } else {
+        __kmp_msg(kmp_ms_warning,
+                  KMP_MSG(OmpNoAllocator, "omp_high_bw_mem_alloc"),
+                  __kmp_msg_null);
+        __kmp_def_allocator = omp_default_mem_alloc;
+      }
+      break;
+    case 1:
+      __kmp_def_allocator = omp_default_mem_alloc;
+      break;
+    case 2:
+      __kmp_msg(kmp_ms_warning,
+                KMP_MSG(OmpNoAllocator, "omp_large_cap_mem_alloc"),
+                __kmp_msg_null);
+      __kmp_def_allocator = omp_default_mem_alloc;
+      break;
+    case 3:
+      __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_const_mem_alloc"),
+                __kmp_msg_null);
+      __kmp_def_allocator = omp_default_mem_alloc;
+      break;
+    case 5:
+      __kmp_msg(kmp_ms_warning,
+                KMP_MSG(OmpNoAllocator, "omp_low_lat_mem_alloc"),
+                __kmp_msg_null);
+      __kmp_def_allocator = omp_default_mem_alloc;
+      break;
+    case 6:
+      __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_cgroup_mem_alloc"),
+                __kmp_msg_null);
+      __kmp_def_allocator = omp_default_mem_alloc;
+      break;
+    case 7:
+      __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_pteam_mem_alloc"),
+                __kmp_msg_null);
+      __kmp_def_allocator = omp_default_mem_alloc;
+      break;
+    case 8:
+      __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_thread_mem_alloc"),
+                __kmp_msg_null);
+      __kmp_def_allocator = omp_default_mem_alloc;
+      break;
+    }
+    return;
+  }
+  next = buf;
+  if (__kmp_match_str("omp_high_bw_mem_alloc", buf, &next)) {
+    if (__kmp_hbw_mem_available) {
+      __kmp_def_allocator = omp_high_bw_mem_alloc;
+    } else {
+      __kmp_msg(kmp_ms_warning,
+                KMP_MSG(OmpNoAllocator, "omp_high_bw_mem_alloc"),
+                __kmp_msg_null);
+      __kmp_def_allocator = omp_default_mem_alloc;
+    }
+  } else if (__kmp_match_str("omp_default_mem_alloc", buf, &next)) {
+    __kmp_def_allocator = omp_default_mem_alloc;
+  } else if (__kmp_match_str("omp_large_cap_mem_alloc", buf, &next)) {
+    __kmp_msg(kmp_ms_warning,
+              KMP_MSG(OmpNoAllocator, "omp_large_cap_mem_alloc"),
+              __kmp_msg_null);
+    __kmp_def_allocator = omp_default_mem_alloc;
+  } else if (__kmp_match_str("omp_const_mem_alloc", buf, &next)) {
+    __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_const_mem_alloc"),
+              __kmp_msg_null);
+    __kmp_def_allocator = omp_default_mem_alloc;
+  } else if (__kmp_match_str("omp_low_lat_mem_alloc", buf, &next)) {
+    __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_low_lat_mem_alloc"),
+              __kmp_msg_null);
+    __kmp_def_allocator = omp_default_mem_alloc;
+  } else if (__kmp_match_str("omp_cgroup_mem_alloc", buf, &next)) {
+    __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_cgroup_mem_alloc"),
+              __kmp_msg_null);
+    __kmp_def_allocator = omp_default_mem_alloc;
+  } else if (__kmp_match_str("omp_pteam_mem_alloc", buf, &next)) {
+    __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_pteam_mem_alloc"),
+              __kmp_msg_null);
+    __kmp_def_allocator = omp_default_mem_alloc;
+  } else if (__kmp_match_str("omp_thread_mem_alloc", buf, &next)) {
+    __kmp_msg(kmp_ms_warning, KMP_MSG(OmpNoAllocator, "omp_thread_mem_alloc"),
+              __kmp_msg_null);
+    __kmp_def_allocator = omp_default_mem_alloc;
+  }
+  buf = next;
+  SKIP_WS(buf);
+  if (*buf != '\0') {
+    KMP_WARNING(ParseExtraCharsWarn, name, buf);
+  }
+}
+
+static void __kmp_stg_print_allocator(kmp_str_buf_t *buffer, char const *name,
+                                      void *data) {
+  if (__kmp_def_allocator == omp_default_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_default_mem_alloc");
+  } else if (__kmp_def_allocator == omp_high_bw_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_high_bw_mem_alloc");
+  } else if (__kmp_def_allocator == omp_large_cap_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_large_cap_mem_alloc");
+  } else if (__kmp_def_allocator == omp_const_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_const_mem_alloc");
+  } else if (__kmp_def_allocator == omp_low_lat_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_low_lat_mem_alloc");
+  } else if (__kmp_def_allocator == omp_cgroup_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_cgroup_mem_alloc");
+  } else if (__kmp_def_allocator == omp_pteam_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_pteam_mem_alloc");
+  } else if (__kmp_def_allocator == omp_thread_mem_alloc) {
+    __kmp_stg_print_str(buffer, name, "omp_thread_mem_alloc");
+  }
+}
+
+#endif /* OMP_50_ENABLED */
+
 // -----------------------------------------------------------------------------
 // OMP_DYNAMIC
 
 static void __kmp_stg_parse_omp_dynamic(char const *name, char const *value,
                                         void *data) {
   __kmp_stg_parse_bool(name, value, &(__kmp_global.g.g_dynamic));
 } // __kmp_stg_parse_omp_dynamic
 

 #if OMP_40_ENABLED
     {"OMP_PROC_BIND", __kmp_stg_parse_proc_bind, __kmp_stg_print_proc_bind,
      NULL, 0, 0},
     {"OMP_PLACES", __kmp_stg_parse_places, __kmp_stg_print_places, NULL, 0, 0},
 #else
     {"OMP_PROC_BIND", __kmp_stg_parse_proc_bind, NULL, /* no print */ NULL, 0,
      0},
 #endif /* OMP_40_ENABLED */
-
     {"KMP_TOPOLOGY_METHOD", __kmp_stg_parse_topology_method,
      __kmp_stg_print_topology_method, NULL, 0, 0},
 
 #else
 
 // KMP_AFFINITY is not supported on OS X*, nor is OMP_PLACES.
 // OMP_PROC_BIND and proc-bind-var are supported, however.
 #if OMP_40_ENABLED

 
 #if OMP_40_ENABLED
     {"OMP_DISPLAY_ENV", __kmp_stg_parse_omp_display_env,
      __kmp_stg_print_omp_display_env, NULL, 0, 0},
     {"OMP_CANCELLATION", __kmp_stg_parse_omp_cancellation,
      __kmp_stg_print_omp_cancellation, NULL, 0, 0},
 #endif
 
+#if OMP_50_ENABLED
+    {"OMP_ALLOCATOR", __kmp_stg_parse_allocator, __kmp_stg_print_allocator,
+     NULL, 0, 0},
+#endif
+
 #if OMP_50_ENABLED && OMPT_SUPPORT
     {"OMP_TOOL_LIBRARIES", __kmp_stg_parse_omp_tool_libraries,
      __kmp_stg_print_omp_tool_libraries, NULL, 0, 0},
 #endif
 
     {"", NULL, NULL, NULL, 0, 0}}; // settings
 
 static int const __kmp_stg_count =

openmp/trunk/runtime/src/kmp_stub.cpp

 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 
+#define __KMP_IMP
 #include "omp.h" // omp_* declarations, must be included before "kmp.h"
 #include "kmp.h" // KMP_DEFAULT_STKSIZE
 #include "kmp_stub.h"
 
 #if KMP_OS_WINDOWS
 #include <windows.h>
 #else
 #include <sys/time.h>
#if KMP_OS_WINDOWS
   }
 #else
   // TODO: gettimeofday() returns in microseconds, but what the precision?
   wtick = 1.0E-06;
 #endif
   return wtick;
 } // __kmps_get_wtick
 
+#if OMP_50_ENABLED
+/* OpenMP 5.0 Memory Management */
+const omp_allocator_t *OMP_NULL_ALLOCATOR = NULL;
+const omp_allocator_t *omp_default_mem_alloc = (const omp_allocator_t *)1;
+const omp_allocator_t *omp_large_cap_mem_alloc = (const omp_allocator_t *)2;
+const omp_allocator_t *omp_const_mem_alloc = (const omp_allocator_t *)3;
+const omp_allocator_t *omp_high_bw_mem_alloc = (const omp_allocator_t *)4;
+const omp_allocator_t *omp_low_lat_mem_alloc = (const omp_allocator_t *)5;
+const omp_allocator_t *omp_cgroup_mem_alloc = (const omp_allocator_t *)6;
+const omp_allocator_t *omp_pteam_mem_alloc = (const omp_allocator_t *)7;
+const omp_allocator_t *omp_thread_mem_alloc = (const omp_allocator_t *)8;
+#endif /* OMP_50_ENABLED */
+
 // end of file //

openmp/trunk/runtime/test/api/omp_alloc.c

+// RUN: %libomp-compile-and-run
+#include <stdio.h>
+#include <stdint.h>
+#include <omp.h>
+#include "omp_testsuite.h"
+
+#define ARRAY_SIZE 10000
+
+int test_omp_alloc() {
+  int err;
+  int i, j;
+  int *shared_array;
+  const omp_allocator_t *allocator;
+  const omp_allocator_t *test_allocator;
+  // Currently, only default memory allocator is implemented
+  const omp_allocator_t *allocators[] = {
+      omp_default_mem_alloc,
+  };
+
+  err = 0;
+  for (i = 0; i < sizeof(allocators) / sizeof(allocators[0]); ++i) {
+    allocator = allocators[i];
+    printf("Using %p allocator\n", test_allocator);
+    omp_set_default_allocator(allocator);
+    test_allocator = omp_get_default_allocator();
+    if (test_allocator != allocator) {
+      printf("error: omp_set|get_default_allocator() not working\n");
+      return 0;
+    }
+    shared_array = (int *)omp_alloc(sizeof(int) * ARRAY_SIZE, test_allocator);
+    if (shared_array == NULL) {
+      printf("error: shared_array is NULL\n");
+      return 0;
+    }
+    for (j = 0; j < ARRAY_SIZE; ++j) {
+      shared_array[j] = j;
+    }
+    #pragma omp parallel shared(shared_array)
+    {
+      int i;
+      int tid = omp_get_thread_num();
+      int *private_array =
+          (int *)omp_alloc(sizeof(int) * ARRAY_SIZE, omp_default_mem_alloc);
+      if (private_array == NULL) {
+        printf("error: thread %d private_array is NULL\n", tid);
+        #pragma omp atomic
+        err++;
+      }
+      for (i = 0; i < ARRAY_SIZE; ++i) {
+        private_array[i] = shared_array[i] + tid;
+      }
+      for (i = 0; i < ARRAY_SIZE; ++i) {
+        if (private_array[i] != i + tid) {
+          printf("error: thread %d element %d is %d instead of %d\n", tid, i,
+                 private_array[i], i + tid);
+          #pragma omp atomic
+          err++;
+        }
+      }
+      omp_free(private_array, omp_default_mem_alloc);
+    } /* end of parallel */
+    omp_free(shared_array, test_allocator);
+  }
+
+  return !err;
+}
+
+int main() {
+  int i;
+  int num_failed = 0;
+
+  for (i = 0; i < REPETITIONS; i++) {
+    if (!test_omp_alloc()) {
+      num_failed++;
+    }
+  }
+  return num_failed;
+}

openmp/trunk/runtime/tools/generate-def.pl

 sub process(\%) {
 
     my ( $entries ) = @_;
 
     foreach my $entry ( keys( %$entries ) ) {
         if ( not $entries->{ $entry }->{ obsolete } ) {
             my $ordinal = $entries->{ $entry }->{ ordinal };
             if ( $entry =~ m{\A[ok]mp_} ) {
-                if ( not defined( $ordinal ) or $ordinal eq "DATA" ) {
+                if ( not defined( $ordinal ) ) {
                     runtime_error(
                         "Bad entry \"$entry\": ordinal number is not specified."
                     );
                 }; # if
+                if ( $ordinal ne "DATA" ) {
                     $entries->{ uc( $entry ) } = { ordinal => 1000 + $ordinal };
+                }
             }; # if
         }; # if
     }; # foreach
 
     return %$entries;
 
 }; # sub process