Ubuntu Manpage: hbwmalloc - The high bandwidth memory interface

Provided by: libmemkind-dev_1.1.0-0ubuntu1_amd64

NAME

       hbwmalloc - The high bandwidth memory interface
       Note: hbwmalloc.h functionality is considered as stable API (STANDARD API).

SYNOPSIS

       #include <hbwmalloc.h>

       Link with -lmemkind

       int hbw_check_available(void);
       void* hbw_malloc(size_t size);
       void* hbw_calloc(size_t nmemb, size_t size);
       void* hbw_realloc (void *ptr, size_t size);
       void hbw_free(void *ptr);
       int hbw_posix_memalign(void **memptr, size_t alignment, size_t size);
       int hbw_posix_memalign_psize(void **memptr, size_t alignment, size_t size, hbw_pagesize_t pagesize);
       hbw_policy_t hbw_get_policy(void);
       int hbw_set_policy(hbw_policy_t mode);

DESCRIPTION

hbw_check_available() returns 0 if high bandwidth memory is available and an error code described in the
ERRORS section if not.

hbw_malloc() allocates size bytes of uninitialized high bandwidth memory. The allocated space is suitably
aligned (after possible pointer coercion) for storage of any type of object. If size is zero then
hbw_malloc() returns NULL.

hbw_calloc() allocates space for nmemb objects in high bandwidth memory, each size bytes in length. The
result is identical to calling hbw_malloc() with an argument of nmemb*size , with the exception that the
allocated memory is explicitly initialized to zero bytes. If nmemb or size is 0, then hbw_calloc()
returns NULL.

hbw_realloc() changes the size of the previously allocated high bandwidth memory referenced by ptr to
size bytes. The contents of the memory are unchanged up to the lesser of the new and old sizes. If the
new size is larger, the contents of the newly allocated portion of the memory are undefined. Upon
success, the memory referenced by ptr is freed and a pointer to the newly allocated high bandwidth memory
is returned.

Note: hbw_realloc() may move the memory allocation, resulting in a different return value than ptr.

If ptr is NULL, the hbw_realloc() function behaves identically to hbw_malloc() for the specified size.
The address ptr, if not NULL, was returned by a previous call to hbw_malloc(), hbw_calloc(),
hbw_realloc(), or hbw_posix_memalign(). Otherwise, or if hbw_free(ptr) was called before, undefined
behavior occurs.

Note: hbw_realloc() cannot be used with a pointer returned by hbw_posix_memalign_psize().

hbw_free() causes the allocated memory referenced by ptr to be made available for future allocations. If
ptr is NULL, no action occurs. The address ptr, if not NULL, must have been returned by a previous call
to hbw_malloc(), hbw_calloc(), hbw_realloc(), hbw_posix_memalign(), or hbw_posix_memalign_psize().
Otherwise, if hbw_free(ptr) was called before, undefined behavior occurs.

hbw_posix_memalign() allocates size bytes of high bandwidth memory such that the allocation's base
address is an even multiple of alignment, and returns the allocation in the value pointed to by memptr.
The requested alignment must be a power of 2 at least as large as sizeof(void *).

hbw_posix_memalign_psize() allocates size bytes of high bandwidth memory such that the allocation's base
address is an even multiple of alignment, and returns the allocation in the value pointed to by memptr.
The requested alignment must be a power of 2 at least as large as sizeof(void *). The memory will be
allocated using pages determined by the pagesize variable which may be one of the following enumerated
values:

HBW_PAGESIZE_4KB
The four kilobyte page size option. Note that with transparent huge pages enabled these
allocations may be promoted by the operating system to two megabyte pages.

HBW_PAGESIZE_2MB
The two megabyte page size option.

HBW_PAGESIZE_1GB
This option allows the user to specify arbitrary sizes backed by one gigabytes pages. Gigabyte
pages are allocated even if the size is not a modulo of 1GB. A good example of using this feature
with realloc is shown in gb_realloc_example.c

HBW_PAGESIZE_1GB_STRICT
The one gigabyte page size option. The total size of the allocation must be a multiple of 1GB with
this option, otherwise the allocation will fail.

hbw_get_policy() returns the current fallback policy when insufficient high bandwith memory is available.

hbw_set_policy() sets the current fallback policy. The policy can be modified only once in the lifetime
of an application and before calling hbw_*alloc() or hbw_posix_memalign*() function.
Note: If the policy is not set, than HBW_POLICY_PREFERRED will be used by default.

HBW_POLICY_BIND
If insufficient high bandwidth memory from the nearest NUMA node is available to satisfy a
request, the allocated pointer is set to NULL and errno is set to ENOMEM. If insufficient high
bandwidth memory pages are available at fault time the Out Of Memory (OOM) killer is triggered.
Note that pages are faulted exclusively from the high bandwidth NUMA node nearest at time of
allocation, not at time of fault.

HBW_POLICY_PREFERRED
If insufficient memory is available from the high bandwidth NUMA node closest at allocation time,
fall back to standard memory (default) with the smallest NUMA distance.

HBW_POLICY_INTERLEAVE
Interleave faulted pages from across all high bandwidth NUMA nodes using standard size pages (the
Transparent Huge Page feature is disabled).

RETURN VALUE

       hbw_get_policy() returns HBW_POLICY_BIND  or  HBW_POLICY_PREFERRED  which  represents  the  current  high
       bandwidth  policy.   hbw_free()  do  not have return value.  hbw_malloc() hbw_calloc(), and hbw_realloc()
       return the pointer to the  allocated  memory,  or  NULL  if  the  request  fails.   hbw_posix_memalign(),
       hbw_posix_memalign_psize()  and  hbw_set_policy()  return  zero  on  success  and return an error code as
       described in the ERRORS section below on failure.

ERRORS

       Error codes described here are the POSIX standard error codes as defined in <errno.h>

       hbw_check_available()
              returns ENODEV if high-bandwidth memory is unavailable.

       hbw_posix_memalign() and hbw_posix_memalign_psize()
              If the alignment parameter is not a power of two, or was not a multiple of sizoeof(void  *),  then
              EINVAL  is  returned.  If  there  was  insufficient  memory  to satisfy the request then ENOMEM is
              returned.

       hbw_set_policy()
              returns EPERM if hbw_set_policy () was called more than once,  or  EINVAL  if  mode  argument  was
              neither HBW_POLICY_PREFERRED, HBW_POLICY_BIND nor HBW_POLICY_INTERLEAVE.

NOTES

       The  hbwmalloc.h  file  defines  the external functions and enumerations for the hbwmalloc library. These
       interfaces define a heap manager that targets high bandwidth memory numa nodes.

FILES

       /usr/bin/memkind-hbw-nodes
              Prints a comma separated list of high bandwidth nodes.

ENVIRONMENT

       MEMKIND_HBW_NODES
              This environment varaible is a comma separated list  of  NUMA  nodes  that  are  treated  as  high
              bandwidth.  Uses  the libnuma routine numa_parse_nodestring() for parsing, so the syntax described
              in the numa(3) man page for this routine applies for example: 1-3,5 is a valid setting.

       MEMKIND_ARENA_NUM_PER_KIND
              This environment variable allows leveraging internal mechanism of the library for  setting  number
              of  arenas  per  kind.  Value  should  be  a positive integer (not greater than INT_MAX defined in
              limits.h).  The user should set the value based on the  characteristics  of  application  that  is
              using  the  library.  Higher  value  can  provide  better  performance  in extremely multithreaded
              applications at the cost of memory overhead. See section "IMPLEMENTATION NOTES" of jemalloc(3) for
              more details about arenas.

COPYRIGHT

       Copyright (C) 2014 - 2016 Intel Corporation. All rights reserved.