/*
* Copyright (C) 2014 - 2019 Intel Corporation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice(s),
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice(s),
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <memkind/internal/memkind_arena.h>
#include <memkind/internal/memkind_default.h>
#include <memkind/internal/memkind_private.h>
#include <memkind/internal/memkind_log.h>
#include <memkind/internal/tbb_wrapper.h>
#include <memkind/internal/heap_manager.h>
#include <numa.h>
#include <numaif.h>
#include <sys/mman.h>
#include <errno.h>
#include <jemalloc/jemalloc.h>
#include <stdint.h>
#include "config.h"
#ifndef MADV_NOHUGEPAGE
#define MADV_NOHUGEPAGE 15
#endif
static int memkind_default_get_kind_stat(struct memkind *kind,
memkind_stat_type stat, size_t *value)
{
return memkind_arena_get_stat_with_check_init(kind, stat, true, value);
}
MEMKIND_EXPORT struct memkind_ops MEMKIND_DEFAULT_OPS = {
.create = memkind_default_create,
.destroy = memkind_default_destroy,
.malloc = memkind_default_malloc,
.calloc = memkind_default_calloc,
.posix_memalign = memkind_default_posix_memalign,
.realloc = memkind_default_realloc,
.free = memkind_default_free,
.init_once = memkind_default_init_once,
.malloc_usable_size = memkind_default_malloc_usable_size,
.finalize = memkind_default_destroy,
.get_stat = memkind_default_get_kind_stat,
.defrag_reallocate = memkind_arena_defrag_reallocate
};
MEMKIND_EXPORT int memkind_default_create(struct memkind *kind,
struct memkind_ops *ops, const char *name)
{
int err = 0;
kind->ops = ops;
if (strlen(name) >= MEMKIND_NAME_LENGTH_PRIV) {
kind->name[0] = '\0';
err = MEMKIND_ERROR_INVALID;
} else {
strcpy(kind->name, name);
}
return err;
}
MEMKIND_EXPORT int memkind_default_destroy(struct memkind *kind)
{
return 0;
}
MEMKIND_EXPORT void *memkind_default_malloc(struct memkind *kind, size_t size)
{
if(MEMKIND_UNLIKELY(size_out_of_bounds(size))) {
return NULL;
}
return jemk_malloc(size);
}
MEMKIND_EXPORT void *memkind_default_calloc(struct memkind *kind, size_t num,
size_t size)
{
if(MEMKIND_UNLIKELY(size_out_of_bounds(num) || size_out_of_bounds(size))) {
return NULL;
}
return jemk_calloc(num, size);
}
MEMKIND_EXPORT int memkind_default_posix_memalign(struct memkind *kind,
void **memptr, size_t alignment, size_t size)
{
if(MEMKIND_UNLIKELY(size_out_of_bounds(size))) {
*memptr = NULL;
return 0;
}
return jemk_posix_memalign(memptr, alignment, size);
}
MEMKIND_EXPORT void *memkind_default_realloc(struct memkind *kind, void *ptr,
size_t size)
{
if(MEMKIND_UNLIKELY(size_out_of_bounds(size))) {
jemk_free(ptr);
return NULL;
}
return jemk_realloc(ptr, size);
}
MEMKIND_EXPORT void memkind_default_free(struct memkind *kind, void *ptr)
{
jemk_free(ptr);
}
MEMKIND_EXPORT size_t memkind_default_malloc_usable_size(struct memkind *kind,
void *ptr)
{
return jemk_malloc_usable_size(ptr);
}
MEMKIND_EXPORT void *memkind_default_mmap(struct memkind *kind, void *addr,
size_t size)
{
void *result = MAP_FAILED;
int err = 0;
int flags;
if (kind->ops->get_mmap_flags) {
err = kind->ops->get_mmap_flags(kind, &flags);
} else {
err = memkind_default_get_mmap_flags(kind, &flags);
}
if (MEMKIND_LIKELY(!err)) {
result = mmap(addr, size, PROT_READ | PROT_WRITE, flags, -1, 0);
if (result == MAP_FAILED) {
log_err("syscall mmap() returned: %p", result);
return result;
}
}
if (kind->ops->mbind) {
err = kind->ops->mbind(kind, result, size);
if (err) {
munmap(result, size);
result = MAP_FAILED;
}
}
if (kind->ops->madvise) {
err = kind->ops->madvise(kind, result, size);
if (err) {
munmap(result, size);
result = MAP_FAILED;
}
}
return result;
}
MEMKIND_EXPORT int memkind_nohugepage_madvise(struct memkind *kind, void *addr,
size_t size)
{
int err = madvise(addr, size, MADV_NOHUGEPAGE);
//checking if EINVAL was returned due to lack of THP support in kernel
if ((err == EINVAL) && (((uintptr_t) addr & (uintptr_t) 0xfff) == 0) &&
(size > 0)) {
return 0;
}
if (MEMKIND_UNLIKELY(err)) {
log_err("syscall madvise() returned: %d", err);
}
return err;
}
MEMKIND_EXPORT int memkind_default_mbind(struct memkind *kind, void *ptr,
size_t size)
{
nodemask_t nodemask;
int err = 0;
int mode;
if (MEMKIND_UNLIKELY(kind->ops->get_mbind_nodemask == NULL ||
kind->ops->get_mbind_mode == NULL)) {
log_err("memkind_ops->mbind_mode or memkind_ops->bind_nodemask is NULL.");
return MEMKIND_ERROR_BADOPS;
}
err = kind->ops->get_mbind_nodemask(kind, nodemask.n, NUMA_NUM_NODES);
if (MEMKIND_UNLIKELY(err)) {
return err;
}
err = kind->ops->get_mbind_mode(kind, &mode);
if (MEMKIND_UNLIKELY(err)) {
return err;
}
err = mbind(ptr, size, mode, nodemask.n, NUMA_NUM_NODES, 0);
if (MEMKIND_UNLIKELY(err)) {
log_err("syscall mbind() returned: %d", err);
return MEMKIND_ERROR_MBIND;
}
return err;
}
MEMKIND_EXPORT int memkind_default_get_mmap_flags(struct memkind *kind,
int *flags)
{
*flags = MAP_PRIVATE | MAP_ANONYMOUS;
return 0;
}
MEMKIND_EXPORT int memkind_default_get_mbind_nodemask(struct memkind *kind,
unsigned long *nodemask,
unsigned long maxnode)
{
struct bitmask nodemask_bm = {maxnode, nodemask};
copy_bitmask_to_bitmask(numa_all_nodes_ptr, &nodemask_bm);
return 0;
}
MEMKIND_EXPORT int memkind_default_get_mbind_mode(struct memkind *kind,
int *mode)
{
*mode = MPOL_BIND;
return 0;
}
MEMKIND_EXPORT int memkind_preferred_get_mbind_mode(struct memkind *kind,
int *mode)
{
*mode = MPOL_PREFERRED;
return 0;
}
MEMKIND_EXPORT int memkind_interleave_get_mbind_mode(struct memkind *kind,
int *mode)
{
*mode = MPOL_INTERLEAVE;
return 0;
}
MEMKIND_EXPORT int memkind_posix_check_alignment(struct memkind *kind,
size_t alignment)
{
int err = 0;
if ((alignment < sizeof(void *)) ||
(((alignment - 1) & alignment) != 0)) {
err = EINVAL;
}
return err;
}
MEMKIND_EXPORT void memkind_default_init_once(void)
{
heap_manager_init(MEMKIND_DEFAULT);
}