/*
* Copyright (C) 2019 - 2020 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.
*/
#pragma once
#include <cmath>
#include <map>
#include <memory>
#include <string>
#include <exception>
#include <type_traits>
#include <cstddef>
#include <stdexcept>
#include "memkind.h"
/*
* Header file for the C++ allocator compatible with the C++ standard library allocator concepts.
* More details in memkind(3) man page.
* Note: memory heap management is based on memkind_malloc, refer to the memkind(3) man page for more
* information.
*
* Functionality defined in this header is considered as stable API (STANDARD API).
* API standards are described in memkind(3) man page.
*/
namespace libmemkind
{
enum class kinds {
DEFAULT = 0,
HUGETLB = 1,
INTERLEAVE = 2,
HBW = 3,
HBW_ALL = 4,
HBW_HUGETLB = 5,
HBW_ALL_HUGETLB = 6,
HBW_PREFERRED = 7,
HBW_PREFERRED_HUGETLB = 8,
HBW_INTERLEAVE = 9,
REGULAR = 10,
DAX_KMEM = 11,
DAX_KMEM_ALL = 12,
DAX_KMEM_PREFERRED = 13,
};
namespace static_kind
{
template<typename T>
class allocator
{
public:
using value_type = T;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using size_type = size_t;
using difference_type = ptrdiff_t;
template<class U>
struct rebind {
using other = allocator<U>;
};
template<typename U>
friend class allocator;
#if !_GLIBCXX_USE_CXX11_ABI
/* This is a workaround for compilers (e.g GCC 4.8) that uses C++11 standard,
* but use old - non C++11 ABI */
template<typename V = void>
explicit allocator()
{
static_assert(std::is_same<V, void>::value,
"libmemkind::static_kind::allocator cannot be compiled without CXX11 ABI");
}
#endif
explicit allocator(libmemkind::kinds kind)
{
switch (kind) {
case libmemkind::kinds::DEFAULT:
_kind = MEMKIND_DEFAULT;
break;
case libmemkind::kinds::HUGETLB:
_kind = MEMKIND_HUGETLB;
break;
case libmemkind::kinds::INTERLEAVE:
_kind = MEMKIND_INTERLEAVE;
break;
case libmemkind::kinds::HBW:
_kind = MEMKIND_HBW;
break;
case libmemkind::kinds::HBW_ALL:
_kind = MEMKIND_HBW_ALL;
break;
case libmemkind::kinds::HBW_HUGETLB:
_kind = MEMKIND_HBW_HUGETLB;
break;
case libmemkind::kinds::HBW_ALL_HUGETLB:
_kind = MEMKIND_HBW_ALL_HUGETLB;
break;
case libmemkind::kinds::HBW_PREFERRED:
_kind = MEMKIND_HBW_PREFERRED;
break;
case libmemkind::kinds::HBW_PREFERRED_HUGETLB:
_kind = MEMKIND_HBW_PREFERRED_HUGETLB;
break;
case libmemkind::kinds::HBW_INTERLEAVE:
_kind = MEMKIND_HBW_INTERLEAVE;
break;
case libmemkind::kinds::REGULAR:
_kind = MEMKIND_REGULAR;
break;
case libmemkind::kinds::DAX_KMEM:
_kind = MEMKIND_DAX_KMEM;
break;
case libmemkind::kinds::DAX_KMEM_ALL:
_kind = MEMKIND_DAX_KMEM_ALL;
break;
case libmemkind::kinds::DAX_KMEM_PREFERRED:
_kind = MEMKIND_DAX_KMEM_PREFERRED;
break;
default:
throw std::runtime_error("Unknown libmemkind::kinds");
break;
}
}
allocator(const allocator &other) = default;
template <typename U>
allocator(const allocator<U> &other) noexcept
{
_kind = other._kind;
}
allocator(allocator &&other) = default;
template <typename U>
allocator(const allocator<U> &&other) noexcept
{
_kind = std::move(other._kind);
}
allocator<T> &operator = (const allocator &other) = default;
template <typename U>
allocator<T> &operator = (const allocator<U> &other) noexcept
{
_kind = other._kind;
return *this;
}
allocator<T> &operator = (allocator &&other) = default;
template <typename U>
allocator<T> &operator = (allocator<U> &&other) noexcept
{
_kind = std::move(other._kind);
return *this;
}
pointer allocate(size_type n) const
{
pointer result = static_cast<pointer>(memkind_malloc(_kind, n*sizeof(T)));
if (!result) {
throw std::bad_alloc();
}
return result;
}
void deallocate(pointer p, size_type n) const
{
memkind_free(_kind, static_cast<void *>(p));
}
template <class U, class... Args>
void construct(U *p, Args &&... args) const
{
::new((void *)p) U(std::forward<Args>(args)...);
}
void destroy(pointer p) const
{
p->~value_type();
}
template <typename U, typename V>
friend bool operator ==(const allocator<U> &lhs, const allocator<V> &rhs);
template <typename U, typename V>
friend bool operator !=(const allocator<U> &lhs, const allocator<V> &rhs);
private:
memkind_t _kind;
};
template <typename U, typename V>
bool operator ==(const allocator<U> &lhs, const allocator<V> &rhs)
{
return lhs._kind == rhs._kind;
}
template <typename U, typename V>
bool operator !=(const allocator<U> &lhs, const allocator<V> &rhs)
{
return !(lhs._kind == rhs._kind);
}
} // namespace static_kind
} // namespace libmemkind