blob: 4b8167ba03933a27e5aa3b8145340820aa0e6881 [file] [log] [blame]
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#ifndef SUPPORT_TEST_MEMORY_RESOURCE_HPP
#define SUPPORT_TEST_MEMORY_RESOURCE_HPP
#include <experimental/memory_resource>
#include <experimental/utility>
#include <memory>
#include <type_traits>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
#include "controlled_allocators.hpp"
#include "uses_alloc_types.hpp"
// FIXME: This is a hack to allow uses_allocator_types.hpp to work with
// erased_type. However we can't define that behavior directly in the header
// because it can't include <experimental/memory_resource>
template <>
struct TransformErasedTypeAlloc<std::experimental::erased_type> {
using type = std::experimental::pmr::polymorphic_allocator<int>;
};
template <class ProviderT, int = 0>
class TestResourceImp : public std::experimental::pmr::memory_resource
{
public:
static int resource_alive;
static int resource_constructed;
static int resource_destructed;
static void resetStatics() {
assert(resource_alive == 0);
resource_alive = 0;
resource_constructed = 0;
resource_destructed = 0;
}
using memory_resource = std::experimental::pmr::memory_resource;
using Provider = ProviderT;
int value;
explicit TestResourceImp(int val = 0) : value(val) {
++resource_alive;
++resource_constructed;
}
~TestResourceImp() noexcept {
--resource_alive;
++resource_destructed;
}
void reset() { C.reset(); P.reset(); }
AllocController& getController() { return C; }
bool checkAlloc(void* p, std::size_t s, std::size_t a) const
{ return C.checkAlloc(p, s, a); }
bool checkDealloc(void* p, std::size_t s, std::size_t a) const
{ return C.checkDealloc(p, s, a); }
bool checkIsEqualCalledEq(int n) const { return C.checkIsEqualCalledEq(n); }
protected:
virtual void * do_allocate(std::size_t s, std::size_t a) {
if (C.throw_on_alloc) {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw TestException{};
#else
assert(false);
#endif
}
void* ret = P.allocate(s, a);
C.countAlloc(ret, s, a);
return ret;
}
virtual void do_deallocate(void * p, std::size_t s, std::size_t a) {
C.countDealloc(p, s, a);
P.deallocate(p, s, a);
}
virtual bool do_is_equal(memory_resource const & other) const noexcept {
C.countIsEqual();
TestResourceImp const * o = dynamic_cast<TestResourceImp const *>(&other);
return o && o->value == value;
}
private:
mutable AllocController C;
mutable Provider P;
DISALLOW_COPY(TestResourceImp);
};
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_alive = 0;
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_constructed = 0;
template <class Provider, int N>
int TestResourceImp<Provider, N>::resource_destructed = 0;
struct NullProvider {
NullProvider() {}
void* allocate(size_t, size_t) { return nullptr; }
void deallocate(void*, size_t, size_t) {}
void reset() {}
private:
DISALLOW_COPY(NullProvider);
};
struct NewDeleteProvider {
NewDeleteProvider() {}
void* allocate(size_t s, size_t) { return ::operator new(s); }
void deallocate(void* p, size_t, size_t) { ::operator delete(p); }
void reset() {}
private:
DISALLOW_COPY(NewDeleteProvider);
};
template <size_t Size = 4096 * 10> // 10 pages worth of memory.
struct BufferProvider {
char buffer[Size];
void* next = &buffer;
size_t space = Size;
BufferProvider() {}
void* allocate(size_t s, size_t a) {
void* ret = std::align(s, a, next, space);
if (ret == nullptr) {
#ifndef TEST_HAS_NO_EXCEPTIONS
throw std::bad_alloc();
#else
assert(false);
#endif
}
return ret;
}
void deallocate(void*, size_t, size_t) {}
void reset() {
next = &buffer;
space = Size;
}
private:
DISALLOW_COPY(BufferProvider);
};
using NullResource = TestResourceImp<NullProvider, 0>;
using NewDeleteResource = TestResourceImp<NewDeleteProvider, 0>;
using TestResource = TestResourceImp<BufferProvider<>, 0>;
using TestResource1 = TestResourceImp<BufferProvider<>, 1>;
using TestResource2 = TestResourceImp<BufferProvider<>, 2>;
#endif /* SUPPORT_TEST_MEMORY_RESOURCE_HPP */