ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

- The ptmalloc2 memory manager component is now by default built as

Просмотр исходного кода 
a standalone library named libopenmpi-malloc.  Users wanting to
  use leave_pinned with ptmalloc2 will now need to link the library
  into their application explicitly.  All other users will use the
  libc-provided allocator instead of Open MPI's ptmalloc2.  This change
  may be overriden with the configure option enable-ptmalloc2-internal
- The leave_pinned options will now default to using mallopt on
  Linux in the cases where ptmalloc2 was not linked in.  mallopt
  will also only be available if munmap can be intercepted (the
  default whenever Open MPI is not compiled with --without-memory-
  manager.
- Open MPI will now complain and refuse to use leave_pinned if
  no memory intercept / mallopt option is available.

This commit was SVN r18654.
Этот коммит содержится в:
Brian Barrett 2008-06-13 22:32:49 +00:00
родитель 44cd373a87
Коммит 79ad6d983e
23 изменённых файлов: 409 добавлений и 405 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

16
NEWS
Просмотреть файл

@ -79,6 +79,22 @@ Trunk (not on release branches yet)
- Added more stringent MPI API parameter checking to help user-level
debugging.
--> Expected: 1.3
- The ptmalloc2 memory manager component is now by default built as
a standalone library named libopenmpi-malloc. Users wanting to
use leave_pinned with ptmalloc2 will now need to link the library
into their application explicitly. All other users will use the
libc-provided allocator instead of Open MPI's ptmalloc2. This change
may be overriden with the configure option enable-ptmalloc2-internal
--> Expected: 1.3
- The leave_pinned options will now default to using mallopt on
Linux in the cases where ptmalloc2 was not linked in. mallopt
will also only be available if munmap can be intercepted (the
default whenever Open MPI is not compiled with --without-memory-
manager.
--> Expected: 1.3
- Open MPI will now complain and refuse to use leave_pinned if
no memory intercept / mallopt option is available.
--> Expected: 1.3r
1.2.7 (not released yet)

11
ompi/mca/mpool/base/base.h
Просмотреть файл

@ -29,6 +29,12 @@
#include "ompi/mca/mpool/mpool.h"
#include "opal/threads/mutex.h"
#if defined(HAVE_MALLOPT) && defined(M_TRIM_THRESHOLD) && defined(M_MMAP_MAX)
#define OMPI_MPOOL_BASE_HAVE_LINUX_MALLOPT 1
#else
#define OMPI_MPOOL_BASE_HAVE_LINUX_MALLOPT 0
#endif
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif
@ -87,6 +93,11 @@ OMPI_DECLSPEC extern opal_list_t mca_mpool_base_components;
extern opal_list_t mca_mpool_base_modules;
OMPI_DECLSPEC extern uint32_t mca_mpool_base_page_size;
OMPI_DECLSPEC extern uint32_t mca_mpool_base_page_size_log;
/* only used within base -- no need to DECLSPEC */
extern int mca_mpool_base_use_mem_hooks;
extern int mca_mpool_base_mallopt_disable_free;
#if defined(c_plusplus) || defined(__cplusplus)
}

5
ompi/mca/mpool/base/help-mpool-base.txt
Просмотреть файл

@ -30,3 +30,8 @@ PID: %d
%d additional leak%s recorded but %s not displayed here. Set the MCA
parameter mpi_show_mpi_alloc_mem_leaks to a larger number to see that
many leaks, or set it to a negative number to see all leaks.
[leave pinned failed]
Process %s on host %s attempted to use the leave pinned
feature, but no memory registration hooks were found. To solve this
problem, either link in the libopenmpi-malloc library or (on Linux)
do not set the MCA parameter base_disable_mallopt.

2
ompi/mca/mpool/base/mpool_base_alloc.c
Просмотреть файл

@ -29,8 +29,6 @@
#include "opal/threads/mutex.h"
#include "mpool_base_mem_cb.h"
extern int mca_mpool_base_use_mem_hooks;
/**
* Memory Pool Registration
*/

1
ompi/mca/mpool/base/mpool_base_close.c
Просмотреть файл

@ -28,7 +28,6 @@
#include "ompi/mca/mpool/base/base.h"
#include "mpool_base_mem_cb.h"
extern int mca_mpool_base_use_mem_hooks;
extern opal_pointer_array_t mca_mpool_base_mem_cb_array;
int mca_mpool_base_close(void)

51
ompi/mca/mpool/base/mpool_base_lookup.c
Просмотреть файл

@ -25,22 +25,20 @@
#include <string.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
extern int mca_mpool_base_disable_sbrk;
#endif
#if defined(HAVE_MALLOPT) && defined(M_TRIM_THRESHOLD) && defined(M_MMAP_MAX)
#define MPOOL_BASE_CAN_DISABLE_SBRK 1
#else
#define MPOOL_BASE_CAN_DISABLE_SBRK 0
#endif
#include "opal/mca/mca.h"
#include "opal/mca/base/base.h"
#include "opal/util/output.h"
#include "orte/util/show_help.h"
#include "orte/util/name_fns.h"
#include "orte/util/proc_info.h"
#include "orte/runtime/orte_globals.h"
#include "ompi/mca/mpool/mpool.h"
#include "ompi/mca/mpool/base/base.h"
#include "mpool_base_mem_cb.h"
extern int mca_mpool_base_use_mem_hooks;
extern opal_pointer_array_t mca_mpool_base_mem_cb_array;
mca_mpool_base_component_t* mca_mpool_base_component_lookup(const char* name)
@ -98,20 +96,33 @@ mca_mpool_base_module_t* mca_mpool_base_module_create(
sm->user_data = user_data;
sm->mpool_resources = resources;
opal_list_append(&mca_mpool_base_modules, (opal_list_item_t*) sm);
/* on the very first creation of a module we init the memory callback*/
if(opal_list_get_size(&mca_mpool_base_modules) == 1) {
if(mca_mpool_base_use_mem_hooks &&
0 != (OPAL_MEMORY_FREE_SUPPORT & opal_mem_hooks_support_level())) {
opal_mem_hooks_register_release(mca_mpool_base_mem_cb, NULL);
OBJ_CONSTRUCT(&mca_mpool_base_mem_cb_array, opal_pointer_array_t);
/* on the very first creation of a module we init the memory
callback and (if needed) disable free() returning memory to the
OS. Note that even when we disable free() with mallopt, we
still need to register a callback to handle the case of the
user calling mmap/munmap on his own. */
if (opal_list_get_size(&mca_mpool_base_modules) == 1) {
if (mca_mpool_base_use_mem_hooks) {
if (0 != (OPAL_MEMORY_FREE_SUPPORT & opal_mem_hooks_support_level())) {
opal_mem_hooks_register_release(mca_mpool_base_mem_cb, NULL);
OBJ_CONSTRUCT(&mca_mpool_base_mem_cb_array, opal_pointer_array_t);
} else if (mca_mpool_base_mallopt_disable_free &&
0 != (OPAL_MEMORY_MUNMAP_SUPPORT & opal_mem_hooks_support_level())) {
opal_mem_hooks_register_release(mca_mpool_base_mem_cb, NULL);
OBJ_CONSTRUCT(&mca_mpool_base_mem_cb_array, opal_pointer_array_t);
/* mallopt_disable_free will only be set to 1 if
HAVE_LINUX_MALLOPT, so this is safe */
#if OMPI_MPOOL_BASE_HAVE_LINUX_MALLOPT
mallopt(M_TRIM_THRESHOLD, -1);
mallopt(M_MMAP_MAX, 0);
#endif
} else {
orte_show_help("help-mpool-base.txt", "leave pinned failed",
true, ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
orte_process_info.nodename);
return NULL;
}
}
#if MPOOL_BASE_CAN_DISABLE_SBRK
else if(mca_mpool_base_disable_sbrk) {
mallopt(M_TRIM_THRESHOLD, -1);
mallopt(M_MMAP_MAX, 0);
}
#endif /* MPOOL_BASE_CAN_DISABLE_SBRK */
}
return module;
}

61
ompi/mca/mpool/base/mpool_base_open.c
Просмотреть файл

@ -27,14 +27,10 @@
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#if defined(HAVE_MALLOPT) && defined(M_TRIM_THRESHOLD) && defined(M_MMAP_MAX)
#define MPOOL_BASE_CAN_DISABLE_SBRK 1
#else
#define MPOOL_BASE_CAN_DISABLE_SBRK 0
#endif
#include "opal/mca/mca.h"
#include "opal/mca/base/base.h"
#include "opal/memoryhooks/memory.h"
#include "ompi/runtime/params.h"
#include "ompi/mca/mpool/mpool.h"
#include "ompi/mca/mpool/base/base.h"
@ -52,11 +48,12 @@
* Global variables
*/
int mca_mpool_base_output = -1;
int mca_mpool_base_use_mem_hooks = 0;
#if MPOOL_BASE_CAN_DISABLE_SBRK
int mca_mpool_base_disable_sbrk = 0;
#endif
/* should we attempt to use the available memory hooks */
int mca_mpool_base_use_mem_hooks = 0;
/* should we attempt to use mallopt to disable free() returning memory
to OS? */
int mca_mpool_base_mallopt_disable_free = 0;
uint32_t mca_mpool_base_page_size;
uint32_t mca_mpool_base_page_size_log;
@ -74,9 +71,7 @@ int mca_mpool_base_open(void)
mca_mpool_base_components list */
int use_mem_hooks;
#if MPOOL_BASE_CAN_DISABLE_SBRK
int disable_sbrk;
#endif /* MPOOL_BASE_CAN_DISABLE_SBRK */
int no_mallopt;
if (OMPI_SUCCESS !=
mca_base_components_open("mpool", 0, mca_mpool_base_static_components,
@ -112,36 +107,32 @@ int mca_mpool_base_open(void)
mca_mpool_base_use_mem_hooks = use_mem_hooks || mca_mpool_base_use_mem_hooks;
#if MPOOL_BASE_CAN_DISABLE_SBRK
#if OMPI_MPOOL_BASE_HAVE_LINUX_MALLOPT
mca_base_param_reg_int_name("mpool",
"base_disable_sbrk",
"use mallopt to override calling sbrk (doesn't return memory to OS!)",
"base_disable_mallopt",
"do not use mallopt to disable returning memory to "
"the OS when leave_pinned is active and no memory "
"components are found.",
false,
false,
0,
&mca_mpool_base_disable_sbrk);
mca_base_param_reg_int_name("mpool",
"disable_sbrk",
"(deprecated, use mca_mpool_base_disable_sbrk)",
false,
false,
0,
&disable_sbrk);
mca_mpool_base_disable_sbrk = disable_sbrk || mca_mpool_base_disable_sbrk;
&no_mallopt);
#else
no_mallopt = 1;
#endif
/* force mem hooks if leave_pinned or leave_pinned_pipeline is enabled */
#if MPOOL_BASE_CAN_DISABLE_SBRK
if(0 == mca_mpool_base_use_mem_hooks && 0 == mca_mpool_base_disable_sbrk) {
#else
if(0 == mca_mpool_base_use_mem_hooks ) {
#endif
if (ompi_mpi_leave_pinned || ompi_mpi_leave_pinned_pipeline) {
mca_mpool_base_use_mem_hooks = 1;
}
if (ompi_mpi_leave_pinned || ompi_mpi_leave_pinned_pipeline) {
mca_mpool_base_use_mem_hooks = 1;
}
/* enable mallopt if we're using leave pinned, there is support
for intercepting munmap, and the user didn't tell us not to use
mallopt */
if ((ompi_mpi_leave_pinned || ompi_mpi_leave_pinned_pipeline) &&
(0 != (OPAL_MEMORY_MUNMAP_SUPPORT & opal_mem_hooks_support_level())) &&
0 == no_mallopt) {
mca_mpool_base_mallopt_disable_free = 1;
}
/* get the page size for this architecture*/

11
opal/mca/memory/base/memory_base_open.c
Просмотреть файл

@ -40,7 +40,7 @@
* Globals
*/
opal_list_t opal_memory_base_components_opened;
opal_memory_base_component_1_0_0_t *opal_memory_active_component = NULL;
/*
* Function for finding and opening either all MCA components, or the one
@ -57,6 +57,15 @@ int opal_memory_base_open(void)
return OPAL_ERROR;
}
/* can only be zero or one */
if (opal_list_get_size(&opal_memory_base_components_opened) == 1) {
mca_base_component_list_item_t *item;
item = (mca_base_component_list_item_t*)
opal_list_get_first(&opal_memory_base_components_opened);
opal_memory_active_component = (opal_memory_base_component_1_0_0_t*)
item->cli_component;
}
/* All done */
return OPAL_SUCCESS;
}

25
opal/mca/memory/mallopt/Makefile.am Обычный файл
Просмотреть файл

@ -0,0 +1,25 @@
#
# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
# University Research and Technology
# Corporation. All rights reserved.
# Copyright (c) 2004-2005 The University of Tennessee and The University
# of Tennessee Research Foundation. All rights
# reserved.
# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
# University of Stuttgart. All rights reserved.
# Copyright (c) 2004-2005 The Regents of the University of California.
# All rights reserved.
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#
noinst_LTLIBRARIES = libmca_memory_mallopt.la
# Source code files
libmca_memory_mallopt_la_SOURCES = \
memory_mallopt_component.c
libmca_memory_mallopt_la_LIBADD = \
$(memory_mallopt_LIBS)

80
opal/mca/memory/mallopt/configure.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,80 @@
# -*- shell-script -*-
#
# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
# University Research and Technology
# Corporation. All rights reserved.
# Copyright (c) 2004-2005 The University of Tennessee and The University
# of Tennessee Research Foundation. All rights
# reserved.
# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
# University of Stuttgart. All rights reserved.
# Copyright (c) 2004-2005 The Regents of the University of California.
# All rights reserved.
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#
AC_DEFUN([MCA_memory_mallopt_COMPILE_MODE], [
AC_MSG_CHECKING([for MCA component $2:$3 compile mode])
$4="static"
AC_MSG_RESULT([$$4])
])
# MCA_memory_mallopt_CONFIG(action-if-can-compile,
# [action-if-cant-compile])
# ------------------------------------------------
AC_DEFUN([MCA_memory_mallopt_CONFIG],[
AS_IF([test "$with_memory_manager" = "mallopt"],
[memory_mallopt_happy="yes"
memory_mallopt_should_use=1],
[memory_mallopt_should_use=0
AS_IF([test "$with_memory_manager" = ""],
[memory_mallopt_happy="yes"],
[memory_mallopt_happy="no"])])
AS_IF([test "$memory_mallopt_happy" = "yes"],
[AC_CHECK_HEADER([malloc.h], [], [memory_mallopt_happy="no"])])
AS_IF([test "$memory_mallopt_happy" = "yes"],
[AC_CHECK_FUNCS([mallopt], [], [memory_mallopt_happy="no"])])
AS_IF([test "$memory_mallopt_happy" = "yes"],
[memory_mallopt_munmap=0
AC_CHECK_HEADER([syscall.h],
[AC_CHECK_FUNCS([syscall], [memory_mallopt_munmap=1])])
AC_CHECK_FUNCS([__munmap], [memory_mallopt_munmap=1])
# only allow dlsym (and therefore add -ldl) if we
# really need to
AS_IF([test "$memory_mallopt_munmap" = "0"],
[memory_mallopt_LIBS_SAVE="$LIBS"
AC_CHECK_LIB([dl],
[dlsym],
[memory_mallopt_LIBS="-ldl"
memory_mallopt_munmap=1])
AC_CHECK_FUNCS([dlsym])
LIBS="$memory_mallopt_LIBS_SAVE"])
AS_IF([test "$memory_mallopt_munmap" = "0"],
[memory_mallopt_happy="no"])])
AS_IF([test "$memory_mallopt_happy" = "yes"],
[memory_mallopt_WRAPPER_EXTRA_LIBS="$memory_mallopt_LIBS"])
AS_IF([test "$memory_mallopt_happy" = "no" -a \
"$memory_malloc_hoooks_should_use" = "1"],
[AC_MSG_ERROR([mallopt memory management requested but not available. Aborting.])])
AC_SUBST(memory_mallopt_LIBS)
AS_IF([test "$memory_mallopt_happy" = "yes"],
[memory_base_found=1
$1], [$2])
])

23
opal/mca/memory/mallopt/configure.params Обычный файл
Просмотреть файл

@ -0,0 +1,23 @@
# -*- shell-script -*-
#
# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
# University Research and Technology
# Corporation. All rights reserved.
# Copyright (c) 2004-2005 The University of Tennessee and The University
# of Tennessee Research Foundation. All rights
# reserved.
# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
# University of Stuttgart. All rights reserved.
# Copyright (c) 2004-2005 The Regents of the University of California.
# All rights reserved.
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#
# Specific to this module
PARAM_CONFIG_PRIORITY=0
PARAM_CONFIG_FILES="Makefile"

118
opal/mca/memory/mallopt/memory_mallopt_component.c Обычный файл
Просмотреть файл

@ -0,0 +1,118 @@
/*
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "opal_config.h"
#include <sys/types.h>
#include <stdlib.h>
#include <sys/mman.h>
#if defined(HAVE___MUNMAP)
/* here so we only include others if we absolutely have to */
#elif defined(HAVE_SYSCALL)
#include <syscall.h>
#include <unistd.h>
#endif
#if defined(HAVE_DLSYM)
#ifndef __USE_GNU
#define __USE_GNU
#endif
#include <dlfcn.h>
#endif
#include "opal/mca/memory/memory.h"
#include "opal/memoryhooks/memory_internal.h"
#include "opal/constants.h"
#if defined(HAVE___MUNMAP)
int __munmap(void* addr, size_t len);
#endif
static int opal_memory_malloc_open(void);
const opal_memory_base_component_1_0_0_t mca_memory_mallopt_component = {
/* First, the mca_component_t struct containing meta information
about the component itself */
{
/* Indicate that we are a memory v1.0.0 component (which also
implies a specific MCA version) */
OPAL_MEMORY_BASE_VERSION_1_0_0,
/* Component name and version */
"mallopt",
OPAL_MAJOR_VERSION,
OPAL_MINOR_VERSION,
OPAL_RELEASE_VERSION,
/* Component open and close functions */
opal_memory_malloc_open,
NULL
},
/* Next the MCA v1.0.0 component meta data */
{
/* The component is checkpoint ready */
MCA_BASE_METADATA_PARAM_CHECKPOINT
},
};
static int
opal_memory_malloc_open(void)
{
/* This component is a bit weird, in that it exists only to
capture munmap. Real work happens in mpool_base */
opal_mem_hooks_set_support(OPAL_MEMORY_MUNMAP_SUPPORT);
return OPAL_SUCCESS;
}
/* three ways to call munmap. Prefered is to call __munmap, which
will exist if munmap is a weak symbol. If that doesn't work, try
the syscal, and if that doesn't work, try looking in the dynamic
libc. */
int
munmap(void* addr, size_t len)
{
#if !defined(HAVE___MUNMAP) && \
!(defined(HAVE_SYSCALL) && defined(__NR_munmap)) && defined(HAVE_DLSYM)
static int (*realmunmap)(void*, size_t);
#endif
opal_mem_hooks_release_hook(addr, len, 0);
#if defined(HAVE___MUNMAP)
return __munmap(addr, len);
#elif defined(HAVE_SYSCALL) && defined(__NR_munmap)
return syscall(__NR_munmap, addr, len);
#elif defined(HAVE_DLSYM)
if (NULL == realmunmap) {
union {
int (*munmap_fp)(void*, size_t);
void *munmap_p;
} tmp;
tmp.munmap_p = dlsym(RTLD_NEXT, "munmap");
realmunmap = tmp.munmap_fp;
}
return realmunmap(addr, len);
#else
#error "Can not determine how to call munmap"
#endif
}

2
opal/mca/memory/memory.h
Просмотреть файл

@ -51,6 +51,8 @@ struct opal_memory_base_component_1_0_0_t {
*/
typedef struct opal_memory_base_component_1_0_0_t opal_memory_base_component_1_0_0_t;
extern opal_memory_base_component_1_0_0_t *opal_memory_active_component;
/*
* Macro for use in components that are of type memory v1.0.0
*/

15
opal/mca/memory/ptmalloc2/Makefile.am
Просмотреть файл

@ -42,10 +42,23 @@ noinst_LTLIBRARIES = libmca_memory_ptmalloc2.la
libmca_memory_ptmalloc2_la_SOURCES = \
opal_ptmalloc2_component.c \
opal_ptmalloc2_munmap.c \
opal_ptmalloc2_munmap.c
if OMPI_WANT_EXTERNAL_PTMALLOC2
lib_LTLIBRARIES = libopenmpi-malloc.la
libopenmpi_malloc_la_SOURCES = \
malloc.c \
malloc-stats.c \
malloc.h
else
libmca_memory_ptmalloc2_la_SOURCES += \
malloc.c \
malloc-stats.c \
malloc.h
endif
libmca_memory_ptmalloc2_la_LDFLAGS = -module -avoid-version $(memory_ptmalloc2_LDFLAGS)
libmca_memory_ptmalloc2_la_LIBADD = $(memory_ptmalloc2_LIBS)

15
opal/mca/memory/ptmalloc2/arena.c
Просмотреть файл

@ -469,18 +469,9 @@ ptmalloc_init __MALLOC_P((void))
/* don't use __hook for this, as someone might want to use those
features */
opal_mem_hooks_set_support(OPAL_MEMORY_FREE_SUPPORT |
#if defined(HAVE___MMAP) || defined(HAVE_DLSYM)
OPAL_MEMORY_MALLOC_SUPPORT |
#endif
#if defined(HAVE___MMAP)
OPAL_MEMORY_MMAP_SUPPORT |
#endif
#if OMPI_MEMORY_PTMALLOC2_OPT_SBRK
OPAL_MEMORY_CHUNK_SUPPORT
#else
0
#endif
);
OPAL_MEMORY_MUNMAP_SUPPORT |
OPAL_MEMORY_CHUNK_SUPPORT);
/********************* BEGIN OMPI CHANGES ******************************/
__malloc_initialized = 1;

26
opal/mca/memory/ptmalloc2/configure.m4
Просмотреть файл

@ -28,21 +28,18 @@ AC_DEFUN([MCA_memory_ptmalloc2_COMPILE_MODE], [
# [action-if-cant-compile])
# ------------------------------------------------
AC_DEFUN([MCA_memory_ptmalloc2_CONFIG],[
AC_ARG_ENABLE([ptmalloc2-internal],
[AC_HELP_STRING([--enable-ptmalloc2-internal],
[Build ptmalloc2 memory manager into libopen-pal,
instead of as separate library. Only has meaning
if ptmalloc2 memory component exists])])
AC_ARG_ENABLE([ptmalloc2-opt-sbrk],
[AC_HELP_STRING([--enable-ptmalloc2-opt-sbrk],
[Only trigger callbacks when sbrk is used for small
allocations, rather than every call to malloc/free.
(default: enabled)])])
AM_CONDITIONAL([OMPI_WANT_EXTERNAL_PTMALLOC2],
[test "$enable_ptmalloc2_internal" != "yes"])
AC_MSG_CHECKING([if ptmalloc2 should be part of libopen-pal])
AS_IF([test "$enable_ptmalloc2_internal" == "yes"],
[AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no])])
if test "$enable_ptmalloc2_opt_sbrk" = "no" ; then
memory_ptmalloc2_opt_sbrk=0
else
memory_ptmalloc2_opt_sbrk=1
fi
AC_DEFINE_UNQUOTED([OMPI_MEMORY_PTMALLOC2_OPT_SBRK],
[$memory_ptmalloc2_opt_sbrk],
[Trigger callbacks on sbrk instead of malloc or free])
AS_IF([test "$with_memory_manager" = "ptmalloc2"],
[if test "`echo $host | grep apple-darwin`" != "" ; then
@ -56,6 +53,7 @@ AC_DEFUN([MCA_memory_ptmalloc2_CONFIG],[
[memory_ptmalloc2_happy="yes"],
[memory_ptmalloc2_happy="no"])])
# Per ticket #227, Intel 9.0 v20051201 on ia64 with optimization
# of -O2 or higher will bork ptmalloc2 in strange in mysterious
# ways. Doh! So if the compiler vendor is intel and we're on an
@ -98,7 +96,7 @@ AC_DEFUN([MCA_memory_ptmalloc2_CONFIG],[
#
# See if we have sbrk prototyped
#
AC_CHECK_DECLS([sbrk])
AS_IF([test "$memory_ptmalloc2_happy" = "yes"], [AC_CHECK_DECLS([sbrk])])
#
# Figure out how we're going to call mmap/munmap for real

80
opal/mca/memory/ptmalloc2/malloc.c
Просмотреть файл

@ -17,30 +17,18 @@ void *sbrk();
#endif
#if OMPI_MEMORY_PTMALLOC2_OPT_SBRK
static void*
opal_mem_free_ptmalloc2_sbrk(int inc)
{
if (inc < 0) {
long oldp = (long) sbrk(0);
opal_mem_hooks_release_hook((void*) (oldp + inc), -inc, 1);
#if defined(HAVE___MMAP) || defined(HAVE_DLSYM)
} else if (inc > 0) {
long oldp = (long) sbrk(0);
opal_mem_hooks_alloc_hook((void*) oldp, inc, 1);
}
#endif
return sbrk(inc);
}
extern int opal_mem_free_ptmalloc2_munmap(void *start, size_t length, int from_alloc);
#if defined(HAVE___MMAP) || defined(HAVE_DLSYM)
extern void* opal_mem_free_ptmalloc2_mmap(void *start, size_t length,
int prot, int flags,
int fd, off_t offset, int from_alloc);
#endif
/* if we are trying to catch only allocations from and releases to the
operating system, intercept sbrk, mmap, and munmap. If we want to
@ -48,20 +36,6 @@ extern void* opal_mem_free_ptmalloc2_mmap(void *start, size_t length,
we need to add something into each of those calls anyway. */
#define MORECORE opal_mem_free_ptmalloc2_sbrk
#define munmap(a,b) opal_mem_free_ptmalloc2_munmap(a,b,1)
#if defined(HAVE___MMAP) || defined(HAVE_DLSYM)
#define mmap(a,b,c,d,e,f) opal_mem_free_ptmalloc2_mmap(a,b,c,d,e,f,1)
#endif
#endif /* OMPI_MEMORY_PTMALLOC2_OPT_SBRK */
/* easier to just not use mremap - having it makes tracking more
difficult */
#define HAVE_MREMAP 0
/* set the threshold for switching from sbrk heap to mmap higher than
normal so that there are more things in the heap. mmap segments
are never reused, so this keeps the number of calls to munmap and
sbrk down significantly */
#define DEFAULT_MMAP_THRESHOLD (2*1024*1024)
/* make some non-GCC compilers happy */
#ifndef __GNUC__
@ -3386,6 +3360,8 @@ mremap_chunk(p, new_size) mchunkptr p; size_t new_size;
/* Note the extra SIZE_SZ overhead as in mmap_chunk(). */
new_size = (new_size + offset + SIZE_SZ + page_mask) & ~page_mask;
/* OMPI change - take pessimistic approach and assume going to move */
opal_mem_hooks_release_hook((char *)p - offset, size, 1);
cp = (char *)mremap((char *)p - offset, size + offset, new_size,
MREMAP_MAYMOVE);
@ -3454,11 +3430,6 @@ public_mALLOc(size_t bytes)
assert(!victim || chunk_is_mmapped(mem2chunk(victim)) ||
ar_ptr == arena_for_chunk(mem2chunk(victim)));
/* OMPI Change */
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(victim, mUSABLe(victim), 1);
#endif
return victim;
}
#ifdef libc_hidden_def
@ -3477,10 +3448,6 @@ public_fREe(Void_t* mem)
(*hook)(mem, RETURN_ADDRESS (0));
return;
}
/* OMPI change */
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_release_hook(mem, mUSABLe(mem), 1);
#endif
if (mem == 0) /* free(0) has no effect */
return;
@ -3529,10 +3496,6 @@ public_rEALLOc(Void_t* oldmem, size_t bytes)
__realloc_hook;
if (hook != NULL)
return (*hook)(oldmem, bytes, RETURN_ADDRESS (0));
/* OMPI change */
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_release_hook(oldmem, mUSABLe(oldmem), 1);
#endif
#if REALLOC_ZERO_BYTES_FREES
if (bytes == 0 && oldmem != NULL) { public_fREe(oldmem); return 0; }
@ -3554,18 +3517,11 @@ public_rEALLOc(Void_t* oldmem, size_t bytes)
#if HAVE_MREMAP
newp = mremap_chunk(oldp, nb);
if(newp) {
/* OMPI Change */
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(newp, mUSABLe(newp));
#endif
return chunk2mem(newp);
}
#endif
/* Note the extra SIZE_SZ overhead. */
if(oldsize - SIZE_SZ >= nb) {
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(oldmem, mUSABLe(oldmem), 1);
#endif
return oldmem; /* do nothing */
}
/* Must alloc, copy, free. */
@ -3573,9 +3529,6 @@ public_rEALLOc(Void_t* oldmem, size_t bytes)
if (newmem == 0) return 0; /* propagate failure */
MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
munmap_chunk(oldp);
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(newmem, mUSABLe(newmem), 1);
#endif
return newmem;
}
#endif
@ -3602,9 +3555,6 @@ public_rEALLOc(Void_t* oldmem, size_t bytes)
(void)mutex_unlock(&ar_ptr->mutex);
assert(!newp || chunk_is_mmapped(mem2chunk(newp)) ||
ar_ptr == arena_for_chunk(mem2chunk(newp)));
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(newp, mUSABLe(newp), 1);
#endif
return newp;
}
#ifdef libc_hidden_def
@ -3653,9 +3603,6 @@ public_mEMALIGn(size_t alignment, size_t bytes)
}
assert(!p || chunk_is_mmapped(mem2chunk(p)) ||
ar_ptr == arena_for_chunk(mem2chunk(p)));
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(p, mUSABLe(p), 1);
#endif
return p;
}
#ifdef libc_hidden_def
@ -3675,9 +3622,6 @@ public_vALLOc(size_t bytes)
return 0;
p = _int_valloc(ar_ptr, bytes);
(void)mutex_unlock(&ar_ptr->mutex);
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(p, mUSABLe(p), 1);
#endif
return p;
}
@ -3692,9 +3636,6 @@ public_pVALLOc(size_t bytes)
arena_get(ar_ptr, bytes + 2*mp_.pagesize + MINSIZE);
p = _int_pvalloc(ar_ptr, bytes);
(void)mutex_unlock(&ar_ptr->mutex);
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(p, mUSABLe(p), 1);
#endif
return p;
}
@ -3731,9 +3672,6 @@ public_cALLOc(size_t n, size_t elem_size)
return memset(mem, 0, sz);
#else
while(sz > 0) ((char*)mem)[--sz] = 0; /* rather inefficient */
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(mem, mUSABLe(mem));
#endif
return mem;
#endif
}
@ -3789,9 +3727,6 @@ public_cALLOc(size_t n, size_t elem_size)
/* Two optional cases in which clearing not necessary */
#if HAVE_MMAP
if (chunk_is_mmapped(p)) {
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(mem, mUSABLe(mem), 1);
#endif
return mem;
}
#endif
@ -3834,9 +3769,6 @@ public_cALLOc(size_t n, size_t elem_size)
}
}
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(mem, mUSABLe(mem), 1);
#endif
return mem;
}
@ -3852,9 +3784,6 @@ public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks)
m = _int_icalloc(ar_ptr, n, elem_size, chunks);
(void)mutex_unlock(&ar_ptr->mutex);
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(m, mUSABLe(m), 1);
#endif
return m;
}
@ -3870,9 +3799,6 @@ public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks)
m = _int_icomalloc(ar_ptr, n, sizes, chunks);
(void)mutex_unlock(&ar_ptr->mutex);
#if !OMPI_MEMORY_PTMALLOC2_OPT_SBRK
opal_mem_hooks_alloc_hook(m, mUSABLe(m), 1);
#endif
return m;
}
@ -4776,6 +4702,8 @@ _int_realloc(mstate av, Void_t* oldmem, size_t bytes)
if (oldsize == newsize - offset)
return oldmem;
/* OMPI change - take pessimistic approach and assume going to move */
opal_mem_hooks_release_hook((char *)oldp - offset, oldsize + offset, 1);
cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
if (cp != MAP_FAILED) {

19
opal/mca/memory/ptmalloc2/opal_ptmalloc2_component.c
Просмотреть файл

@ -19,6 +19,9 @@
#include "opal_config.h"
#include "opal/mca/memory/memory.h"
#include "opal/memoryhooks/memory.h"
static int opal_memory_ptmalloc2_open(void);
const opal_memory_base_component_1_0_0_t mca_memory_ptmalloc2_component = {
/* First, the mca_component_t struct containing meta information
@ -35,7 +38,7 @@ const opal_memory_base_component_1_0_0_t mca_memory_ptmalloc2_component = {
OPAL_RELEASE_VERSION,
/* Component open and close functions */
NULL,
opal_memory_ptmalloc2_open,
NULL
},
@ -45,3 +48,17 @@ const opal_memory_base_component_1_0_0_t mca_memory_ptmalloc2_component = {
MCA_BASE_METADATA_PARAM_CHECKPOINT
},
};
static int
opal_memory_ptmalloc2_open(void)
{
/* we always provide munmap support as part of libopen-pal.la.
Will also provide malloc/free support if user linked us in. In
that case, we've already likely called set_support, so don't
crush what has already been done */
if (0 == opal_mem_hooks_support_level()) {
opal_mem_hooks_set_support(OPAL_MEMORY_MUNMAP_SUPPORT);
}
return OPAL_SUCCESS;
}

44
opal/mca/memory/ptmalloc2/opal_ptmalloc2_munmap.c
Просмотреть файл

@ -88,47 +88,3 @@ opal_mem_free_ptmalloc2_munmap(void *start, size_t length, int from_alloc)
#error "Can not determine how to call munmap"
#endif
}
/*
* mmap is only intercepted if we have a chance of finding it (ie, a
* syscall or weak symbol)
*/
void* opal_mem_free_ptmalloc2_mmap(void *start, size_t length,
int prot, int flags,
int fd, off_t offset,
int from_alloc);
#if defined(HAVE___MMAP)
void* __mmap(void *start, size_t length, int prot, int flags,
int fd, off_t offset);
void*
mmap(void *start, size_t length, int prot, int flags,
int fd, off_t offset)
{
return opal_mem_free_ptmalloc2_mmap(start, length, prot, flags,
fd, offset, 0);
}
#endif /* defined(HAVE___MMAP) */
void* opal_mem_free_ptmalloc2_mmap(void *start, size_t length,
int prot, int flags,
int fd, off_t offset,
int from_alloc)
{
void *tmp;
#if defined(HAVE___MMAP)
tmp = __mmap(start, length, prot, flags, fd, offset);
#else
tmp = mmap(start, length, prot, flags, fd, offset);
#endif
opal_mem_hooks_alloc_hook(tmp, length, from_alloc);
return tmp;
}

9
opal/mca/memory/ptmalloc2/opal_ptmalloc2_munmap.h
Просмотреть файл

@ -23,14 +23,7 @@
BEGIN_C_DECLS
int opal_mem_free_ptmalloc2_munmap(void *start, size_t length, int from_alloc);
void* opal_mem_free_ptmalloc2_mmap(void *start, size_t length,
int prot, int flags,
int fd, off_t offset,
int from_alloc);
OPAL_DECLSPEC void* mmap(void *start, size_t length, int prot, int flags,
int fd, off_t offset);
OPAL_DECLSPEC int opal_mem_free_ptmalloc2_munmap(void *start, size_t length, int from_alloc);
OPAL_DECLSPEC int munmap(void* addr, size_t len);

141
opal/memoryhooks/memory.c
Просмотреть файл

@ -49,10 +49,6 @@ static OBJ_CLASS_INSTANCE(callback_list_item_t, opal_list_item_t, NULL, NULL);
*/
static int hooks_support = 0;
static opal_list_t alloc_cb_list;
static opal_atomic_lock_t alloc_lock;
static int alloc_run_callbacks;
static opal_list_t release_cb_list;
static opal_atomic_lock_t release_lock;
static int release_run_callbacks;
@ -60,15 +56,12 @@ static int release_run_callbacks;
int
opal_mem_hooks_init(void)
{
OBJ_CONSTRUCT(&alloc_cb_list, opal_list_t);
OBJ_CONSTRUCT(&release_cb_list, opal_list_t);
opal_atomic_init(&alloc_lock, OPAL_ATOMIC_UNLOCKED);
opal_atomic_init(&release_lock, OPAL_ATOMIC_UNLOCKED);
/* delay running callbacks until there is something in the
registration */
alloc_run_callbacks = false;
release_run_callbacks = false;
opal_atomic_mb();
@ -82,28 +75,20 @@ opal_mem_hooks_finalize(void)
opal_list_item_t *item;
/* don't try to run callbacks any more */
alloc_run_callbacks = false;
release_run_callbacks = false;
opal_atomic_mb();
/* aquire the lock, just to make sure no one is currently
twiddling with the list. We know this won't last long, since
no new calls will come in after we set run_callbacks to false */
opal_atomic_lock(&alloc_lock);
opal_atomic_lock(&release_lock);
/* clean out the lists */
while (NULL != (item = opal_list_remove_first(&alloc_cb_list))) {
OBJ_RELEASE(item);
}
OBJ_DESTRUCT(&alloc_cb_list);
while (NULL != (item = opal_list_remove_first(&release_cb_list))) {
OBJ_RELEASE(item);
}
OBJ_DESTRUCT(&release_cb_list);
opal_atomic_unlock(&alloc_lock);
opal_atomic_unlock(&release_lock);
return OPAL_SUCCESS;
@ -118,39 +103,6 @@ opal_mem_hooks_set_support(int support)
}
/* called from the memory manager / memory-manager specific hooks */
void
opal_mem_hooks_alloc_hook(void *buf, size_t length, bool from_alloc)
{
opal_list_item_t *item;
if (!alloc_run_callbacks) return;
/*
* This is not really thread safe - but we can't hold the lock
* while calling the callback function as this routine can
* be called recursively.
*
* Instead, we could set a flag if we are already in the callback,
* and if called recursively queue the new address/length and allow
* the initial callback to dispatch this
*/
opal_atomic_lock(&alloc_lock);
item = opal_list_get_first(&alloc_cb_list);
while(item != opal_list_get_end(&alloc_cb_list)) {
opal_list_item_t* next = opal_list_get_next(item);
callback_list_item_t *cbitem = (callback_list_item_t*) item;
item = next;
opal_atomic_unlock(&alloc_lock);
cbitem->cbfunc(buf, length, cbitem->cbdata, (bool) from_alloc);
opal_atomic_lock(&alloc_lock);
}
opal_atomic_unlock(&alloc_lock);
}
/* called from the memory manager / memory-manager specific hooks */
void
opal_mem_hooks_release_hook(void *buf, size_t length, bool from_alloc)
@ -191,61 +143,6 @@ opal_mem_hooks_support_level(void)
}
int
opal_mem_hooks_register_alloc(opal_mem_hooks_callback_fn_t *func, void *cbdata)
{
opal_list_item_t *item;
callback_list_item_t *cbitem, *new_cbitem;
int ret = OPAL_SUCCESS;
if (0 == (OPAL_MEMORY_FREE_SUPPORT & hooks_support)) {
return OPAL_ERR_NOT_SUPPORTED;
}
/* pre-allocate a callback item on the assumption it won't be
found. We can't call OBJ_NEW inside the lock because it might
call alloc / realloc */
new_cbitem = OBJ_NEW(callback_list_item_t);
if (NULL == new_cbitem) {
ret = OPAL_ERR_OUT_OF_RESOURCE;
goto done;
}
opal_atomic_lock(&alloc_lock);
/* we either have or are about to have a registration that needs
calling back. Let the system know it needs to run callbacks
now */
alloc_run_callbacks = true;
opal_atomic_mb();
/* make sure the callback isn't already in the list */
for (item = opal_list_get_first(&alloc_cb_list) ;
item != opal_list_get_end(&alloc_cb_list) ;
item = opal_list_get_next(item)) {
cbitem = (callback_list_item_t*) item;
if (cbitem->cbfunc == func) {
ret = OPAL_EXISTS;
goto done;
}
}
new_cbitem->cbfunc = func;
new_cbitem->cbdata = cbdata;
opal_list_append(&alloc_cb_list, (opal_list_item_t*) new_cbitem);
done:
opal_atomic_unlock(&alloc_lock);
if (OPAL_EXISTS == ret && NULL != new_cbitem) {
OBJ_RELEASE(new_cbitem);
}
return ret;
}
int
opal_mem_hooks_register_release(opal_mem_hooks_callback_fn_t *func, void *cbdata)
{
@ -253,7 +150,7 @@ opal_mem_hooks_register_release(opal_mem_hooks_callback_fn_t *func, void *cbdata
callback_list_item_t *cbitem, *new_cbitem;
int ret = OPAL_SUCCESS;
if (0 == (OPAL_MEMORY_FREE_SUPPORT & hooks_support)) {
if (0 == ((OPAL_MEMORY_FREE_SUPPORT|OPAL_MEMORY_MUNMAP_SUPPORT) & hooks_support)) {
return OPAL_ERR_NOT_SUPPORTED;
}
@ -301,42 +198,6 @@ opal_mem_hooks_register_release(opal_mem_hooks_callback_fn_t *func, void *cbdata
}
int
opal_mem_hooks_unregister_alloc(opal_mem_hooks_callback_fn_t* func)
{
opal_list_item_t *item;
opal_list_item_t *found_item = NULL;
callback_list_item_t *cbitem;
int ret = OPAL_ERR_NOT_FOUND;
opal_atomic_lock(&alloc_lock);
/* make sure the callback isn't already in the list */
for (item = opal_list_get_first(&alloc_cb_list) ;
item != opal_list_get_end(&alloc_cb_list) ;
item = opal_list_get_next(item)) {
cbitem = (callback_list_item_t*) item;
if (cbitem->cbfunc == func) {
opal_list_remove_item(&alloc_cb_list, item);
found_item = item;
ret = OPAL_SUCCESS;
break;
}
}
opal_atomic_unlock(&alloc_lock);
/* OBJ_ALLOC calls free, so we can't alloc until we get out of
the lock */
if (NULL != found_item) {
OBJ_RELEASE(item);
}
return ret;
}
int
opal_mem_hooks_unregister_release(opal_mem_hooks_callback_fn_t* func)
{

49
opal/memoryhooks/memory.h
Просмотреть файл

@ -91,20 +91,15 @@ OPAL_DECLSPEC int opal_mem_hooks_finalize(void);
* callback events when memory is going
* to be released by the process, either
* by the user calling an allocator
* function or mmap.
* @retval OPAL_MEMORY_MALLOC_SUPPORT Memory hooks subsystem can trigger
* callback events when memory is being
* allocated by the process through the
* traditional allocator (malloc,
* calloc, etc.)
* @retval OPAL_MEMORY_MMAP_SUPPORT Memory hooks subsystem can trigger
* callback events when memory is being
* allocated by the process through mmap.
* function or munmap. Implies
* OPAL_MEMORY_MUNMAP_SUPPORT.
* @retval OPAL_MEMORY_MUNMAP_SUPPORT Subsystem can trigger callback events
* by the user calling munmap directly.
* @retval OPAL_MEMORY_CHUNK_SUPPORT Memory hooks subsystem will only
* trigger callback events when the
* process is giving memory back to the
* operating system, not at ever call
* to malloc/realloc/free/etc.
* to realloc/free/etc.
*
* \note This function must be called after opal_mem_hooks_init().
*/
@ -131,26 +126,6 @@ typedef void (opal_mem_hooks_callback_fn_t)(void *buf, size_t length,
void *cbdata, bool from_alloc);
/**
* Register callback for when memory has been allocated
*
* Register a \c opal_mem_hooks_callback_fn_t function pointer to be
* called whenever the current process has allocated memory
*
* @param func Function pointer to call when memory has been allocated
* @param cbdata A pointer-length field to be passed to func when it is
* invoked.
*
* @retval OPAL_SUCCESS The registration completed successfully.
* @retval OPAL_EXISTS The function is already registered and will not
* be registered again.
* @retval OPAL_ERR_NOT_SUPPORTED There are no hooks available for
* receiving callbacks when memory is to be allocated
*/
OPAL_DECLSPEC int opal_mem_hooks_register_alloc(opal_mem_hooks_callback_fn_t *func,
void *cbdata);
/**
* Register callback for when memory is to be released
*
@ -170,20 +145,6 @@ OPAL_DECLSPEC int opal_mem_hooks_register_alloc(opal_mem_hooks_callback_fn_t *fu
OPAL_DECLSPEC int opal_mem_hooks_register_release(opal_mem_hooks_callback_fn_t *func,
void *cbdata);
/**
* Unregister previously registered alloc callback
*
* Unregister previously registered alloc callback.
*
* @param func Function pointer to registered callback to remove
*
* @retval OPAL_SUCCESS The function was successfully deregistered
* @retval OPAL_ERR_NOT_FOUND The function was not previously registered
*/
OPAL_DECLSPEC int opal_mem_hooks_unregister_alloc(opal_mem_hooks_callback_fn_t *func);
/**
* Unregister previously registered release callback
*

10
opal/memoryhooks/memory_internal.h
Просмотреть файл

@ -25,20 +25,18 @@
# include <sys/types.h>
#endif
/* see memory.h for meaning */
#define OPAL_MEMORY_FREE_SUPPORT 0x0001
#define OPAL_MEMORY_MALLOC_SUPPORT 0x0002
#define OPAL_MEMORY_MUNMAP_SUPPORT 0x0002
#define OPAL_MEMORY_CHUNK_SUPPORT 0x0004
#define OPAL_MEMORY_MMAP_SUPPORT 0x0008
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif
void opal_mem_hooks_set_support(int support);
OPAL_DECLSPEC void opal_mem_hooks_set_support(int support);
void opal_mem_hooks_release_hook(void *buf, size_t length, bool from_alloc);
void opal_mem_hooks_alloc_hook(void *buf, size_t length, bool from_alloc);
OPAL_DECLSPEC void opal_mem_hooks_release_hook(void *buf, size_t length, bool from_alloc);
#if defined(c_plusplus) || defined(__cplusplus)
}