This is an archive of the discontinued LLVM Phabricator instance.

Differential D47360

Implement <memory_resource> as a copy of <experimental/memory_resource>.
AbandonedPublic

Authored by • Quuxplusone on May 24 2018, 11:49 PM.

Details

Reviewers
EricWF
mclow.lists
serge-sans-paille
Summary

Depends on D46806 D47109 D47344 D47111 D47358

Even with all the above prep work to make <experimental/memory_resource> look just like <memory_resource>, this is still a huge diff.

Diff Detail

Repository
rCXX libc++

Event Timeline

• Quuxplusone created this revision.May 24 2018, 11:49 PM
Herald added subscribers: cfe-commits, christof. · View Herald TranscriptMay 24 2018, 11:49 PM
• Quuxplusone mentioned this in D47090: Implement C++17 <memory_resource>..May 24 2018, 11:50 PM
• Quuxplusone mentioned this in D46807: Rename test_memory_resource.hpp -> test_experimental_memory_resource.hpp. NFC..
• Quuxplusone added a reviewer: mclow.lists.May 26 2018, 9:48 PM
• Quuxplusone planned changes to this revision.Jun 5 2018, 9:44 PM

Once the dependencies (D47111 and D47358) are merged, I need to update the unit tests in this patch to reflect the unit tests that were committed. Right now, the unit tests in this patch reflect an old, out-of-date snapshot of what had been in those patches a couple weeks ago.

include/__memory_resource_base
54

This should be #include <__tuple>

include/memory_resource
48

This line should be gone.

• Quuxplusone updated this revision to Diff 153883.Jul 3 2018, 2:33 AM

Clean some minor cruft from src/experimental/memory_resource.cpp. (This part is a separate git commit which I could pull-request if you want it separately.)

I wonder if memory_resource needs a key function for its vtable; consider the precedent of D27387. But out-of-lining a trivial destructor just to avoid -Wweak-vtables feels kind of awful.

Experimental and std differ in their implementation of options() because the latter needs to be compileable as -std=c++11 whereas the former gets to use -std=c++14.

Herald added subscribers: ldionne, mgrang, mgorny. · View Herald TranscriptJul 3 2018, 2:33 AM
• Quuxplusone marked 2 inline comments as done.Jul 3 2018, 2:34 AM
• Quuxplusone added a comment.Nov 20 2018, 7:10 AM

@EricWF ping? (and D47344 D47111 D47358)

Herald added subscribers: libcxx-commits, jfb. · View Herald TranscriptNov 20 2018, 7:10 AM
• Quuxplusone updated this revision to Diff 185236.Feb 4 2019, 10:07 PM

Rebased on master. Added to <version> by updating and running the Python script.

Herald added a reviewer: serge-sans-paille. · View Herald TranscriptFeb 4 2019, 10:07 PM
• Quuxplusone updated this revision to Diff 219760.Sep 11 2019, 12:08 PM

Rebased on master.

The previous patch had replaced test/support/test_memory_resource.hpp with the two files test/support/test_experimental_memory_resource.hpp and test/support/test_memory_resource.hpp (and edited all the experimental tests to use the former).

This new patch replaces test/support/test_memory_resource.h with the two files test/support/test_memory_resource.h and test/support/test_std_memory_resource.h (which reduces the diff by leaving the experimental tests untouched in this patch).

• Quuxplusone updated this revision to Diff 219818.Sep 11 2019, 3:33 PM

Oops, fix one last include of an ".hpp" support file which was recently renamed to ".h".

• Quuxplusone mentioned this in D89057: Add the C++17 <memory_resource> header (mono-patch).Oct 8 2020, 10:21 AM
• Quuxplusone abandoned this revision.Nov 2 2020, 3:33 PM

Superseded by D89057.

ldionne mentioned this in rG243da90ea535: [libc++] Add the C++17 <memory_resource> header (mono-patch).Oct 11 2022, 5:41 AM

Revision Contents

PathSize
docs/
2 lines
include/
2 lines
315 lines
14 lines
14 lines
14 lines
17 lines
359 lines
5 lines
19 lines
17 lines
19 lines
17 lines
17 lines
14 lines
2 lines
src/
567 lines
test/
libcxx/
1 line
experimental/
memory/
memory.polymorphic.allocator.class/
memory.polymorphic.allocator.mem/
2 lines
2 lines
memory.resource.adaptor/
memory.resource.adaptor.mem/
2 lines
2 lines
utilities/
utility/
mem.res/
mem.poly.allocator.class/
mem.poly.allocator.mem/
173 lines
44 lines
mem.res.monotonic.buffer/
mem.res.monotonic.buffer.mem/
34 lines
mem.res.pool/
209 lines
std/
experimental/
memory/
memory.polymorphic.allocator.class/
memory.polymorphic.allocator.ctor/
2 lines
2 lines
memory.polymorphic.allocator.eq/
2 lines
2 lines
memory.polymorphic.allocator.mem/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
memory.resource.adaptor/
memory.resource.adaptor.ctor/
2 lines
2 lines
2 lines
memory.resource.adaptor.mem/
2 lines
2 lines
memory.resource.global/
2 lines
memory.resource/
memory.resource.eq/
2 lines
2 lines
memory.resource.public/
2 lines
2 lines
2 lines
2 lines
language.support/
support.limits/
support.limits.general/
58 lines
32 lines
utilities/
utility/
mem.res/
mem.poly.allocator.class/
mem.poly.allocator.ctor/
29 lines
48 lines
50 lines
47 lines
57 lines
mem.poly.allocator.eq/
135 lines
106 lines
mem.poly.allocator.mem/
113 lines
54 lines
139 lines
134 lines
140 lines
154 lines
141 lines
190 lines
63 lines
53 lines
58 lines
54 lines
mem.res.aliases/
35 lines
35 lines
35 lines
30 lines
67 lines
55 lines
65 lines
73 lines
36 lines
85 lines
83 lines
35 lines
mem.res.global/
75 lines
103 lines
117 lines
mem.res.monotonic.buffer/
mem.res.monotonic.buffer.ctor/
28 lines
44 lines
38 lines
mem.res.monotonic.buffer.mem/
56 lines
75 lines
55 lines
56 lines
45 lines
54 lines
48 lines
50 lines
61 lines
mem.res.pool/
mem.res.pool.ctor/
46 lines
40 lines
40 lines
mem.res.pool.mem/
70 lines
50 lines
54 lines
53 lines
109 lines
50 lines
54 lines
53 lines
109 lines
mem.res/
25 lines
mem.res.eq/
76 lines
75 lines
mem.res.private/
27 lines
47 lines
mem.res.public/
89 lines
74 lines
59 lines
93 lines
support/
171 lines
16 lines
2 lines
utils/
3 lines

Diff 185236

docs/FeatureTestMacroTable.rst

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines.. table:: Current Status
``__cpp_lib_logical_traits`` ``201510L`` ``__cpp_lib_logical_traits`` ``201510L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_make_from_tuple`` ``201606L`` ``__cpp_lib_make_from_tuple`` ``201606L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_map_try_emplace`` ``201411L`` ``__cpp_lib_map_try_emplace`` ``201411L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_math_special_functions`` *unimplemented* ``__cpp_lib_math_special_functions`` *unimplemented*
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_memory_resource`` *unimplemented* ``__cpp_lib_memory_resource`` ``201603L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_node_extract`` ``201606L`` ``__cpp_lib_node_extract`` ``201606L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_nonmember_container_access`` ``201411L`` ``__cpp_lib_nonmember_container_access`` ``201411L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_not_fn`` ``201603L`` ``__cpp_lib_not_fn`` ``201603L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_optional`` ``201606L`` ``__cpp_lib_optional`` ``201606L``
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

include/CMakeLists.txt

set(files set(files
__bit_reference __bit_reference
__bsd_locale_defaults.h __bsd_locale_defaults.h
__bsd_locale_fallbacks.h __bsd_locale_fallbacks.h
__errc __errc
__debug __debug
__functional_03 __functional_03
__functional_base __functional_base
__functional_base_03 __functional_base_03
__hash_table __hash_table
__libcpp_version __libcpp_version
__locale __locale
__memory_resource_base
__mutex_base __mutex_base
__node_handle __node_handle
__nullptr __nullptr
__split_buffer __split_buffer
__sso_allocator __sso_allocator
__std_stream __std_stream
__string __string
__threading_support __threading_support
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Linesset(files
limits limits
limits.h limits.h
list list
locale locale
locale.h locale.h
map map
math.h math.h
memory memory
memory_resource
module.modulemap module.modulemap
mutex mutex
new new
numeric numeric
optional optional
ostream ostream
queue queue
random random
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

include/__memory_resource_base

  • This file was added.
// -*- C++ -*-
//===------------------------ memory_resource -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___MEMORY_RESOURCE_BASE
#define _LIBCPP___MEMORY_RESOURCE_BASE
#ifndef _LIBCPP_CXX03_LANG
/**
memory_resource synopsis
// C++17
namespace std {
namespace pmr {
class memory_resource;
bool operator==(const memory_resource& a,
const memory_resource& b) noexcept;
bool operator!=(const memory_resource& a,
const memory_resource& b) noexcept;
template <class Tp> class polymorphic_allocator;
template <class T1, class T2>
bool operator==(const polymorphic_allocator<T1>& a,
const polymorphic_allocator<T2>& b) noexcept;
template <class T1, class T2>
bool operator!=(const polymorphic_allocator<T1>& a,
const polymorphic_allocator<T2>& b) noexcept;
// Global memory resources
memory_resource* set_default_resource(memory_resource* r) noexcept;
memory_resource* get_default_resource() noexcept;
} // namespace pmr
} // namespace std
*/
#include <__config>
#include <__functional_base>
#include <limits>
#include <memory>
#include <new>
#include <stdexcept>
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

This should be #include <__tuple>

Quuxplusone: This should be `#include <__tuple>`
#include <tuple>
#include <type_traits>
#include <utility>
#include <cstddef>
#include <cstdlib>
#include <__debug>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
// 23.12.2, mem.res.class
class _LIBCPP_TYPE_VIS memory_resource
{
static const size_t __max_align = alignof(max_align_t);
// 23.12.2.1, mem.res.public
public:
virtual ~memory_resource() = default;
_LIBCPP_INLINE_VISIBILITY
void* allocate(size_t __bytes, size_t __align = __max_align)
{ return do_allocate(__bytes, __align); }
_LIBCPP_INLINE_VISIBILITY
void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
{ do_deallocate(__p, __bytes, __align); }
_LIBCPP_INLINE_VISIBILITY
bool is_equal(memory_resource const & __other) const _NOEXCEPT
{ return do_is_equal(__other); }
// 23.12.2.2, mem.res.private
private:
virtual void* do_allocate(size_t, size_t) = 0;
virtual void do_deallocate(void*, size_t, size_t) = 0;
virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
};
// 23.12.2.3, mem.res.eq
inline _LIBCPP_INLINE_VISIBILITY
bool operator==(memory_resource const & __lhs,
memory_resource const & __rhs) _NOEXCEPT
{
return &__lhs == &__rhs || __lhs.is_equal(__rhs);
}
inline _LIBCPP_INLINE_VISIBILITY
bool operator!=(memory_resource const & __lhs,
memory_resource const & __rhs) _NOEXCEPT
{
return !(__lhs == __rhs);
}
// 23.12.4, mem.res.global
_LIBCPP_FUNC_VIS
memory_resource * get_default_resource() _NOEXCEPT;
_LIBCPP_FUNC_VIS
memory_resource * set_default_resource(memory_resource *) _NOEXCEPT;
// 23.12.3, mem.poly.allocator.class
template <class _ValueType>
class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
{
public:
typedef _ValueType value_type;
// 23.12.3.1, mem.poly.allocator.ctor
_LIBCPP_INLINE_VISIBILITY
polymorphic_allocator() _NOEXCEPT
: __res_(_VSTD::pmr::get_default_resource())
{}
_LIBCPP_INLINE_VISIBILITY
polymorphic_allocator(memory_resource * __r) _NOEXCEPT
: __res_(__r)
{}
polymorphic_allocator(polymorphic_allocator const &) = default;
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
: __res_(__other.resource())
{}
polymorphic_allocator &
operator=(polymorphic_allocator const &) = delete;
// 23.12.3.2, mem.poly.allocator.mem
_LIBCPP_INLINE_VISIBILITY
_ValueType* allocate(size_t __n) {
if (__n > __max_size()) {
__throw_length_error(
"std::pmr::polymorphic_allocator<T>::allocate(size_t n)"
" 'n' exceeds maximum supported size");
}
return static_cast<_ValueType*>(
__res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
);
}
_LIBCPP_INLINE_VISIBILITY
void deallocate(_ValueType * __p, size_t __n) {
_LIBCPP_ASSERT(__n <= __max_size(),
"deallocate called for size which exceeds max_size()");
__res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
}
template <class _Tp, class ..._Ts>
_LIBCPP_INLINE_VISIBILITY
void construct(_Tp* __p, _Ts &&... __args)
{
_VSTD::__user_alloc_construct_impl(
typename __uses_alloc_ctor<_Tp, polymorphic_allocator&, _Ts...>::type(),
__p, *this, _VSTD::forward<_Ts>(__args)...
);
}
template <class _T1, class _T2, class ..._Args1, class ..._Args2>
_LIBCPP_INLINE_VISIBILITY
void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
tuple<_Args1...> __x, tuple<_Args2...> __y)
{
::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
, __transform_tuple(
typename __uses_alloc_ctor<
_T1, polymorphic_allocator&, _Args1...
>::type()
, _VSTD::move(__x)
, typename __make_tuple_indices<sizeof...(_Args1)>::type{}
)
, __transform_tuple(
typename __uses_alloc_ctor<
_T2, polymorphic_allocator&, _Args2...
>::type()
, _VSTD::move(__y)
, typename __make_tuple_indices<sizeof...(_Args2)>::type{}
)
);
}
template <class _T1, class _T2>
_LIBCPP_INLINE_VISIBILITY
void construct(pair<_T1, _T2>* __p) {
construct(__p, piecewise_construct, tuple<>(), tuple<>());
}
template <class _T1, class _T2, class _Up, class _Vp>
_LIBCPP_INLINE_VISIBILITY
void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
construct(__p, piecewise_construct
, _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
, _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
}
template <class _T1, class _T2, class _U1, class _U2>
_LIBCPP_INLINE_VISIBILITY
void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
construct(__p, piecewise_construct
, _VSTD::forward_as_tuple(__pr.first)
, _VSTD::forward_as_tuple(__pr.second));
}
template <class _T1, class _T2, class _U1, class _U2>
_LIBCPP_INLINE_VISIBILITY
void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
construct(__p, piecewise_construct
, _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
, _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
void destroy(_Tp * __p)
{ __p->~_Tp(); }
_LIBCPP_INLINE_VISIBILITY
polymorphic_allocator
select_on_container_copy_construction() const _NOEXCEPT
{ return polymorphic_allocator(); }
_LIBCPP_INLINE_VISIBILITY
memory_resource * resource() const _NOEXCEPT
{ return __res_; }
private:
template <class ..._Args, size_t ..._Idx>
_LIBCPP_INLINE_VISIBILITY
tuple<_Args&&...>
__transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
__tuple_indices<_Idx...>)
{
return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
}
template <class ..._Args, size_t ..._Idx>
_LIBCPP_INLINE_VISIBILITY
tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
__transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
__tuple_indices<_Idx...>)
{
using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
return _Tup(allocator_arg, *this,
_VSTD::get<_Idx>(_VSTD::move(__t))...);
}
template <class ..._Args, size_t ..._Idx>
_LIBCPP_INLINE_VISIBILITY
tuple<_Args&&..., polymorphic_allocator&>
__transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
__tuple_indices<_Idx...>)
{
using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this);
}
_LIBCPP_INLINE_VISIBILITY
size_t __max_size() const _NOEXCEPT
{ return numeric_limits<size_t>::max() / sizeof(value_type); }
memory_resource * __res_;
};
// 23.12.3.3, mem.poly.allocator.eq
template <class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY
bool operator==(polymorphic_allocator<_Tp> const & __lhs,
polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
{
return *__lhs.resource() == *__rhs.resource();
}
template <class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY
bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
{
return !(__lhs == __rhs);
}
} // namespace pmr
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif /* _LIBCPP_CXX03_LANG */
#endif /* _LIBCPP___MEMORY_RESOURCE_BASE */

include/deque

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Lines
#include <__split_buffer> #include <__split_buffer>
#include <type_traits> #include <type_traits>
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include <algorithm> #include <algorithm>
#include <stdexcept> #include <stdexcept>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) void erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred)
{ __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); } { __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _ValueT>
using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_DEQUE #endif // _LIBCPP_DEQUE
Context not available.

include/forward_list

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <initializer_list> #include <initializer_list>
#include <memory> #include <memory>
#include <limits> #include <limits>
#include <iterator> #include <iterator>
#include <algorithm> #include <algorithm>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 1,563 Lines • ▼ Show 20 Lines
template <class _Tp, class _Allocator, class _Up> template <class _Tp, class _Allocator, class _Up>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) void erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v)
{ _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); } { _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _ValueT>
using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_FORWARD_LIST #endif // _LIBCPP_FORWARD_LIST

include/list

Show First 20 Lines • Show All 183 Lines • ▼ Show 20 Lines
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include <algorithm> #include <algorithm>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#include <__debug> #include <__debug>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
template <class _Tp, class _Allocator, class _Up> template <class _Tp, class _Allocator, class _Up>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void erase(list<_Tp, _Allocator>& __c, const _Up& __v) void erase(list<_Tp, _Allocator>& __c, const _Up& __v)
{ _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); } { _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _ValueT>
using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_LIST #endif // _LIBCPP_LIST
Context not available.

include/map

Show First 20 Lines • Show All 480 Lines • ▼ Show 20 Lines
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <utility> #include <utility>
#include <functional> #include <functional>
#include <initializer_list> #include <initializer_list>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Key, class _CP, class _Compare, template <class _Key, class _CP, class _Compare,
bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value> bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
▲ Show 20 Lines • Show All 1,672 Lines • ▼ Show 20 Lines
template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate> template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) void erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred)
{ __libcpp_erase_if_container(__c, __pred); } { __libcpp_erase_if_container(__c, __pred); }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _KeyT, class _ValueT, class _CompareT = _VSTD::less<_KeyT>>
using map = _VSTD::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
template <class _KeyT, class _ValueT, class _CompareT = _VSTD::less<_KeyT>>
using multimap = _VSTD::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
#endif // _LIBCPP_MAP #endif // _LIBCPP_MAP

include/memory_resource

  • This file was added.
// -*- C++ -*-
//===------------------------ memory_resource -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_MEMORY_RESOURCE
#define _LIBCPP_MEMORY_RESOURCE
#ifndef _LIBCPP_CXX03_LANG
/**
memory_resource synopsis
// C++17
namespace std {
namespace pmr {
// Global memory resources
memory_resource* new_delete_resource() noexcept;
memory_resource* null_memory_resource() noexcept;
// Pool resource classes
struct pool_options;
class synchronized_pool_resource;
class unsynchronized_pool_resource;
class monotonic_buffer_resource;
} // namespace pmr
} // namespace std
*/
#include <__config>
#include <__functional_base>
#include <__memory_resource_base>
#include <limits>
#include <memory>
#if !defined(_LIBCPP_HAS_NO_THREADS)
#include <mutex>
#endif
#include <new>
#include <stdexcept>
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

This line should be gone.

Quuxplusone: This line should be gone.
#include <type_traits>
#include <utility>
#include <cstddef>
#include <cstdlib>
#include <__debug>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
// 23.12.4, mem.res.global
_LIBCPP_FUNC_VIS
memory_resource * new_delete_resource() _NOEXCEPT;
_LIBCPP_FUNC_VIS
memory_resource * null_memory_resource() _NOEXCEPT;
// 23.12.5, mem.res.pool
// 23.12.5.2, mem.res.pool.options
struct _LIBCPP_TYPE_VIS pool_options {
size_t max_blocks_per_chunk = 0;
size_t largest_required_pool_block = 0;
};
// 23.12.5.1, mem.res.pool.overview
class _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource
{
class __fixed_pool;
class __adhoc_pool {
struct __chunk_header;
__chunk_header *__first_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __adhoc_pool() : __first_(nullptr) {}
void __release(memory_resource *__upstream);
void *__do_allocate(memory_resource *__upstream,
size_t __bytes, size_t __align);
void __do_deallocate(memory_resource *__upstream,
void *__p, size_t __bytes, size_t __align);
};
static const size_t __min_blocks_per_chunk = 16;
static const size_t __min_bytes_per_chunk = 1024;
static const size_t __max_blocks_per_chunk = (size_t(1) << 20);
static const size_t __max_bytes_per_chunk = (size_t(1) << 30);
static const int __log2_smallest_block_size = 3;
static const size_t __smallest_block_size = 8;
static const size_t __default_largest_block_size = (size_t(1) << 20);
static const size_t __max_largest_block_size = (size_t(1) << 30);
size_t __pool_block_size(int __i) const;
int __log2_pool_block_size(int __i) const;
int __pool_index(size_t __bytes, size_t __align) const;
public:
unsynchronized_pool_resource(const pool_options& __opts,
memory_resource* __upstream);
_LIBCPP_INLINE_VISIBILITY
unsynchronized_pool_resource()
: unsynchronized_pool_resource(pool_options(), get_default_resource()) {}
_LIBCPP_INLINE_VISIBILITY
explicit unsynchronized_pool_resource(memory_resource* __upstream)
: unsynchronized_pool_resource(pool_options(), __upstream) {}
_LIBCPP_INLINE_VISIBILITY
explicit unsynchronized_pool_resource(const pool_options& __opts)
: unsynchronized_pool_resource(__opts, get_default_resource()) {}
unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
_LIBCPP_INLINE_VISIBILITY
~unsynchronized_pool_resource() override
{ release(); }
unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete;
void release();
_LIBCPP_INLINE_VISIBILITY
memory_resource* upstream_resource() const
{ return __res_; }
pool_options options() const;
protected:
void *do_allocate(size_t __bytes, size_t __align) override; // key function
void do_deallocate(void *__p, size_t __bytes, size_t __align) override;
_LIBCPP_INLINE_VISIBILITY
bool do_is_equal(const memory_resource& __other) const _NOEXCEPT override
{ return &__other == this; }
private:
memory_resource *__res_;
__adhoc_pool __adhoc_pool_;
__fixed_pool *__fixed_pools_;
int __num_fixed_pools_;
uint32_t __options_max_blocks_per_chunk_;
};
class _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource
{
public:
_LIBCPP_INLINE_VISIBILITY
synchronized_pool_resource(const pool_options& __opts, memory_resource *__upstream)
: __unsync_(__opts, __upstream) {}
_LIBCPP_INLINE_VISIBILITY
synchronized_pool_resource()
: synchronized_pool_resource(pool_options(), get_default_resource()) {}
_LIBCPP_INLINE_VISIBILITY
explicit synchronized_pool_resource(memory_resource *__upstream)
: synchronized_pool_resource(pool_options(), __upstream) {}
_LIBCPP_INLINE_VISIBILITY
explicit synchronized_pool_resource(const pool_options& __opts)
: synchronized_pool_resource(__opts, get_default_resource()) {}
synchronized_pool_resource(const synchronized_pool_resource&) = delete;
~synchronized_pool_resource() override = default;
synchronized_pool_resource& operator=(const synchronized_pool_resource&) = delete;
_LIBCPP_INLINE_VISIBILITY
void release() {
#if !defined(_LIBCPP_HAS_NO_THREADS)
unique_lock<mutex> __lk(__mut_);
#endif
__unsync_.release();
}
_LIBCPP_INLINE_VISIBILITY
memory_resource* upstream_resource() const
{ return __unsync_.upstream_resource(); }
_LIBCPP_INLINE_VISIBILITY
pool_options options() const
{ return __unsync_.options(); }
protected:
_LIBCPP_INLINE_VISIBILITY
void* do_allocate(size_t __bytes, size_t __align) override {
#if !defined(_LIBCPP_HAS_NO_THREADS)
unique_lock<mutex> __lk(__mut_);
#endif
return __unsync_.allocate(__bytes, __align);
}
_LIBCPP_INLINE_VISIBILITY
void do_deallocate(void *__p, size_t __bytes, size_t __align) override {
#if !defined(_LIBCPP_HAS_NO_THREADS)
unique_lock<mutex> __lk(__mut_);
#endif
return __unsync_.deallocate(__p, __bytes, __align);
}
bool do_is_equal(const memory_resource& __other) const _NOEXCEPT override; // key function
private:
#if !defined(_LIBCPP_HAS_NO_THREADS)
mutex __mut_;
#endif
unsynchronized_pool_resource __unsync_;
};
// 23.12.6, mem.res.monotonic.buffer
class _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource
{
static const size_t __default_buffer_capacity = 1024;
static const size_t __default_buffer_alignment = 16;
struct __chunk_header {
__chunk_header *__next_;
char *__start_;
char *__cur_;
size_t __align_;
size_t __allocation_size() {
return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this);
}
void *__try_allocate_from_chunk(size_t, size_t);
};
struct __initial_header {
char *__start_;
char *__cur_;
union {
char *__end_;
size_t __size_;
};
void *__try_allocate_from_chunk(size_t, size_t);
};
public:
_LIBCPP_INLINE_VISIBILITY
monotonic_buffer_resource()
: monotonic_buffer_resource(
nullptr, __default_buffer_capacity, get_default_resource()) {}
_LIBCPP_INLINE_VISIBILITY
explicit monotonic_buffer_resource(size_t __initial_size)
: monotonic_buffer_resource(
nullptr, __initial_size, get_default_resource()) {}
_LIBCPP_INLINE_VISIBILITY
monotonic_buffer_resource(void *__buffer, size_t __buffer_size)
: monotonic_buffer_resource(
__buffer, __buffer_size, get_default_resource()) {}
_LIBCPP_INLINE_VISIBILITY
explicit monotonic_buffer_resource(memory_resource *__upstream)
: monotonic_buffer_resource(
nullptr, __default_buffer_capacity, __upstream) {}
_LIBCPP_INLINE_VISIBILITY
monotonic_buffer_resource(size_t __initial_size,
memory_resource *__upstream)
: monotonic_buffer_resource(
nullptr, __initial_size, __upstream) {}
_LIBCPP_INLINE_VISIBILITY
monotonic_buffer_resource(void *__buffer, size_t __buffer_size,
memory_resource *__upstream)
: __res_(__upstream)
{
__initial_.__start_ = static_cast<char *>(__buffer);
if (__buffer != nullptr) {
__initial_.__cur_ = static_cast<char *>(__buffer);
__initial_.__end_ = static_cast<char *>(__buffer) + __buffer_size;
} else {
__initial_.__cur_ = nullptr;
__initial_.__size_ = __buffer_size;
}
__chunks_ = nullptr;
}
monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;
_LIBCPP_INLINE_VISIBILITY
~monotonic_buffer_resource() override
{ release(); }
monotonic_buffer_resource& operator=(const monotonic_buffer_resource&) = delete;
_LIBCPP_INLINE_VISIBILITY
void release()
{
__initial_.__cur_ = __initial_.__start_;
while (__chunks_ != nullptr) {
__chunk_header *__next = __chunks_->__next_;
__res_->deallocate(
__chunks_->__start_,
__chunks_->__allocation_size(),
__chunks_->__align_
);
__chunks_ = __next;
}
}
_LIBCPP_INLINE_VISIBILITY
memory_resource* upstream_resource() const
{ return __res_; }
protected:
void *do_allocate(size_t __bytes, size_t __alignment) override; // key function
_LIBCPP_INLINE_VISIBILITY
void do_deallocate(void*, size_t, size_t) override
{}
_LIBCPP_INLINE_VISIBILITY
bool do_is_equal(const memory_resource& __other) const _NOEXCEPT override
{ return this == _VSTD::addressof(__other); }
private:
__initial_header __initial_;
__chunk_header *__chunks_;
memory_resource* __res_;
};
} // namespace pmr
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif /* _LIBCPP_CXX03_LANG */
#endif /* _LIBCPP_MEMORY_RESOURCE */

include/module.modulemap

Show First 20 Lines • Show All 343 Lines • ▼ Show 20 Lines module map {
header "map" header "map"
export initializer_list export initializer_list
export * export *
} }
module memory { module memory {
header "memory" header "memory"
export * export *
} }
module memory_resource {
header "memory_resource"
export *
}
module mutex { module mutex {
header "mutex" header "mutex"
export * export *
} }
module new { module new {
header "new" header "new"
export * export *
} }
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Linesmodule std [system] {
// FIXME: These should be private. // FIXME: These should be private.
module __bit_reference { header "__bit_reference" export * } module __bit_reference { header "__bit_reference" export * }
module __debug { header "__debug" export * } module __debug { header "__debug" export * }
module __errc { header "__errc" export * } module __errc { header "__errc" export * }
module __functional_base { header "__functional_base" export * } module __functional_base { header "__functional_base" export * }
module __hash_table { header "__hash_table" export * } module __hash_table { header "__hash_table" export * }
module __locale { header "__locale" export * } module __locale { header "__locale" export * }
module __memory_resource_base { header "__memory_resource_base" export * }
module __mutex_base { header "__mutex_base" export * } module __mutex_base { header "__mutex_base" export * }
module __split_buffer { header "__split_buffer" export * } module __split_buffer { header "__split_buffer" export * }
module __sso_allocator { header "__sso_allocator" export * } module __sso_allocator { header "__sso_allocator" export * }
module __std_stream { header "__std_stream" export * } module __std_stream { header "__std_stream" export * }
module __string { header "__string" export * } module __string { header "__string" export * }
module __tree { header "__tree" export * } module __tree { header "__tree" export * }
module __tuple { header "__tuple" export * } module __tuple { header "__tuple" export * }
module __undef_macros { header "__undef_macros" export * } module __undef_macros { header "__undef_macros" export * }
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

include/regex

Show First 20 Lines • Show All 764 Lines • ▼ Show 20 Lines
#include <utility> #include <utility>
#include <iterator> #include <iterator>
#include <string> #include <string>
#include <memory> #include <memory>
#include <vector> #include <vector>
#include <deque> #include <deque>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
_VSTD::regex_replace(back_inserter(__r), __s, _VSTD::regex_replace(back_inserter(__r), __s,
__s + char_traits<_CharT>::length(__s), __e, __s + char_traits<_CharT>::length(__s), __e,
__fmt, __flags); __fmt, __flags);
return __r; return __r;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template<class _BidirT>
using match_results = _VSTD::match_results<_BidirT, polymorphic_allocator<_VSTD::sub_match<_BidirT>>>;
using cmatch = match_results<const char*>;
using wcmatch = match_results<const wchar_t*>;
using smatch = match_results<_VSTD::pmr::string::const_iterator>;
using wsmatch = match_results<_VSTD::pmr::wstring::const_iterator>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_REGEX #endif // _LIBCPP_REGEX
Context not available.

include/set

Show First 20 Lines • Show All 421 Lines • ▼ Show 20 Lines
*/ */
#include <__config> #include <__config>
#include <__tree> #include <__tree>
#include <__node_handle> #include <__node_handle>
#include <functional> #include <functional>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Key, class _Compare, class _Allocator> template <class _Key, class _Compare, class _Allocator>
class multiset; class multiset;
▲ Show 20 Lines • Show All 970 Lines • ▼ Show 20 Lines
template <class _Key, class _Compare, class _Allocator, class _Predicate> template <class _Key, class _Compare, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) void erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred)
{ __libcpp_erase_if_container(__c, __pred); } { __libcpp_erase_if_container(__c, __pred); }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _KeyT, class _CompareT = _VSTD::less<_KeyT>>
using set = _VSTD::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
template <class _KeyT, class _CompareT = _VSTD::less<_KeyT>>
using multiset = _VSTD::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
#endif // _LIBCPP_SET #endif // _LIBCPP_SET

include/string

Show First 20 Lines • Show All 515 Lines • ▼ Show 20 Lines
#include <__functional_base> #include <__functional_base>
#include <version> #include <version>
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
#include <cstdint> #include <cstdint>
#endif #endif
#include <__debug> #include <__debug>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
return basic_string<char32_t> (__str, __len); return basic_string<char32_t> (__str, __len);
} }
} }
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template<class _CharT, class _TraitsT = _VSTD::char_traits<_CharT>>
using basic_string = _VSTD::basic_string<_CharT, _TraitsT, polymorphic_allocator<_CharT>>;
using string = basic_string<char>;
using u16string = basic_string<char16_t>;
using u32string = basic_string<char32_t>;
using wstring = basic_string<wchar_t>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_STRING #endif // _LIBCPP_STRING
Context not available.

include/unordered_map

Show First 20 Lines • Show All 405 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <__hash_table> #include <__hash_table>
#include <__node_handle> #include <__node_handle>
#include <functional> #include <functional>
#include <stdexcept> #include <stdexcept>
#include <tuple> #include <tuple>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#include <__debug> #include <__debug>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
▲ Show 20 Lines • Show All 1,869 Lines • ▼ Show 20 Lines
operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _KeyT, class _ValueT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
using unordered_map = _VSTD::unordered_map<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
template <class _KeyT, class _ValueT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
using unordered_multimap = _VSTD::unordered_multimap<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<_VSTD::pair<const _KeyT, _ValueT>>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
#endif // _LIBCPP_UNORDERED_MAP #endif // _LIBCPP_UNORDERED_MAP

include/unordered_set

Show First 20 Lines • Show All 360 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <__hash_table> #include <__hash_table>
#include <__node_handle> #include <__node_handle>
#include <functional> #include <functional>
#include <version> #include <version>
#include <__debug> #include <__debug>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Value, class _Hash, class _Pred, class _Alloc> template <class _Value, class _Hash, class _Pred, class _Alloc>
class unordered_multiset; class unordered_multiset;
▲ Show 20 Lines • Show All 1,169 Lines • ▼ Show 20 Lines
operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _KeyT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
using unordered_set = _VSTD::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
template <class _KeyT, class _HashT = _VSTD::hash<_KeyT>, class _PredT = _VSTD::equal_to<_KeyT>>
using unordered_multiset = _VSTD::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
#endif // _LIBCPP_UNORDERED_SET #endif // _LIBCPP_UNORDERED_SET

include/vector

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Lines
#include <algorithm> #include <algorithm>
#include <cstring> #include <cstring>
#include <version> #include <version>
#include <__split_buffer> #include <__split_buffer>
#include <__functional_base> #include <__functional_base>
#include <__debug> #include <__debug>
#if _LIBCPP_STD_VER > 14
#include <__memory_resource_base>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
template <class _Tp, class _Allocator, class _Predicate> template <class _Tp, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) void erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred)
{ __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); } { __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr
{
template <class _ValueT>
using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>;
}
_LIBCPP_END_NAMESPACE_STD
#endif
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_VECTOR #endif // _LIBCPP_VECTOR
Context not available.

include/version

Show First 20 Lines • Show All 176 Lines • ▼ Show 20 Lines
# endif # endif
# define __cpp_lib_is_invocable 201703L # define __cpp_lib_is_invocable 201703L
# define __cpp_lib_is_swappable 201603L # define __cpp_lib_is_swappable 201603L
# define __cpp_lib_launder 201606L # define __cpp_lib_launder 201606L
# define __cpp_lib_logical_traits 201510L # define __cpp_lib_logical_traits 201510L
# define __cpp_lib_make_from_tuple 201606L # define __cpp_lib_make_from_tuple 201606L
# define __cpp_lib_map_try_emplace 201411L # define __cpp_lib_map_try_emplace 201411L
// # define __cpp_lib_math_special_functions 201603L // # define __cpp_lib_math_special_functions 201603L
// # define __cpp_lib_memory_resource 201603L # define __cpp_lib_memory_resource 201603L
# define __cpp_lib_node_extract 201606L # define __cpp_lib_node_extract 201606L
# define __cpp_lib_nonmember_container_access 201411L # define __cpp_lib_nonmember_container_access 201411L
# define __cpp_lib_not_fn 201603L # define __cpp_lib_not_fn 201603L
# define __cpp_lib_optional 201606L # define __cpp_lib_optional 201606L
// # define __cpp_lib_parallel_algorithm 201603L // # define __cpp_lib_parallel_algorithm 201603L
# define __cpp_lib_raw_memory_algorithms 201606L # define __cpp_lib_raw_memory_algorithms 201606L
# define __cpp_lib_sample 201603L # define __cpp_lib_sample 201603L
# define __cpp_lib_scoped_lock 201703L # define __cpp_lib_scoped_lock 201703L
Show All 38 Lines

src/memory_resource.cpp

  • This file was added.
//===------------------------ memory_resource.cpp -------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "memory_resource"
#include "memory"
#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
#include "atomic"
#endif
#if !defined(_LIBCPP_HAS_NO_THREADS)
#include "mutex"
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr {
// memory_resource
//memory_resource::~memory_resource() {}
// new_delete_resource()
#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
static bool is_aligned_to(void *ptr, size_t align)
{
void *p2 = ptr;
size_t space = 1;
void *result = _VSTD::align(align, 1, p2, space);
return (result == ptr);
}
#endif
class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp
: public memory_resource
{
void *do_allocate(size_t bytes, size_t align) override
{
#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
return _VSTD::__libcpp_allocate(bytes, align);
#else
if (bytes == 0)
bytes = 1;
void *result = _VSTD::__libcpp_allocate(bytes, align);
if (!is_aligned_to(result, align)) {
_VSTD::__libcpp_deallocate(result, bytes, align);
__throw_bad_alloc();
}
return result;
#endif
}
void do_deallocate(void *p, size_t bytes, size_t align) override
{ _VSTD::__libcpp_deallocate(p, bytes, align); }
bool do_is_equal(const memory_resource& other) const _NOEXCEPT override
{ return &other == this; }
};
// null_memory_resource()
class _LIBCPP_TYPE_VIS __null_memory_resource_imp
: public memory_resource
{
void *do_allocate(size_t, size_t) override { __throw_bad_alloc(); }
void do_deallocate(void *, size_t, size_t) override {}
bool do_is_equal(const memory_resource& other) const _NOEXCEPT override
{ return &other == this; }
};
namespace {
union ResourceInitHelper {
struct {
__new_delete_memory_resource_imp new_delete_res;
__null_memory_resource_imp null_res;
} resources;
char dummy;
_LIBCPP_CONSTEXPR_AFTER_CXX11 ResourceInitHelper() : resources() {}
~ResourceInitHelper() {}
};
// When compiled in C++14 this initialization should be a constant expression.
// Only in C++11 is "init_priority" needed to ensure initialization order.
#if _LIBCPP_STD_VER > 11
_LIBCPP_SAFE_STATIC
#endif
ResourceInitHelper res_init __attribute__((init_priority (101)));
} // end namespace
memory_resource * new_delete_resource() _NOEXCEPT {
return &res_init.resources.new_delete_res;
}
memory_resource * null_memory_resource() _NOEXCEPT {
return &res_init.resources.null_res;
}
// default_memory_resource()
static memory_resource *
__default_memory_resource(bool set = false, memory_resource * new_res = nullptr) _NOEXCEPT
{
#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
_LIBCPP_SAFE_STATIC static atomic<memory_resource*> __res =
ATOMIC_VAR_INIT(&res_init.resources.new_delete_res);
if (set) {
new_res = new_res ? new_res : new_delete_resource();
// TODO: Can a weaker ordering be used?
return _VSTD::atomic_exchange_explicit(
&__res, new_res, memory_order::memory_order_acq_rel);
}
else {
return _VSTD::atomic_load_explicit(
&__res, memory_order::memory_order_acquire);
}
#elif !defined(_LIBCPP_HAS_NO_THREADS)
_LIBCPP_SAFE_STATIC static memory_resource * res = &res_init.resources.new_delete_res;
static mutex res_lock;
if (set) {
new_res = new_res ? new_res : new_delete_resource();
lock_guard<mutex> guard(res_lock);
memory_resource * old_res = res;
res = new_res;
return old_res;
} else {
lock_guard<mutex> guard(res_lock);
return res;
}
#else
_LIBCPP_SAFE_STATIC static memory_resource* res = &res_init.resources.new_delete_res;
if (set) {
new_res = new_res ? new_res : new_delete_resource();
memory_resource * old_res = res;
res = new_res;
return old_res;
} else {
return res;
}
#endif
}
memory_resource * get_default_resource() _NOEXCEPT
{
return __default_memory_resource();
}
memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT
{
return __default_memory_resource(true, __new_res);
}
// 23.12.5, mem.res.pool
static size_t roundup(size_t count, size_t alignment)
{
size_t mask = alignment - 1;
return (count + mask) & ~mask;
}
struct unsynchronized_pool_resource::__adhoc_pool::__chunk_header {
__chunk_header *__next_;
char *__start_;
size_t __align_;
size_t __allocation_size() {
return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this);
}
};
void unsynchronized_pool_resource::__adhoc_pool::__release(
memory_resource *upstream)
{
while (__first_ != nullptr) {
__chunk_header *next = __first_->__next_;
upstream->deallocate(__first_->__start_, __first_->__allocation_size(),
__first_->__align_);
__first_ = next;
}
}
void *unsynchronized_pool_resource::__adhoc_pool::__do_allocate(
memory_resource *upstream, size_t bytes, size_t align)
{
const size_t header_size = sizeof(__chunk_header);
const size_t header_align = alignof(__chunk_header);
if (align < header_align)
align = header_align;
size_t aligned_capacity = roundup(bytes, header_align) + header_size;
void *result = upstream->allocate(aligned_capacity, align);
__chunk_header *h =
(__chunk_header *)((char *)result + aligned_capacity - header_size);
h->__next_ = __first_;
h->__start_ = (char *)result;
h->__align_ = align;
__first_ = h;
return result;
}
void unsynchronized_pool_resource::__adhoc_pool::__do_deallocate(
memory_resource *upstream, void *p, size_t bytes, size_t align)
{
_LIBCPP_ASSERT(__first_ != nullptr, "deallocating a block that was not allocated with this allocator");
if (__first_->__start_ == p) {
__chunk_header *next = __first_->__next_;
upstream->deallocate(p, __first_->__allocation_size(), __first_->__align_);
__first_ = next;
} else {
for (__chunk_header *h = __first_; h->__next_ != nullptr; h = h->__next_) {
if (h->__next_->__start_ == p) {
__chunk_header *next = h->__next_->__next_;
upstream->deallocate(p, h->__next_->__allocation_size(),
h->__next_->__align_);
h->__next_ = next;
return;
}
}
_LIBCPP_ASSERT(false, "deallocating a block that was not allocated with this allocator");
}
}
class unsynchronized_pool_resource::__fixed_pool {
struct __chunk_header {
__chunk_header *__next_;
char *__start_;
size_t __align_;
size_t __allocation_size() {
return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this);
}
};
struct __vacancy_header {
__vacancy_header *__next_vacancy_;
};
__chunk_header *__first_chunk_ = nullptr;
__vacancy_header *__first_vacancy_ = nullptr;
public:
explicit __fixed_pool() = default;
void __release(memory_resource *upstream)
{
__first_vacancy_ = nullptr;
while (__first_chunk_ != nullptr) {
__chunk_header *next = __first_chunk_->__next_;
upstream->deallocate(__first_chunk_->__start_,
__first_chunk_->__allocation_size(), __first_chunk_->__align_);
__first_chunk_ = next;
}
}
void *__try_allocate_from_vacancies()
{
if (__first_vacancy_ != nullptr) {
void *result = __first_vacancy_;
__first_vacancy_ = __first_vacancy_->__next_vacancy_;
return result;
}
return nullptr;
}
void *__allocate_in_new_chunk(
memory_resource *upstream, size_t block_size, size_t chunk_size)
{
_LIBCPP_ASSERT(chunk_size % block_size == 0, "");
static_assert(__default_alignment >= alignof(std::max_align_t), "");
static_assert(__default_alignment >= alignof(__chunk_header), "");
static_assert(__default_alignment >= alignof(__vacancy_header), "");
const size_t header_size = sizeof(__chunk_header);
const size_t header_align = alignof(__chunk_header);
size_t aligned_capacity = roundup(chunk_size, header_align) + header_size;
void *result = upstream->allocate(aligned_capacity, __default_alignment);
__chunk_header *h =
(__chunk_header *)((char *)result + aligned_capacity - header_size);
h->__next_ = __first_chunk_;
h->__start_ = (char *)result;
h->__align_ = __default_alignment;
__first_chunk_ = h;
if (chunk_size > block_size) {
__vacancy_header *last_vh = this->__first_vacancy_;
for (size_t i = block_size; i != chunk_size; i += block_size) {
__vacancy_header *vh = (__vacancy_header *)((char *)result + i);
vh->__next_vacancy_ = last_vh;
last_vh = vh;
}
this->__first_vacancy_ = last_vh;
}
return result;
}
void __evacuate(void *p)
{
__vacancy_header *vh = (__vacancy_header *)(p);
vh->__next_vacancy_ = __first_vacancy_;
__first_vacancy_ = vh;
}
size_t __previous_chunk_size_in_bytes() const
{
return __first_chunk_ ? __first_chunk_->__allocation_size() : 0;
}
static const size_t __default_alignment = alignof(max_align_t);
};
size_t unsynchronized_pool_resource::__pool_block_size(int i) const
{
return size_t(1) << __log2_pool_block_size(i);
}
int unsynchronized_pool_resource::__log2_pool_block_size(int i) const
{
return (i + __log2_smallest_block_size);
}
int unsynchronized_pool_resource::__pool_index(size_t bytes, size_t align) const
{
if (align > alignof(std::max_align_t) || bytes > (size_t(1) << __num_fixed_pools_))
return __num_fixed_pools_;
else {
int i = 0;
bytes = (bytes > align) ? bytes : align;
bytes -= 1;
bytes >>= __log2_smallest_block_size;
while (bytes != 0) {
bytes >>= 1;
i += 1;
}
return i;
}
}
unsynchronized_pool_resource::unsynchronized_pool_resource(
const pool_options& opts, memory_resource* upstream)
: __res_(upstream), __fixed_pools_(nullptr)
{
size_t largest_block_size;
if (opts.largest_required_pool_block == 0)
largest_block_size = __default_largest_block_size;
else if (opts.largest_required_pool_block < __smallest_block_size)
largest_block_size = __smallest_block_size;
else if (opts.largest_required_pool_block > __max_largest_block_size)
largest_block_size = __max_largest_block_size;
else
largest_block_size = opts.largest_required_pool_block;
if (opts.max_blocks_per_chunk == 0)
__options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
else if (opts.max_blocks_per_chunk < __min_blocks_per_chunk)
__options_max_blocks_per_chunk_ = __min_blocks_per_chunk;
else if (opts.max_blocks_per_chunk > __max_blocks_per_chunk)
__options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
else
__options_max_blocks_per_chunk_ = opts.max_blocks_per_chunk;
__num_fixed_pools_ = 1;
size_t capacity = __smallest_block_size;
while (capacity < largest_block_size) {
capacity <<= 1;
__num_fixed_pools_ += 1;
}
}
pool_options unsynchronized_pool_resource::options() const
{
pool_options p;
p.max_blocks_per_chunk = __options_max_blocks_per_chunk_;
p.largest_required_pool_block = __pool_block_size(__num_fixed_pools_ - 1);
return p;
}
void unsynchronized_pool_resource::release()
{
__adhoc_pool_.__release(__res_);
if (__fixed_pools_ != nullptr) {
const int n = __num_fixed_pools_;
for (int i=0; i < n; ++i)
__fixed_pools_[i].__release(__res_);
__res_->deallocate(__fixed_pools_,
__num_fixed_pools_ * sizeof(__fixed_pool), alignof(__fixed_pool));
__fixed_pools_ = nullptr;
}
}
void *unsynchronized_pool_resource::do_allocate(size_t bytes, size_t align)
{
// A pointer to allocated storage (6.6.4.4.1) with a size of at least bytes.
// The size and alignment of the allocated memory shall meet the requirements for
// a class derived from memory_resource (23.12).
// If the pool selected for a block of size bytes is unable to satisfy the memory request
// from its own internal data structures, it will call upstream_resource()->allocate()
// to obtain more memory. If bytes is larger than that which the largest pool can handle,
// then memory will be allocated using upstream_resource()->allocate().
int i = __pool_index(bytes, align);
if (i == __num_fixed_pools_)
return __adhoc_pool_.__do_allocate(__res_, bytes, align);
else {
if (__fixed_pools_ == nullptr) {
__fixed_pools_ = (__fixed_pool*)__res_->allocate(
__num_fixed_pools_ * sizeof(__fixed_pool),
alignof(__fixed_pool)
);
__fixed_pool *first = __fixed_pools_;
__fixed_pool *last = __fixed_pools_ + __num_fixed_pools_;
for (__fixed_pool *pool = first; pool != last; ++pool)
::new((void*)pool) __fixed_pool;
}
void *result = __fixed_pools_[i].__try_allocate_from_vacancies();
if (result == nullptr) {
static_assert(
(__max_bytes_per_chunk*5)/4 > __max_bytes_per_chunk,
"unsigned overflow is possible"
);
auto min = [](size_t a, size_t b) { return a < b ? a : b; };
auto max = [](size_t a, size_t b) { return a < b ? b : a; };
size_t prev_chunk_size_in_bytes = __fixed_pools_[i].__previous_chunk_size_in_bytes();
size_t prev_chunk_size_in_blocks = prev_chunk_size_in_bytes >> __log2_pool_block_size(i);
size_t chunk_size_in_blocks;
if (prev_chunk_size_in_blocks == 0) {
size_t min_blocks_per_chunk = max(
__min_bytes_per_chunk >> __log2_pool_block_size(i),
__min_blocks_per_chunk
);
chunk_size_in_blocks = min_blocks_per_chunk;
} else
chunk_size_in_blocks = (prev_chunk_size_in_blocks*5)/4;
size_t max_blocks_per_chunk = min(
(__max_bytes_per_chunk >> __log2_pool_block_size(i)),
min(
__max_blocks_per_chunk,
__options_max_blocks_per_chunk_
)
);
if (chunk_size_in_blocks > max_blocks_per_chunk)
chunk_size_in_blocks = max_blocks_per_chunk;
size_t block_size = __pool_block_size(i);
size_t chunk_size_in_bytes =
(chunk_size_in_blocks << __log2_pool_block_size(i));
result = __fixed_pools_[i].__allocate_in_new_chunk(
__res_, block_size, chunk_size_in_bytes
);
}
return result;
}
}
void unsynchronized_pool_resource::do_deallocate(
void* p, size_t bytes, size_t align)
{
// Returns the memory at p to the pool. It is unspecified if,
// or under what circumstances, this operation will result in
// a call to upstream_resource()->deallocate().
int i = __pool_index(bytes, align);
if (i == __num_fixed_pools_)
return __adhoc_pool_.__do_deallocate(__res_, p, bytes, align);
else {
_LIBCPP_ASSERT(__fixed_pools_ != nullptr, "deallocating a block that was not allocated with this allocator");
__fixed_pools_[i].__evacuate(p);
}
}
bool synchronized_pool_resource::do_is_equal(
const memory_resource& other) const _NOEXCEPT
{
return &other == this;
}
// 23.12.6, mem.res.monotonic.buffer
void *monotonic_buffer_resource::__initial_header::__try_allocate_from_chunk(
size_t bytes, size_t align)
{
if (!__cur_)
return nullptr;
void *new_ptr = static_cast<void*>(__cur_);
size_t new_capacity = (__end_ - __cur_);
void *aligned_ptr = _VSTD::align(align, bytes, new_ptr, new_capacity);
if (aligned_ptr != nullptr)
__cur_ = static_cast<char*>(new_ptr) + bytes;
return aligned_ptr;
}
void *monotonic_buffer_resource::__chunk_header::__try_allocate_from_chunk(
size_t bytes, size_t align)
{
void *new_ptr = static_cast<void*>(__cur_);
size_t new_capacity = (reinterpret_cast<char*>(this) - __cur_);
void *aligned_ptr = _VSTD::align(align, bytes, new_ptr, new_capacity);
if (aligned_ptr != nullptr)
__cur_ = static_cast<char*>(new_ptr) + bytes;
return aligned_ptr;
}
void* monotonic_buffer_resource::do_allocate(size_t bytes, size_t align)
{
const size_t header_size = sizeof(__chunk_header);
const size_t header_align = alignof(__chunk_header);
auto previous_allocation_size = [&]() {
if (__chunks_ != nullptr)
return __chunks_->__allocation_size();
size_t newsize = (__initial_.__start_ != nullptr) ?
(__initial_.__end_ - __initial_.__start_) : __initial_.__size_;
return roundup(newsize, header_align) + header_size;
};
if (void *result = __initial_.__try_allocate_from_chunk(bytes, align))
return result;
if (__chunks_ != nullptr) {
if (void *result = __chunks_->__try_allocate_from_chunk(bytes, align))
return result;
}
// Allocate a brand-new chunk.
if (align < header_align)
align = header_align;
size_t aligned_capacity = roundup(bytes, header_align) + header_size;
size_t previous_capacity = previous_allocation_size();
if (aligned_capacity <= previous_capacity) {
size_t newsize = 2 * (previous_capacity - header_size);
aligned_capacity = roundup(newsize, header_align) + header_size;
}
char *start = (char *)__res_->allocate(aligned_capacity, align);
__chunk_header *header =
(__chunk_header *)(start + aligned_capacity - header_size);
header->__next_ = __chunks_;
header->__start_ = start;
header->__cur_ = start;
header->__align_ = align;
__chunks_ = header;
return __chunks_->__try_allocate_from_chunk(bytes, align);
}
} // namespace pmr
_LIBCPP_END_NAMESPACE_STD

test/libcxx/double_include.sh.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
#include <limits> #include <limits>
#include <limits.h> #include <limits.h>
#include <list> #include <list>
#include <locale> #include <locale>
#include <locale.h> #include <locale.h>
#include <map> #include <map>
#include <math.h> #include <math.h>
#include <memory> #include <memory>
#include <memory_resource>
#ifndef _LIBCPP_HAS_NO_THREADS #ifndef _LIBCPP_HAS_NO_THREADS
#include <mutex> #include <mutex>
#endif #endif
#include <new> #include <new>
#include <numeric> #include <numeric>
#include <optional> #include <optional>
#include <ostream> #include <ostream>
#include <queue> #include <queue>
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

Show All 39 Lines
// 'tuple<Args1...>' and 'tuple<Args2...>'. // 'tuple<Args1...>' and 'tuple<Args2...>'.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class T> template <class T>
struct TestHarness { struct TestHarness {
TestResource R; TestResource R;
ex::memory_resource * M = &R; ex::memory_resource * M = &R;
ex::polymorphic_allocator<T> A = M; ex::polymorphic_allocator<T> A = M;
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/db_deallocate.pass.cpp

Show All 16 Lines
int AssertCount = 0; int AssertCount = 0;
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
#define _LIBCPP_DEBUG 0 #define _LIBCPP_DEBUG 0
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
using Alloc = ex::polymorphic_allocator<int>; using Alloc = ex::polymorphic_allocator<int>;
using Traits = std::allocator_traits<Alloc>; using Traits = std::allocator_traits<Alloc>;
NullResource R; NullResource R;
Show All 10 Lines

test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/db_deallocate.pass.cpp

Show All 16 Lines
int AssertCount = 0; int AssertCount = 0;
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
#define _LIBCPP_DEBUG 0 #define _LIBCPP_DEBUG 0
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
using Alloc = NullAllocator<char>; using Alloc = NullAllocator<char>;
AllocController P; AllocController P;
Show All 13 Lines

test/libcxx/min_max_macros.sh.cpp

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
#include <locale.h> #include <locale.h>
TEST_MACROS(); TEST_MACROS();
#include <map> #include <map>
TEST_MACROS(); TEST_MACROS();
#include <math.h> #include <math.h>
TEST_MACROS(); TEST_MACROS();
#include <memory> #include <memory>
TEST_MACROS(); TEST_MACROS();
#include <memory_resource>
TEST_MACROS();
#ifndef _LIBCPP_HAS_NO_THREADS #ifndef _LIBCPP_HAS_NO_THREADS
#include <mutex> #include <mutex>
TEST_MACROS(); TEST_MACROS();
#endif #endif
#include <new> #include <new>
TEST_MACROS(); TEST_MACROS();
#include <numeric> #include <numeric>
TEST_MACROS(); TEST_MACROS();
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

test/libcxx/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_piecewise_pair.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class U1, class U2, class ...Args1, class ...Args2>
// void polymorphic_allocator<T>::construct(pair<T1, T2>*, piecewise_construct_t
// tuple<Args1...> x, tuple<Args2...>)
// The stardard specifiers a tranformation to uses-allocator construction as
// follows:
// - If uses_allocator_v<T1,memory_resource*> is false and
// is_constructible_v<T,Args1...> is true, then xprime is x.
// - Otherwise, if uses_allocator_v<T1,memory_resource*> is true and
// is_constructible_v<T1,allocator_arg_t,memory_resource*,Args1...> is true,
// then xprime is
// tuple_cat(make_tuple(allocator_arg, this->resource()), std::move(x)).
// - Otherwise, if uses_allocator_v<T1,memory_resource*> is true and
// is_constructible_v<T1,Args1...,memory_resource*> is true, then xprime is
// tuple_cat(std::move(x), make_tuple(this->resource())).
// - Otherwise the program is ill formed.
//
// The use of "xprime = tuple_cat(..., std::move(x), ...)" causes all of the
// objects in 'x' to be copied into 'xprime'. If 'x' contains any types which
// are stored by value this causes an unessary copy to occur. To prevent this
// libc++ changes this call into
// "xprime = forward_as_tuple(..., std::get<Idx>(std::move(x))..., ...)".
// 'xprime' contains references to the values in 'x' instead of copying them.
// This test checks the number of copies incurred to the elements in
// 'tuple<Args1...>' and 'tuple<Args2...>'.
#include <memory_resource>
#include <type_traits>
#include <utility>
#include <tuple>
#include <cassert>
#include <cstdlib>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
template <class T>
struct TestHarness {
TestResource R;
ex::memory_resource * M = &R;
ex::polymorphic_allocator<T> A = M;
bool constructed = false;
T * ptr;
TestHarness() : ptr(A.allocate(1)) {}
template <class ...Args>
void construct(Args&&... args) {
A.construct(ptr, std::forward<Args>(args)...);
constructed = true;
}
~TestHarness() {
if (constructed) A.destroy(ptr);
A.deallocate(ptr, 1);
}
};
struct CountCopies {
int count;
CountCopies() : count(0) {}
CountCopies(CountCopies const& o) : count(o.count + 1) {}
};
struct CountCopiesAllocV1 {
typedef ex::polymorphic_allocator<char> allocator_type;
ex::memory_resource *alloc;
int count;
CountCopiesAllocV1() : alloc(nullptr), count(0) {}
CountCopiesAllocV1(std::allocator_arg_t, allocator_type const& a,
CountCopiesAllocV1 const& o) : alloc(a.resource()), count(o.count + 1)
{}
CountCopiesAllocV1(CountCopiesAllocV1 const& o) : count(o.count + 1) {}
};
struct CountCopiesAllocV2 {
typedef ex::polymorphic_allocator<char> allocator_type;
ex::memory_resource *alloc;
int count;
CountCopiesAllocV2() : alloc(nullptr), count(0) {}
CountCopiesAllocV2(CountCopiesAllocV2 const& o, allocator_type const& a)
: alloc(a.resource()), count(o.count + 1)
{ }
CountCopiesAllocV2(CountCopiesAllocV2 const& o) : count(o.count + 1) {}
};
int main(int, char**)
{
{
using T = CountCopies;
using U = CountCopiesAllocV1;
using P = std::pair<T, U>;
std::tuple<T> t1;
std::tuple<U> t2;
TestHarness<P> h;
h.construct(std::piecewise_construct, t1, t2);
P const& p = *h.ptr;
assert(p.first.count == 2);
assert(p.second.count == 2);
assert(p.second.alloc == h.M);
}
{
using T = CountCopiesAllocV1;
using U = CountCopiesAllocV2;
using P = std::pair<T, U>;
std::tuple<T> t1;
std::tuple<U> t2;
TestHarness<P> h;
h.construct(std::piecewise_construct, std::move(t1), std::move(t2));
P const& p = *h.ptr;
assert(p.first.count == 2);
assert(p.first.alloc == h.M);
assert(p.second.count == 2);
assert(p.second.alloc == h.M);
}
{
using T = CountCopiesAllocV2;
using U = CountCopiesAllocV1;
using P = std::pair<T, U>;
std::tuple<T> t1;
std::tuple<U> t2;
TestHarness<P> h;
h.construct(std::piecewise_construct, std::move(t1), std::move(t2));
P const& p = *h.ptr;
assert(p.first.count == 2);
assert(p.first.alloc == h.M);
assert(p.second.count == 2);
assert(p.second.alloc == h.M);
}
{
using T = CountCopiesAllocV2;
using U = CountCopies;
using P = std::pair<T, U>;
std::tuple<T> t1;
std::tuple<U> t2;
TestHarness<P> h;
h.construct(std::piecewise_construct, t1, t2);
P const& p = *h.ptr;
assert(p.first.count == 2);
assert(p.first.alloc == h.M);
assert(p.second.count == 2);
}
return 0;
}

test/libcxx/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/db_deallocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
int AssertCount = 0;
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (void)::AssertCount++)
#define _LIBCPP_DEBUG 0
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
int main(int, char**)
{
using Alloc = ex::polymorphic_allocator<int>;
using Traits = std::allocator_traits<Alloc>;
NullResource R;
Alloc a(&R);
const std::size_t maxSize = Traits::max_size(a);
a.deallocate(nullptr, maxSize);
assert(AssertCount == 0);
a.deallocate(nullptr, maxSize + 1);
assert(AssertCount == 1);
return 0;
}

test/libcxx/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_in_geometric_progression.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main(int, char**)
{
globalMemCounter.reset();
std::pmr::monotonic_buffer_resource mono;
for (int i=0; i < 100; ++i) {
mono.allocate(1);
assert(globalMemCounter.last_new_size < 1000000000);
mono.release();
assert(globalMemCounter.checkOutstandingNewEq(0));
}
return 0;
}

test/libcxx/utilities/utility/mem.res/mem.res.pool/unsynchronized_buffer.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// struct pool_options
// class unsynchronized_pool_resource
// class synchronized_pool_resource
#include <memory_resource>
#include <cassert>
static void assert_options(const std::pmr::pool_options& actual, const std::pmr::pool_options& expected)
{
assert(actual.max_blocks_per_chunk == expected.max_blocks_per_chunk);
assert(actual.largest_required_pool_block == expected.largest_required_pool_block);
}
void test_pool_options(std::pmr::pool_options initial, std::pmr::pool_options expected)
{
std::pmr::unsynchronized_pool_resource mr(initial, std::pmr::null_memory_resource());
assert_options(mr.options(), expected);
std::pmr::synchronized_pool_resource mr2(initial, std::pmr::null_memory_resource());
assert_options(mr2.options(), expected);
}
int main(int, char**)
{
test_pool_options({0, 0}, {1048576, 1048576});
test_pool_options({0, 1}, {1048576, 8});
test_pool_options({0, 2}, {1048576, 8});
test_pool_options({0, 4}, {1048576, 8});
test_pool_options({0, 8}, {1048576, 8});
test_pool_options({0, 16}, {1048576, 16});
test_pool_options({0, 32}, {1048576, 32});
test_pool_options({0, 1024}, {1048576, 1024});
test_pool_options({0, 1048576}, {1048576, 1048576});
test_pool_options({0, 2097152}, {1048576, 2097152});
test_pool_options({0, 1073741824}, {1048576, 1073741824});
test_pool_options({0, 2147483648}, {1048576, 1073741824});
test_pool_options({0, 8589934592}, {1048576, 1073741824});
test_pool_options({1, 0}, {16, 1048576});
test_pool_options({1, 1}, {16, 8});
test_pool_options({1, 2}, {16, 8});
test_pool_options({1, 4}, {16, 8});
test_pool_options({1, 8}, {16, 8});
test_pool_options({1, 16}, {16, 16});
test_pool_options({1, 32}, {16, 32});
test_pool_options({1, 1024}, {16, 1024});
test_pool_options({1, 1048576}, {16, 1048576});
test_pool_options({1, 2097152}, {16, 2097152});
test_pool_options({1, 1073741824}, {16, 1073741824});
test_pool_options({1, 2147483648}, {16, 1073741824});
test_pool_options({1, 8589934592}, {16, 1073741824});
test_pool_options({2, 0}, {16, 1048576});
test_pool_options({2, 1}, {16, 8});
test_pool_options({2, 2}, {16, 8});
test_pool_options({2, 4}, {16, 8});
test_pool_options({2, 8}, {16, 8});
test_pool_options({2, 16}, {16, 16});
test_pool_options({2, 32}, {16, 32});
test_pool_options({2, 1024}, {16, 1024});
test_pool_options({2, 1048576}, {16, 1048576});
test_pool_options({2, 2097152}, {16, 2097152});
test_pool_options({2, 1073741824}, {16, 1073741824});
test_pool_options({2, 2147483648}, {16, 1073741824});
test_pool_options({2, 8589934592}, {16, 1073741824});
test_pool_options({4, 0}, {16, 1048576});
test_pool_options({4, 1}, {16, 8});
test_pool_options({4, 2}, {16, 8});
test_pool_options({4, 4}, {16, 8});
test_pool_options({4, 8}, {16, 8});
test_pool_options({4, 16}, {16, 16});
test_pool_options({4, 32}, {16, 32});
test_pool_options({4, 1024}, {16, 1024});
test_pool_options({4, 1048576}, {16, 1048576});
test_pool_options({4, 2097152}, {16, 2097152});
test_pool_options({4, 1073741824}, {16, 1073741824});
test_pool_options({4, 2147483648}, {16, 1073741824});
test_pool_options({4, 8589934592}, {16, 1073741824});
test_pool_options({8, 0}, {16, 1048576});
test_pool_options({8, 1}, {16, 8});
test_pool_options({8, 2}, {16, 8});
test_pool_options({8, 4}, {16, 8});
test_pool_options({8, 8}, {16, 8});
test_pool_options({8, 16}, {16, 16});
test_pool_options({8, 32}, {16, 32});
test_pool_options({8, 1024}, {16, 1024});
test_pool_options({8, 1048576}, {16, 1048576});
test_pool_options({8, 2097152}, {16, 2097152});
test_pool_options({8, 1073741824}, {16, 1073741824});
test_pool_options({8, 2147483648}, {16, 1073741824});
test_pool_options({8, 8589934592}, {16, 1073741824});
test_pool_options({16, 0}, {16, 1048576});
test_pool_options({16, 1}, {16, 8});
test_pool_options({16, 2}, {16, 8});
test_pool_options({16, 4}, {16, 8});
test_pool_options({16, 8}, {16, 8});
test_pool_options({16, 16}, {16, 16});
test_pool_options({16, 32}, {16, 32});
test_pool_options({16, 1024}, {16, 1024});
test_pool_options({16, 1048576}, {16, 1048576});
test_pool_options({16, 2097152}, {16, 2097152});
test_pool_options({16, 1073741824}, {16, 1073741824});
test_pool_options({16, 2147483648}, {16, 1073741824});
test_pool_options({16, 8589934592}, {16, 1073741824});
test_pool_options({32, 0}, {32, 1048576});
test_pool_options({32, 1}, {32, 8});
test_pool_options({32, 2}, {32, 8});
test_pool_options({32, 4}, {32, 8});
test_pool_options({32, 8}, {32, 8});
test_pool_options({32, 16}, {32, 16});
test_pool_options({32, 32}, {32, 32});
test_pool_options({32, 1024}, {32, 1024});
test_pool_options({32, 1048576}, {32, 1048576});
test_pool_options({32, 2097152}, {32, 2097152});
test_pool_options({32, 1073741824}, {32, 1073741824});
test_pool_options({32, 2147483648}, {32, 1073741824});
test_pool_options({32, 8589934592}, {32, 1073741824});
test_pool_options({1024, 0}, {1024, 1048576});
test_pool_options({1024, 1}, {1024, 8});
test_pool_options({1024, 2}, {1024, 8});
test_pool_options({1024, 4}, {1024, 8});
test_pool_options({1024, 8}, {1024, 8});
test_pool_options({1024, 16}, {1024, 16});
test_pool_options({1024, 32}, {1024, 32});
test_pool_options({1024, 1024}, {1024, 1024});
test_pool_options({1024, 1048576}, {1024, 1048576});
test_pool_options({1024, 2097152}, {1024, 2097152});
test_pool_options({1024, 1073741824}, {1024, 1073741824});
test_pool_options({1024, 2147483648}, {1024, 1073741824});
test_pool_options({1024, 8589934592}, {1024, 1073741824});
test_pool_options({1048576, 0}, {1048576, 1048576});
test_pool_options({1048576, 1}, {1048576, 8});
test_pool_options({1048576, 2}, {1048576, 8});
test_pool_options({1048576, 4}, {1048576, 8});
test_pool_options({1048576, 8}, {1048576, 8});
test_pool_options({1048576, 16}, {1048576, 16});
test_pool_options({1048576, 32}, {1048576, 32});
test_pool_options({1048576, 1024}, {1048576, 1024});
test_pool_options({1048576, 1048576}, {1048576, 1048576});
test_pool_options({1048576, 2097152}, {1048576, 2097152});
test_pool_options({1048576, 1073741824}, {1048576, 1073741824});
test_pool_options({1048576, 2147483648}, {1048576, 1073741824});
test_pool_options({1048576, 8589934592}, {1048576, 1073741824});
test_pool_options({2097152, 0}, {1048576, 1048576});
test_pool_options({2097152, 1}, {1048576, 8});
test_pool_options({2097152, 2}, {1048576, 8});
test_pool_options({2097152, 4}, {1048576, 8});
test_pool_options({2097152, 8}, {1048576, 8});
test_pool_options({2097152, 16}, {1048576, 16});
test_pool_options({2097152, 32}, {1048576, 32});
test_pool_options({2097152, 1024}, {1048576, 1024});
test_pool_options({2097152, 1048576}, {1048576, 1048576});
test_pool_options({2097152, 2097152}, {1048576, 2097152});
test_pool_options({2097152, 1073741824}, {1048576, 1073741824});
test_pool_options({2097152, 2147483648}, {1048576, 1073741824});
test_pool_options({2097152, 8589934592}, {1048576, 1073741824});
test_pool_options({1073741824, 0}, {1048576, 1048576});
test_pool_options({1073741824, 1}, {1048576, 8});
test_pool_options({1073741824, 2}, {1048576, 8});
test_pool_options({1073741824, 4}, {1048576, 8});
test_pool_options({1073741824, 8}, {1048576, 8});
test_pool_options({1073741824, 16}, {1048576, 16});
test_pool_options({1073741824, 32}, {1048576, 32});
test_pool_options({1073741824, 1024}, {1048576, 1024});
test_pool_options({1073741824, 1048576}, {1048576, 1048576});
test_pool_options({1073741824, 2097152}, {1048576, 2097152});
test_pool_options({1073741824, 1073741824}, {1048576, 1073741824});
test_pool_options({1073741824, 2147483648}, {1048576, 1073741824});
test_pool_options({1073741824, 8589934592}, {1048576, 1073741824});
test_pool_options({2147483648, 0}, {1048576, 1048576});
test_pool_options({2147483648, 1}, {1048576, 8});
test_pool_options({2147483648, 2}, {1048576, 8});
test_pool_options({2147483648, 4}, {1048576, 8});
test_pool_options({2147483648, 8}, {1048576, 8});
test_pool_options({2147483648, 16}, {1048576, 16});
test_pool_options({2147483648, 32}, {1048576, 32});
test_pool_options({2147483648, 1024}, {1048576, 1024});
test_pool_options({2147483648, 1048576}, {1048576, 1048576});
test_pool_options({2147483648, 2097152}, {1048576, 2097152});
test_pool_options({2147483648, 1073741824}, {1048576, 1073741824});
test_pool_options({2147483648, 2147483648}, {1048576, 1073741824});
test_pool_options({2147483648, 8589934592}, {1048576, 1073741824});
test_pool_options({8589934592, 0}, {1048576, 1048576});
test_pool_options({8589934592, 1}, {1048576, 8});
test_pool_options({8589934592, 2}, {1048576, 8});
test_pool_options({8589934592, 4}, {1048576, 8});
test_pool_options({8589934592, 8}, {1048576, 8});
test_pool_options({8589934592, 16}, {1048576, 16});
test_pool_options({8589934592, 32}, {1048576, 32});
test_pool_options({8589934592, 1024}, {1048576, 1024});
test_pool_options({8589934592, 1048576}, {1048576, 1048576});
test_pool_options({8589934592, 2097152}, {1048576, 2097152});
test_pool_options({8589934592, 1073741824}, {1048576, 1073741824});
test_pool_options({8589934592, 2147483648}, {1048576, 1073741824});
test_pool_options({8589934592, 8589934592}, {1048576, 1073741824});
return 0;
}

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp

Show All 13 Lines
// template <class T> class polymorphic_allocator // template <class T> class polymorphic_allocator
// polymorphic_allocator<T>::polymorphic_allocator() noexcept // polymorphic_allocator<T>::polymorphic_allocator() noexcept
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
{ {
static_assert( static_assert(
std::is_nothrow_default_constructible<ex::polymorphic_allocator<void>>::value std::is_nothrow_default_constructible<ex::polymorphic_allocator<void>>::value
Show All 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp

Show All 12 Lines
// template <class T> class polymorphic_allocator // template <class T> class polymorphic_allocator
// polymorphic_allocator<T>::polymorphic_allocator(memory_resource *) // polymorphic_allocator<T>::polymorphic_allocator(memory_resource *)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
{ {
typedef ex::polymorphic_allocator<void> A; typedef ex::polymorphic_allocator<void> A;
static_assert( static_assert(
Show All 17 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp

Show All 16 Lines
// bool operator==( // bool operator==(
// polymorphic_allocator<T> const & // polymorphic_allocator<T> const &
// , polymorphic_allocator<U> const &) noexcept // , polymorphic_allocator<U> const &) noexcept
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef ex::polymorphic_allocator<void> A1; typedef ex::polymorphic_allocator<void> A1;
typedef ex::polymorphic_allocator<int> A2; typedef ex::polymorphic_allocator<int> A2;
// check return types // check return types
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp

Show All 16 Lines
// bool operator!=( // bool operator!=(
// polymorphic_allocator<T> const & // polymorphic_allocator<T> const &
// , polymorphic_allocator<T> const &) noexcept // , polymorphic_allocator<T> const &) noexcept
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef ex::polymorphic_allocator<void> A1; typedef ex::polymorphic_allocator<void> A1;
typedef ex::polymorphic_allocator<int> A2; typedef ex::polymorphic_allocator<int> A2;
// check return types // check return types
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp

Show All 17 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <exception> #include <exception>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <size_t S, size_t Align> template <size_t S, size_t Align>
void testForSizeAndAlign() { void testForSizeAndAlign() {
using T = typename std::aligned_storage<S, Align>::type; using T = typename std::aligned_storage<S, Align>::type;
TestResource R; TestResource R;
ex::polymorphic_allocator<T> a(&R); ex::polymorphic_allocator<T> a(&R);
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

Show All 18 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp" #include "controlled_allocators.hpp"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class UA1, class UA2, class TT, class UU> template <class UA1, class UA2, class TT, class UU>
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp

Show All 18 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp" #include "controlled_allocators.hpp"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp

Show All 18 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp" #include "controlled_allocators.hpp"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class UA1, class UA2, class TT, class UU> template <class UA1, class UA2, class TT, class UU>
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

Show All 19 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp" #include "controlled_allocators.hpp"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class T, class U, class ...TTuple, class ...UTuple> template <class T, class U, class ...TTuple, class ...UTuple>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect, bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp

Show All 16 Lines
// void polymorphic_allocator<T>::construct(U *, Args &&...) // void polymorphic_allocator<T>::construct(U *, Args &&...)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
#include "uses_alloc_types.hpp" #include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp" #include "controlled_allocators.hpp"
#include "test_allocator.h" #include "test_allocator.h"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class T> template <class T>
struct PMATest { struct PMATest {
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp

Show All 13 Lines
// template <class T> class polymorphic_allocator // template <class T> class polymorphic_allocator
// T* polymorphic_allocator<T>::deallocate(T*, size_t size) // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <size_t S, size_t Align> template <size_t S, size_t Align>
void testForSizeAndAlign() { void testForSizeAndAlign() {
using T = typename std::aligned_storage<S, Align>::type; using T = typename std::aligned_storage<S, Align>::type;
TestResource R; TestResource R;
Show All 33 Lines

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp

Show All 11 Lines
// template <class Alloc> class resource_adaptor_imp; // template <class Alloc> class resource_adaptor_imp;
// resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc const &) // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc const &)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef CountingAllocator<char> AllocT; typedef CountingAllocator<char> AllocT;
typedef ex::resource_adaptor<AllocT> R; typedef ex::resource_adaptor<AllocT> R;
{ {
Show All 26 Lines

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp

Show All 11 Lines
// template <class Alloc> class resource_adaptor_imp; // template <class Alloc> class resource_adaptor_imp;
// resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc &&) // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc &&)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef CountingAllocator<char> AllocT; typedef CountingAllocator<char> AllocT;
typedef ex::resource_adaptor<AllocT> R; typedef ex::resource_adaptor<AllocT> R;
{ {
Show All 17 Lines

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp

Show All 13 Lines
// resource_adaptor_imp<Alloc>::resource_adaptor_imp() = default; // resource_adaptor_imp<Alloc>::resource_adaptor_imp() = default;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
{ {
typedef CountingAllocator<char> AllocT; // Not default constructible typedef CountingAllocator<char> AllocT; // Not default constructible
typedef ex::resource_adaptor<AllocT> R; typedef ex::resource_adaptor<AllocT> R;
Show All 11 Lines

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp

Show All 17 Lines
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <memory> #include <memory>
#include <exception> #include <exception>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
template <class Alloc> template <class Alloc>
void check_allocate_deallocate() void check_allocate_deallocate()
{ {
typedef ex::resource_adaptor<Alloc> R1; typedef ex::resource_adaptor<Alloc> R1;
const std::size_t max_align = alignof(std::max_align_t); const std::size_t max_align = alignof(std::max_align_t);
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp

Show All 12 Lines
// template <class Alloc> class resource_adaptor_imp; // template <class Alloc> class resource_adaptor_imp;
// bool do_is_equal(memory_resource const &) const noexcept; // bool do_is_equal(memory_resource const &) const noexcept;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
using std::size_t; using std::size_t;
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
typedef CountingAllocator<char> Alloc1; typedef CountingAllocator<char> Alloc1;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp

Show All 26 Lines
// E) 'set_default_resource(null)' sets the default resource to // E) 'set_default_resource(null)' sets the default resource to
// 'new_delete_resource()'. // 'new_delete_resource()'.
// F) 'get_default_resource' and 'set_default_resource' are noexcept. // F) 'get_default_resource' and 'set_default_resource' are noexcept.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
using namespace std::experimental::pmr; using namespace std::experimental::pmr;
int main(int, char**) { int main(int, char**) {
TestResource R; TestResource R;
{ // Test (A) and (B) { // Test (A) and (B)
memory_resource* p = get_default_resource(); memory_resource* p = get_default_resource();
assert(p != nullptr); assert(p != nullptr);
Show All 32 Lines

test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp

Show All 11 Lines
// bool operator==(memory_resource const &, memory_resource const &) noexcept; // bool operator==(memory_resource const &, memory_resource const &) noexcept;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
// check return types // check return types
{ {
ex::memory_resource const * mr1(nullptr); ex::memory_resource const * mr1(nullptr);
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp

Show All 10 Lines
// <experimental/memory_resource> // <experimental/memory_resource>
// bool operator!=(memory_resource const &, memory_resource const &) noexcept; // bool operator!=(memory_resource const &, memory_resource const &) noexcept;
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
namespace ex = std::experimental::pmr; namespace ex = std::experimental::pmr;
int main(int, char**) int main(int, char**)
{ {
// check return types // check return types
{ {
ex::memory_resource const * mr1(nullptr); ex::memory_resource const * mr1(nullptr);
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp

Show All 21 Lines
// E) If 'do_allocate' throws then 'allocate' propagates that exception. // E) If 'do_allocate' throws then 'allocate' propagates that exception.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
TestResource R(42); TestResource R(42);
auto& P = R.getController(); auto& P = R.getController();
memory_resource& M = R; memory_resource& M = R;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp

Show All 20 Lines
// D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments. // D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
NullResource R(42); NullResource R(42);
auto& P = R.getController(); auto& P = R.getController();
memory_resource& M = R; memory_resource& M = R;
Show All 38 Lines

test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp

Show All 16 Lines
// A) 'memory_resource' is destructible. // A) 'memory_resource' is destructible.
// B) The destructor is implicitly marked noexcept. // B) The destructor is implicitly marked noexcept.
// C) The destructor is marked virtual. // C) The destructor is marked virtual.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
static_assert( static_assert(
std::has_virtual_destructor<memory_resource>::value std::has_virtual_destructor<memory_resource>::value
, "Must have virtual destructor" , "Must have virtual destructor"
Show All 27 Lines

test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp

Show All 18 Lines
// B) 'is_equal' is noexcept. // B) 'is_equal' is noexcept.
// C) 'do_is_equal' is called using the same arguments passed to 'is_equal' // C) 'do_is_equal' is called using the same arguments passed to 'is_equal'
// and the resulting value is returned. // and the resulting value is returned.
// D) 'do_is_equal' is called on the LHS object and not the RHS object. // D) 'do_is_equal' is called on the LHS object and not the RHS object.
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_memory_resource.hpp" #include "test_experimental_memory_resource.hpp"
using std::experimental::pmr::memory_resource; using std::experimental::pmr::memory_resource;
int main(int, char**) int main(int, char**)
{ {
{ {
memory_resource const* r1 = nullptr; memory_resource const* r1 = nullptr;
memory_resource const* r2 = nullptr; memory_resource const* r2 = nullptr;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/std/language.support/support.limits/support.limits.general/memory_resource.version.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// <memory_resource> feature macros // WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually.
/* Constant Value // <memory_resource>
__cpp_lib_memory_resource 201603L
// Test the feature test macros defined by <memory_resource>
/* Constant Value
__cpp_lib_memory_resource 201603L [C++17]
*/ */
// XFAIL #include <memory_resource>
// #include <memory_resource>
#include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) #if TEST_STD_VER < 14
{
// ensure that the macros that are supposed to be defined in <memory_resource> are defined. # ifdef __cpp_lib_memory_resource
# error "__cpp_lib_memory_resource should not be defined before c++17"
/*
#if !defined(__cpp_lib_fooby)
# error "__cpp_lib_fooby is not defined"
#elif __cpp_lib_fooby < 201606L
# error "__cpp_lib_fooby has an invalid value"
#endif # endif
*/
return 0; #elif TEST_STD_VER == 14
}
# ifdef __cpp_lib_memory_resource
# error "__cpp_lib_memory_resource should not be defined before c++17"
# endif
#elif TEST_STD_VER == 17
# ifndef __cpp_lib_memory_resource
# error "__cpp_lib_memory_resource should be defined in c++17"
# endif
# if __cpp_lib_memory_resource != 201603L
# error "__cpp_lib_memory_resource should have the value 201603L in c++17"
# endif
#elif TEST_STD_VER > 17
# ifndef __cpp_lib_memory_resource
# error "__cpp_lib_memory_resource should be defined in c++2a"
# endif
# if __cpp_lib_memory_resource != 201603L
# error "__cpp_lib_memory_resource should have the value 201603L in c++2a"
# endif
#endif // TEST_STD_VER > 17
int main(int, char**) { return 0; }

test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
# error "__cpp_lib_math_special_functions should have the value 201603L in c++17" # error "__cpp_lib_math_special_functions should have the value 201603L in c++17"
# endif # endif
# else // _LIBCPP_VERSION # else // _LIBCPP_VERSION
# ifdef __cpp_lib_math_special_functions # ifdef __cpp_lib_math_special_functions
# error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!" # error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
# endif # endif
# endif # endif
# if !defined(_LIBCPP_VERSION) # ifndef __cpp_lib_memory_resource
# ifndef __cpp_lib_memory_resource # error "__cpp_lib_memory_resource should be defined in c++17"
# error "__cpp_lib_memory_resource should be defined in c++17" # endif
# endif # if __cpp_lib_memory_resource != 201603L
# if __cpp_lib_memory_resource != 201603L # error "__cpp_lib_memory_resource should have the value 201603L in c++17"
# error "__cpp_lib_memory_resource should have the value 201603L in c++17"
# endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_memory_resource
# error "__cpp_lib_memory_resource should not be defined because it is unimplemented in libc++!"
# endif
# endif # endif
# ifndef __cpp_lib_node_extract # ifndef __cpp_lib_node_extract
# error "__cpp_lib_node_extract should be defined in c++17" # error "__cpp_lib_node_extract should be defined in c++17"
# endif # endif
# if __cpp_lib_node_extract != 201606L # if __cpp_lib_node_extract != 201606L
# error "__cpp_lib_node_extract should have the value 201606L in c++17" # error "__cpp_lib_node_extract should have the value 201606L in c++17"
# endif # endif
▲ Show 20 Lines • Show All 687 Lines • ▼ Show 20 Lines
# error "__cpp_lib_math_special_functions should have the value 201603L in c++2a" # error "__cpp_lib_math_special_functions should have the value 201603L in c++2a"
# endif # endif
# else // _LIBCPP_VERSION # else // _LIBCPP_VERSION
# ifdef __cpp_lib_math_special_functions # ifdef __cpp_lib_math_special_functions
# error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!" # error "__cpp_lib_math_special_functions should not be defined because it is unimplemented in libc++!"
# endif # endif
# endif # endif
# if !defined(_LIBCPP_VERSION) # ifndef __cpp_lib_memory_resource
# ifndef __cpp_lib_memory_resource # error "__cpp_lib_memory_resource should be defined in c++2a"
# error "__cpp_lib_memory_resource should be defined in c++2a" # endif
# endif # if __cpp_lib_memory_resource != 201603L
# if __cpp_lib_memory_resource != 201603L # error "__cpp_lib_memory_resource should have the value 201603L in c++2a"
# error "__cpp_lib_memory_resource should have the value 201603L in c++2a"
# endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_memory_resource
# error "__cpp_lib_memory_resource should not be defined because it is unimplemented in libc++!"
# endif
# endif # endif
# ifndef __cpp_lib_node_extract # ifndef __cpp_lib_node_extract
# error "__cpp_lib_node_extract should be defined in c++2a" # error "__cpp_lib_node_extract should be defined in c++2a"
# endif # endif
# if __cpp_lib_node_extract != 201606L # if __cpp_lib_node_extract != 201606L
# error "__cpp_lib_node_extract should have the value 201606L in c++2a" # error "__cpp_lib_node_extract should have the value 201606L in c++2a"
# endif # endif
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/assign.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// polymorphic_allocator operator=(polymorphic_allocator const &) = delete
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
typedef std::pmr::polymorphic_allocator<void> T;
static_assert(!std::is_copy_assignable<T>::value, "");
static_assert(!std::is_move_assignable<T>::value, "");
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/copy.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator const &);
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
typedef std::pmr::polymorphic_allocator<void> A1;
{
static_assert(
std::is_copy_constructible<A1>::value, ""
);
static_assert(
std::is_move_constructible<A1>::value, ""
);
}
// copy
{
A1 const a((std::pmr::memory_resource*)42);
A1 const a2(a);
assert(a.resource() == a2.resource());
}
// move
{
A1 a((std::pmr::memory_resource*)42);
A1 a2(std::move(a));
assert(a.resource() == a2.resource());
assert(a2.resource() == (std::pmr::memory_resource*)42);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/default.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// polymorphic_allocator<T>::polymorphic_allocator() noexcept
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
int main(int, char**)
{
{
static_assert(
std::is_nothrow_default_constructible<ex::polymorphic_allocator<void>>::value
, "Must me nothrow default constructible"
);
}
{
// test that the allocator gets its resource from get_default_resource
TestResource R1(42);
ex::set_default_resource(&R1);
typedef ex::polymorphic_allocator<void> A;
A const a;
assert(a.resource() == &R1);
ex::set_default_resource(nullptr);
A const a2;
assert(a.resource() == &R1);
assert(a2.resource() == ex::new_delete_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/memory_resource_convert.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// polymorphic_allocator<T>::polymorphic_allocator(memory_resource *)
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
int main(int, char**)
{
{
typedef ex::polymorphic_allocator<void> A;
static_assert(
std::is_convertible<decltype(nullptr), A>::value
, "Must be convertible"
);
static_assert(
std::is_convertible<ex::memory_resource *, A>::value
, "Must be convertible"
);
}
{
typedef ex::polymorphic_allocator<void> A;
TestResource R;
A const a(&R);
assert(a.resource() == &R);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.ctor/other_alloc.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class U>
// polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator<U> const &);
#include <memory_resource>
#include <type_traits>
#include <cassert>
namespace ex = std::pmr;
int main()
{
typedef ex::polymorphic_allocator<void> A1;
typedef ex::polymorphic_allocator<char> A2;
{ // Test that the conversion is implicit and noexcept.
static_assert(
std::is_convertible<A1 const &, A2>::value, ""
);
static_assert(
std::is_convertible<A2 const &, A1>::value, ""
);
static_assert(
std::is_nothrow_constructible<A1, A2 const &>::value, ""
);
static_assert(
std::is_nothrow_constructible<A2, A1 const &>::value, ""
);
}
// copy other type
{
A1 const a((ex::memory_resource*)42);
A2 const a2(a);
assert(a.resource() == a2.resource());
assert(a2.resource() == (ex::memory_resource*)42);
}
{
A1 a((ex::memory_resource*)42);
A2 const a2(std::move(a));
assert(a.resource() == a2.resource());
assert(a2.resource() == (ex::memory_resource*)42);
}
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.eq/equal.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator;
// template <class T, class U>
// bool operator==(
// polymorphic_allocator<T> const &
// , polymorphic_allocator<U> const &) noexcept
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
int main(int, char**)
{
typedef ex::polymorphic_allocator<void> A1;
typedef ex::polymorphic_allocator<int> A2;
// check return types
{
A1 const a1;
A2 const a2;
static_assert(std::is_same<decltype(a1 == a2), bool>::value, "");
static_assert(noexcept(a1 == a2), "");
}
// equal same type (different resource)
{
TestResource d1(1);
TestResource d2(1);
A1 const a1(&d1);
A1 const a2(&d2);
assert(a1 == a2);
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(0));
d1.reset();
assert(a2 == a1);
assert(d1.checkIsEqualCalledEq(0));
assert(d2.checkIsEqualCalledEq(1));
}
// equal same type (same resource)
{
TestResource d1;
A1 const a1(&d1);
A1 const a2(&d1);
assert(a1 == a2);
assert(d1.checkIsEqualCalledEq(0));
assert(a2 == a1);
assert(d1.checkIsEqualCalledEq(0));
}
// equal different type (different resource)
{
TestResource d1(42);
TestResource d2(42);
A1 const a1(&d1);
A2 const a2(&d2);
assert(a1 == a2);
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(0));
assert(a2 == a1);
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(1));
}
// equal different type (same resource)
{
TestResource d1(42);
A1 const a1(&d1);
A2 const a2(&d1);
assert(a1 == a2);
assert(d1.checkIsEqualCalledEq(0));
assert(a2 == a1);
assert(d1.checkIsEqualCalledEq(0));
}
// not equal same type
{
TestResource d1(1);
TestResource d2(2);
A1 const a1(&d1);
A1 const a2(&d2);
assert(!(a1 == a2));
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(0));
d1.reset();
assert(!(a2 == a1));
assert(d1.checkIsEqualCalledEq(0));
assert(d2.checkIsEqualCalledEq(1));
}
// not equal different types
{
TestResource d1;
TestResource1 d2;
A1 const a1(&d1);
A2 const a2(&d2);
assert(!(a1 == a2));
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(0));
d1.reset();
assert(!(a2 == a1));
assert(d1.checkIsEqualCalledEq(0));
assert(d2.checkIsEqualCalledEq(1));
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.eq/not_equal.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator;
// template <class T>
// bool operator!=(
// polymorphic_allocator<T> const &
// , polymorphic_allocator<T> const &) noexcept
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
int main(int, char**)
{
typedef ex::polymorphic_allocator<void> A1;
typedef ex::polymorphic_allocator<int> A2;
// check return types
{
A1 const a1;
A2 const a2;
static_assert(std::is_same<decltype(a1 != a2), bool>::value, "");
static_assert(noexcept(a1 != a2), "");
}
// not equal same type (different resource)
{
TestResource d1(1);
TestResource d2(2);
A1 const a1(&d1);
A1 const a2(&d2);
assert(a1 != a2);
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(0));
d1.reset();
assert(a2 != a1);
assert(d1.checkIsEqualCalledEq(0));
assert(d2.checkIsEqualCalledEq(1));
}
// equal same type (same resource)
{
TestResource d1;
A1 const a1(&d1);
A1 const a2(&d1);
assert(!(a1 != a2));
assert(d1.checkIsEqualCalledEq(0));
assert(!(a2 != a1));
assert(d1.checkIsEqualCalledEq(0));
}
// equal same type
{
TestResource d1(1);
TestResource d2(1);
A1 const a1(&d1);
A1 const a2(&d2);
assert(!(a1 != a2));
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(0));
d1.reset();
assert(!(a2 != a1));
assert(d1.checkIsEqualCalledEq(0));
assert(d2.checkIsEqualCalledEq(1));
}
// not equal different types
{
TestResource d1;
TestResource1 d2;
A1 const a1(&d1);
A2 const a2(&d2);
assert(a1 != a2);
assert(d1.checkIsEqualCalledEq(1));
assert(d2.checkIsEqualCalledEq(0));
d1.reset();
assert(a2 != a1);
assert(d1.checkIsEqualCalledEq(0));
assert(d2.checkIsEqualCalledEq(1));
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// T* polymorphic_allocator<T>::allocate(size_t n)
#include <memory_resource>
#include <limits>
#include <memory>
#include <exception>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
template <size_t S, size_t Align>
void testForSizeAndAlign() {
using T = typename std::aligned_storage<S, Align>::type;
TestResource R;
ex::polymorphic_allocator<T> a(&R);
for (int N = 1; N <= 5; ++N) {
auto ret = a.allocate(N);
assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
a.deallocate(ret, N);
R.reset();
}
}
#ifndef TEST_HAS_NO_EXCEPTIONS
template <size_t S>
void testAllocForSizeThrows() {
using T = typename std::aligned_storage<S>::type;
using Alloc = ex::polymorphic_allocator<T>;
using Traits = std::allocator_traits<Alloc>;
NullResource R;
Alloc a(&R);
// Test that allocating exactly the max size does not throw.
size_t maxSize = Traits::max_size(a);
try {
a.allocate(maxSize);
} catch (...) {
assert(false);
}
size_t sizeTypeMax = std::numeric_limits<std::size_t>::max();
if (maxSize != sizeTypeMax)
{
// Test that allocating size_t(~0) throws bad alloc.
try {
a.allocate(sizeTypeMax);
assert(false);
} catch (std::exception const&) {
}
// Test that allocating even one more than the max size does throw.
size_t overSize = maxSize + 1;
try {
a.allocate(overSize);
assert(false);
} catch (std::exception const&) {
}
}
}
#endif // TEST_HAS_NO_EXCEPTIONS
int main(int, char**)
{
{
ex::polymorphic_allocator<int> a;
static_assert(std::is_same<decltype(a.allocate(0)), int*>::value, "");
static_assert(!noexcept(a.allocate(0)), "");
}
{
constexpr std::size_t MA = alignof(std::max_align_t);
testForSizeAndAlign<1, 1>();
testForSizeAndAlign<1, 2>();
testForSizeAndAlign<1, MA>();
testForSizeAndAlign<2, 2>();
testForSizeAndAlign<73, alignof(void*)>();
testForSizeAndAlign<73, MA>();
testForSizeAndAlign<13, MA>();
}
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testAllocForSizeThrows<1>();
testAllocForSizeThrows<2>();
testAllocForSizeThrows<4>();
testAllocForSizeThrows<8>();
testAllocForSizeThrows<16>();
testAllocForSizeThrows<73>();
testAllocForSizeThrows<13>();
}
#endif
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class U1, class U2>
// void polymorphic_allocator<T>::construct(pair<U1, U2>*)
#include <memory_resource>
#include <type_traits>
#include <utility>
#include <tuple>
#include <cassert>
#include <cstdlib>
#include "uses_alloc_types.hpp"
namespace ex = std::pmr;
int constructed = 0;
struct default_constructible
{
default_constructible() : x(42) { ++constructed; }
int x{0};
};
int main(int, char**)
{
// pair<default_constructible, default_constructible> as T()
{
typedef default_constructible T;
typedef std::pair<T, T> P;
typedef ex::polymorphic_allocator<void> A;
P * ptr = (P*)std::malloc(sizeof(P));
A a;
a.construct(ptr);
assert(constructed == 2);
assert(ptr->first.x == 42);
assert(ptr->second.x == 42);
std::free(ptr);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class P1, class P2, class U1, class U2>
// void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> const&)
#include <memory_resource>
#include <type_traits>
#include <utility>
#include <tuple>
#include <cassert>
#include <cstdlib>
#include "test_macros.h"
#include "test_memory_resource.hpp"
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
#include "test_allocator.h"
template <class UA1, class UA2, class TT, class UU>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
std::pair<TT, UU> const& p)
{
using P = std::pair<UA1, UA2>;
TestResource R;
std::pmr::memory_resource * M = &R;
std::pmr::polymorphic_allocator<P> A(M);
P * ptr = (P*)std::malloc(sizeof(P));
P * ptr2 = (P*)std::malloc(sizeof(P));
// UNDER TEST //
A.construct(ptr, p);
A.construct(ptr2, std::piecewise_construct,
std::forward_as_tuple(p.first),
std::forward_as_tuple(p.second));
// ------- //
bool tres = checkConstruct<decltype((p.first))>(ptr->first, TExpect, M) &&
checkConstructionEquiv(ptr->first, ptr2->first);
bool ures = checkConstruct<decltype((p.second))>(ptr->second, UExpect, M) &&
checkConstructionEquiv(ptr->second, ptr2->second);
A.destroy(ptr);
std::free(ptr);
A.destroy(ptr2);
std::free(ptr2);
return tres && ures;
}
template <class Alloc, class TT, class UU>
void test_pmr_uses_allocator(std::pair<TT, UU> const& p)
{
{
using T = NotUsesAllocator<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, p)));
}
{
using T = UsesAllocatorV1<Alloc, 1>;
using U = UsesAllocatorV2<Alloc, 1>;
assert((doTest<T, U>(UA_AllocArg, UA_AllocLast, p)));
}
{
using T = UsesAllocatorV2<Alloc, 1>;
using U = UsesAllocatorV3<Alloc, 1>;
assert((doTest<T, U>(UA_AllocLast, UA_AllocArg, p)));
}
{
using T = UsesAllocatorV3<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_AllocArg, UA_None, p)));
}
}
template <class Alloc, class TT, class UU>
void test_pmr_not_uses_allocator(std::pair<TT, UU> const& p)
{
{
using T = NotUsesAllocator<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, p)));
}
{
using T = UsesAllocatorV1<Alloc, 1>;
using U = UsesAllocatorV2<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, p)));
}
{
using T = UsesAllocatorV2<Alloc, 1>;
using U = UsesAllocatorV3<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, p)));
}
{
using T = UsesAllocatorV3<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, p)));
}
}
template <class Tp>
struct Print;
int main(int, char**)
{
using PMR = std::pmr::memory_resource*;
using PMA = std::pmr::polymorphic_allocator<char>;
{
int x = 42;
int y = 42;
const std::pair<int, int&> p(x, y);
test_pmr_not_uses_allocator<PMR>(p);
test_pmr_uses_allocator<PMA>(p);
}
{
int x = 42;
int y = 42;
const std::pair<int&, int&&> p(x, std::move(y));
test_pmr_not_uses_allocator<PMR>(p);
test_pmr_uses_allocator<PMA>(p);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_rvalue.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class P1, class P2, class U1, class U2>
// void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> &&)
#include <memory_resource>
#include <type_traits>
#include <utility>
#include <tuple>
#include <cassert>
#include <cstdlib>
#include "test_macros.h"
#include "test_memory_resource.hpp"
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
#include "test_allocator.h"
template <class UA1, class UA2, class TT, class UU>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
std::pair<TT, UU>&& p)
{
using P = std::pair<UA1, UA2>;
TestResource R;
std::pmr::memory_resource * M = &R;
std::pmr::polymorphic_allocator<P> A(M);
P * ptr = A.allocate(2);
P * ptr2 = ptr + 1;
// UNDER TEST //
A.construct(ptr, std::move(p));
A.construct(ptr2, std::piecewise_construct,
std::forward_as_tuple(std::forward<TT>(p.first)),
std::forward_as_tuple(std::forward<UU>(p.second)));
// ------- //
bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) &&
checkConstructionEquiv(ptr->first, ptr2->first);
bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) &&
checkConstructionEquiv(ptr->second, ptr2->second);
A.destroy(ptr);
A.destroy(ptr2);
A.deallocate(ptr, 2);
return tres && ures;
}
template <class Alloc, class TT, class UU>
void test_pmr_uses_allocator(std::pair<TT, UU>&& p)
{
{
using T = NotUsesAllocator<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
}
{
using T = UsesAllocatorV1<Alloc, 1>;
using U = UsesAllocatorV2<Alloc, 1>;
assert((doTest<T, U>(UA_AllocArg, UA_AllocLast, std::move(p))));
}
{
using T = UsesAllocatorV2<Alloc, 1>;
using U = UsesAllocatorV3<Alloc, 1>;
assert((doTest<T, U>(UA_AllocLast, UA_AllocArg, std::move(p))));
}
{
using T = UsesAllocatorV3<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_AllocArg, UA_None, std::move(p))));
}
}
template <class Alloc, class TT, class UU>
void test_pmr_not_uses_allocator(std::pair<TT, UU>&& p)
{
{
using T = NotUsesAllocator<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
}
{
using T = UsesAllocatorV1<Alloc, 1>;
using U = UsesAllocatorV2<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
}
{
using T = UsesAllocatorV2<Alloc, 1>;
using U = UsesAllocatorV3<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
}
{
using T = UsesAllocatorV3<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
}
}
int main(int, char**)
{
using PMR = std::pmr::memory_resource*;
using PMA = std::pmr::polymorphic_allocator<char>;
{
int x = 42;
int y = 42;
std::pair<int&, int&&> p(x, std::move(y));
test_pmr_not_uses_allocator<PMR>(std::move(p));
test_pmr_uses_allocator<PMA>(std::move(p));
}
{
int x = 42;
int y = 42;
std::pair<int&&, int&> p(std::move(x), y);
test_pmr_not_uses_allocator<PMR>(std::move(p));
test_pmr_uses_allocator<PMA>(std::move(p));
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_pair_values.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class P1, class P2, class U1, class U2>
// void polymorphic_allocator<T>::construct(pair<P1, P2>*, U1&&, U2&&)
#include <memory_resource>
#include <type_traits>
#include <utility>
#include <tuple>
#include <cassert>
#include <cstdlib>
#include "test_macros.h"
#include "test_memory_resource.hpp"
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
#include "test_allocator.h"
template <class UA1, class UA2, class TT, class UU>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
TT&& t, UU&& u)
{
using P = std::pair<UA1, UA2>;
TestResource R;
std::pmr::memory_resource * M = &R;
std::pmr::polymorphic_allocator<P> A(M);
P * ptr = (P*)std::malloc(sizeof(P));
P * ptr2 = (P*)std::malloc(sizeof(P));
// UNDER TEST //
A.construct(ptr, std::forward<TT>(t), std::forward<UU>(u));
A.construct(ptr2, std::piecewise_construct,
std::forward_as_tuple(std::forward<TT>(t)),
std::forward_as_tuple(std::forward<UU>(u)));
// ------- //
bool tres = checkConstruct<TT&&>(ptr->first, TExpect, M) &&
checkConstructionEquiv(ptr->first, ptr2->first);
bool ures = checkConstruct<UU&&>(ptr->second, UExpect, M) &&
checkConstructionEquiv(ptr->second, ptr2->second);
A.destroy(ptr);
A.destroy(ptr2);
std::free(ptr);
std::free(ptr2);
return tres && ures;
}
template <class Alloc, class TT, class UU>
void test_pmr_uses_allocator(TT&& t, UU&& u)
{
{
using T = NotUsesAllocator<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None,
std::forward<TT>(t), std::forward<UU>(u))));
}
{
using T = UsesAllocatorV1<Alloc, 1>;
using U = UsesAllocatorV2<Alloc, 1>;
assert((doTest<T, U>(UA_AllocArg, UA_AllocLast,
std::forward<TT>(t), std::forward<UU>(u))));
}
{
using T = UsesAllocatorV2<Alloc, 1>;
using U = UsesAllocatorV3<Alloc, 1>;
assert((doTest<T, U>(UA_AllocLast, UA_AllocArg,
std::forward<TT>(t), std::forward<UU>(u))));
}
{
using T = UsesAllocatorV3<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_AllocArg, UA_None,
std::forward<TT>(t), std::forward<UU>(u))));
}
}
template <class Alloc, class TT, class UU>
void test_pmr_not_uses_allocator(TT&& t, UU&& u)
{
{
using T = NotUsesAllocator<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None,
std::forward<TT>(t), std::forward<UU>(u))));
}
{
using T = UsesAllocatorV1<Alloc, 1>;
using U = UsesAllocatorV2<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None,
std::forward<TT>(t), std::forward<UU>(u))));
}
{
using T = UsesAllocatorV2<Alloc, 1>;
using U = UsesAllocatorV3<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None,
std::forward<TT>(t), std::forward<UU>(u))));
}
{
using T = UsesAllocatorV3<Alloc, 1>;
using U = NotUsesAllocator<Alloc, 1>;
assert((doTest<T, U>(UA_None, UA_None,
std::forward<TT>(t), std::forward<UU>(u))));
}
}
int main(int, char**)
{
using PMR = std::pmr::memory_resource*;
using PMA = std::pmr::polymorphic_allocator<char>;
{
int x = 42;
int y = 42;
test_pmr_not_uses_allocator<PMR>(x, std::move(y));
test_pmr_uses_allocator<PMA>(x, std::move(y));
}
{
int x = 42;
const int y = 42;
test_pmr_not_uses_allocator<PMR>(std::move(x), y);
test_pmr_uses_allocator<PMA>(std::move(x), y);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_piecewise_pair.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class U1, class U2, class ...Args1, class ...Args2>
// void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
// tuple<Args1...>, tuple<Args2...>)
#include <memory_resource>
#include <type_traits>
#include <utility>
#include <tuple>
#include <cassert>
#include <cstdlib>
#include "test_macros.h"
#include "test_memory_resource.hpp"
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
#include "test_allocator.h"
template <class T, class U, class ...TTuple, class ...UTuple>
bool doTest(UsesAllocatorType TExpect, UsesAllocatorType UExpect,
std::tuple<TTuple...> ttuple, std::tuple<UTuple...> utuple)
{
using P = std::pair<T, U>;
TestResource R;
std::pmr::memory_resource * M = &R;
std::pmr::polymorphic_allocator<P> A(M);
P * ptr = A.allocate(1);
// UNDER TEST //
A.construct(ptr, std::piecewise_construct, std::move(ttuple), std::move(utuple));
// ------- //
bool tres = checkConstruct<TTuple&&...>(ptr->first, TExpect, M);
bool ures = checkConstruct<UTuple&&...>(ptr->second, UExpect, M);
A.destroy(ptr);
A.deallocate(ptr, 1);
return tres && ures;
}
template <class Alloc, class ...TTypes, class ...UTypes>
void test_pmr_uses_allocator(std::tuple<TTypes...> ttuple, std::tuple<UTypes...> utuple)
{
{
using T = NotUsesAllocator<Alloc, sizeof...(TTypes)>;
using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_None, UA_None,
std::move(ttuple), std::move(utuple))));
}
{
using T = UsesAllocatorV1<Alloc, sizeof...(TTypes)>;
using U = UsesAllocatorV2<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_AllocArg, UA_AllocLast,
std::move(ttuple), std::move(utuple))));
}
{
using T = UsesAllocatorV2<Alloc, sizeof...(TTypes)>;
using U = UsesAllocatorV3<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_AllocLast, UA_AllocArg,
std::move(ttuple), std::move(utuple))));
}
{
using T = UsesAllocatorV3<Alloc, sizeof...(TTypes)>;
using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_AllocArg, UA_None,
std::move(ttuple), std::move(utuple))));
}
}
template <class Alloc, class ...TTypes, class ...UTypes>
void test_pmr_not_uses_allocator(std::tuple<TTypes...> ttuple, std::tuple<UTypes...> utuple)
{
{
using T = NotUsesAllocator<Alloc, sizeof...(TTypes)>;
using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_None, UA_None,
std::move(ttuple), std::move(utuple))));
}
{
using T = UsesAllocatorV1<Alloc, sizeof...(TTypes)>;
using U = UsesAllocatorV2<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_None, UA_None,
std::move(ttuple), std::move(utuple))));
}
{
using T = UsesAllocatorV2<Alloc, sizeof...(TTypes)>;
using U = UsesAllocatorV3<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_None, UA_None,
std::move(ttuple), std::move(utuple))));
}
{
using T = UsesAllocatorV3<Alloc, sizeof...(TTypes)>;
using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
assert((doTest<T, U>(UA_None, UA_None,
std::move(ttuple), std::move(utuple))));
}
}
int main(int, char**)
{
using PMR = std::pmr::memory_resource*;
using PMA = std::pmr::polymorphic_allocator<char>;
{
std::tuple<> t1;
test_pmr_not_uses_allocator<PMR>(t1, t1);
test_pmr_uses_allocator<PMA>(t1, t1);
}
{
std::tuple<int> t1(42);
std::tuple<> t2;
test_pmr_not_uses_allocator<PMR>(t1, t2);
test_pmr_not_uses_allocator<PMR>(t2, t1);
test_pmr_uses_allocator<PMA>(t1, t2);
test_pmr_uses_allocator<PMA>(t2, t1);
}
{
std::tuple<int> t1(42);
int x = 55;
double dx = 42.42;
std::tuple<int&, double&&> t2(x, std::move(dx));
test_pmr_not_uses_allocator<PMR>( t1, std::move(t2));
test_pmr_not_uses_allocator<PMR>(std::move(t2), t1);
test_pmr_uses_allocator<PMA>( t1, std::move(t2));
test_pmr_uses_allocator<PMA>(std::move(t2), t1);
}
{
void* xptr = nullptr;
long y = 4242;
std::tuple<int, long const&, void*&> t1(42, y, xptr);
int x = 55;
double dx = 42.42;
const char* s = "hello World";
std::tuple<int&, double&&, const char*> t2(x, std::move(dx), s);
test_pmr_not_uses_allocator<PMR>( t1, std::move(t2));
test_pmr_not_uses_allocator<PMR>(std::move(t2), t1);
test_pmr_uses_allocator<PMA>( t1, std::move(t2));
test_pmr_uses_allocator<PMA>(std::move(t2), t1);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_piecewise_pair_evil.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class U1, class U2, class ...Args1, class ...Args2>
// void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
// tuple<Args1...>, tuple<Args2...>)
#include <memory_resource>
#include <tuple>
#include <type_traits>
#include <utility>
#include <cassert>
#include <cstdlib>
#include "test_macros.h"
template <class T>
struct EvilAlloc {
explicit EvilAlloc() : inner_(std::pmr::null_memory_resource()) {}
EvilAlloc(std::pmr::polymorphic_allocator<T> & a) : inner_(a) {}
EvilAlloc(std::pmr::polymorphic_allocator<T> && a) : inner_(a) {}
EvilAlloc(std::pmr::polymorphic_allocator<T> const & a) = delete;
EvilAlloc(std::pmr::polymorphic_allocator<T> const && a) = delete;
using value_type = T;
template <class U> EvilAlloc(EvilAlloc<U> const & rhs) : inner_(rhs.inner_) {}
std::pmr::polymorphic_allocator<T> inner_;
};
struct WidgetV0 {
WidgetV0(int v) : value_(v) {}
bool holds(int v, const std::pmr::polymorphic_allocator<char>&) const {
return value_ == v;
}
private:
int value_;
};
struct WidgetV1 {
using allocator_type = EvilAlloc<char>;
WidgetV1(int v) : value_(v), alloc_() {}
WidgetV1(std::allocator_arg_t, EvilAlloc<char> a, int v) : value_(v), alloc_(a) {}
bool holds(int v, const std::pmr::polymorphic_allocator<char>& a) const {
return value_ == v && alloc_.inner_ == a;
}
private:
int value_;
EvilAlloc<char> alloc_;
};
struct WidgetV2 {
using allocator_type = EvilAlloc<char>;
WidgetV2(int v) : value_(v), alloc_() {}
WidgetV2(int v, EvilAlloc<char> a) : value_(v), alloc_(a) {}
bool holds(int v, std::pmr::polymorphic_allocator<char> a) const {
return value_ == v && alloc_.inner_ == a;
}
private:
int value_;
EvilAlloc<char> alloc_;
};
struct WidgetV3 {
using allocator_type = EvilAlloc<char>;
WidgetV3(int v) : value_(v), alloc_() {}
WidgetV3(std::allocator_arg_t, EvilAlloc<char> a, int v) : value_(v), alloc_(a) {}
WidgetV3(int v, EvilAlloc<char> a) : value_(v), alloc_(a) {}
bool holds(int v, std::pmr::polymorphic_allocator<char> a) const {
return value_ == v && alloc_.inner_ == a;
}
private:
int value_;
EvilAlloc<char> alloc_;
};
static_assert(std::uses_allocator<WidgetV1, EvilAlloc<char>>::value, "");
static_assert(std::uses_allocator<WidgetV2, EvilAlloc<char>>::value, "");
static_assert(std::uses_allocator<WidgetV3, EvilAlloc<char>>::value, "");
static_assert(std::uses_allocator<WidgetV1, std::pmr::polymorphic_allocator<char>>::value, "");
static_assert(std::uses_allocator<WidgetV2, std::pmr::polymorphic_allocator<char>>::value, "");
static_assert(std::uses_allocator<WidgetV3, std::pmr::polymorphic_allocator<char>>::value, "");
template<class W1, class W2>
void test_evil()
{
using PMA = std::pmr::polymorphic_allocator<char>;
PMA pma(std::pmr::new_delete_resource());
{
using Pair = std::pair<W1, W2>;
void *where = std::malloc(sizeof (Pair));
Pair *p = (Pair *)where;
pma.construct(p, std::piecewise_construct, std::make_tuple(42), std::make_tuple(42));
assert(p->first.holds(42, pma));
assert(p->second.holds(42, pma));
pma.destroy(p);
std::free(where);
}
}
int main(int, char**)
{
test_evil<WidgetV0, WidgetV0>();
test_evil<WidgetV0, WidgetV1>();
test_evil<WidgetV0, WidgetV2>();
test_evil<WidgetV0, WidgetV3>();
test_evil<WidgetV1, WidgetV0>();
test_evil<WidgetV1, WidgetV1>();
test_evil<WidgetV1, WidgetV2>();
test_evil<WidgetV1, WidgetV3>();
test_evil<WidgetV2, WidgetV0>();
test_evil<WidgetV2, WidgetV1>();
test_evil<WidgetV2, WidgetV2>();
test_evil<WidgetV2, WidgetV3>();
test_evil<WidgetV3, WidgetV0>();
test_evil<WidgetV3, WidgetV1>();
test_evil<WidgetV3, WidgetV2>();
test_evil<WidgetV3, WidgetV3>();
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/construct_types.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class U, class ...Args>
// void polymorphic_allocator<T>::construct(U *, Args &&...)
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include <cstdlib>
#include "test_macros.h"
#include "test_memory_resource.hpp"
#include "uses_alloc_types.hpp"
#include "controlled_allocators.hpp"
#include "test_allocator.h"
template <class T>
struct PMATest {
TestResource R;
std::pmr::polymorphic_allocator<T> A;
T* ptr;
bool constructed;
PMATest() : A(&R), ptr(A.allocate(1)), constructed(false) {}
template <class ...Args>
void construct(Args&&... args) {
A.construct(ptr, std::forward<Args>(args)...);
constructed = true;
}
~PMATest() {
if (constructed) A.destroy(ptr);
A.deallocate(ptr, 1);
}
};
template <class T, class ...Args>
bool doTest(UsesAllocatorType UAExpect, Args&&... args)
{
PMATest<T> TH;
// UNDER TEST //
TH.construct(std::forward<Args>(args)...);
return checkConstruct<Args&&...>(*TH.ptr, UAExpect, &TH.R);
// ------- //
}
template <class T, class ...Args>
bool doTestUsesAllocV0(Args&&... args)
{
PMATest<T> TH;
// UNDER TEST //
TH.construct(std::forward<Args>(args)...);
return checkConstruct<Args&&...>(*TH.ptr, UA_None);
// -------- //
}
template <class T, class EAlloc, class ...Args>
bool doTestUsesAllocV1(EAlloc const& ealloc, Args&&... args)
{
PMATest<T> TH;
// UNDER TEST //
TH.construct(std::allocator_arg, ealloc, std::forward<Args>(args)...);
return checkConstruct<Args&&...>(*TH.ptr, UA_AllocArg, ealloc);
// -------- //
}
template <class T, class EAlloc, class ...Args>
bool doTestUsesAllocV2(EAlloc const& ealloc, Args&&... args)
{
PMATest<T> TH;
// UNDER TEST //
TH.construct(std::forward<Args>(args)..., ealloc);
return checkConstruct<Args&&...>(*TH.ptr, UA_AllocLast, ealloc);
// -------- //
}
template <class Alloc, class ...Args>
void test_pmr_uses_alloc(Args&&... args)
{
TestResource R(12435);
std::pmr::memory_resource* M = &R;
{
// NotUsesAllocator provides valid signatures for each uses-allocator
// construction but does not supply the required allocator_type typedef.
// Test that we can call these constructors manually without
// polymorphic_allocator interfering.
using T = NotUsesAllocator<Alloc, sizeof...(Args)>;
assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
assert((doTestUsesAllocV1<T>(M, std::forward<Args>(args)...)));
assert((doTestUsesAllocV2<T>(M, std::forward<Args>(args)...)));
}
{
// Test T(std::allocator_arg_t, Alloc const&, Args...) construction
using T = UsesAllocatorV1<Alloc, sizeof...(Args)>;
assert((doTest<T>(UA_AllocArg, std::forward<Args>(args)...)));
}
{
// Test T(Args..., Alloc const&) construction
using T = UsesAllocatorV2<Alloc, sizeof...(Args)>;
assert((doTest<T>(UA_AllocLast, std::forward<Args>(args)...)));
}
{
// Test that T(std::allocator_arg_t, Alloc const&, Args...) construction
// is preferred when T(Args..., Alloc const&) is also available.
using T = UsesAllocatorV3<Alloc, sizeof...(Args)>;
assert((doTest<T>(UA_AllocArg, std::forward<Args>(args)...)));
}
}
// Test that polymorphic_allocator does not prevent us from manually
// doing non-pmr uses-allocator construction.
template <class Alloc, class AllocObj, class ...Args>
void test_non_pmr_uses_alloc(AllocObj const& A, Args&&... args)
{
{
using T = NotUsesAllocator<Alloc, sizeof...(Args)>;
assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
}
{
using T = UsesAllocatorV1<Alloc, sizeof...(Args)>;
assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
}
{
using T = UsesAllocatorV2<Alloc, sizeof...(Args)>;
assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
}
{
using T = UsesAllocatorV3<Alloc, sizeof...(Args)>;
assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
}
}
int main(int, char**)
{
using PMR = std::pmr::memory_resource*;
using PMA = std::pmr::polymorphic_allocator<char>;
using STDA = std::allocator<char>;
using TESTA = test_allocator<char>;
int value = 42;
const int cvalue = 43;
{
test_pmr_uses_alloc<PMA>();
test_pmr_uses_alloc<PMA>(value);
test_pmr_uses_alloc<PMA>(cvalue);
test_pmr_uses_alloc<PMA>(cvalue, std::move(value));
}
{
STDA std_alloc;
TESTA test_alloc(42);
PMR mem_res = std::pmr::new_delete_resource();
test_non_pmr_uses_alloc<PMR>(mem_res);
test_non_pmr_uses_alloc<STDA>(std_alloc);
test_non_pmr_uses_alloc<TESTA>(test_alloc);
test_non_pmr_uses_alloc<PMR>(mem_res, value);
test_non_pmr_uses_alloc<STDA>(std_alloc, value);
test_non_pmr_uses_alloc<TESTA>(test_alloc, value);
test_non_pmr_uses_alloc<PMR>(mem_res, cvalue);
test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue);
test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue);
test_non_pmr_uses_alloc<PMR>(mem_res, cvalue, std::move(cvalue));
test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue, std::move(value));
test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue, std::move(value));
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/deallocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// T* polymorphic_allocator<T>::deallocate(T*, size_t size)
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
template <size_t S, size_t Align>
void testForSizeAndAlign() {
using T = typename std::aligned_storage<S, Align>::type;
TestResource R;
ex::polymorphic_allocator<T> a(&R);
for (int N = 1; N <= 5; ++N) {
auto ret = a.allocate(N);
assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
a.deallocate(ret, N);
assert(R.checkDealloc(ret, N * sizeof(T), alignof(T)));
R.reset();
}
}
int main(int, char**)
{
{
ex::polymorphic_allocator<int> a;
static_assert(
std::is_same<decltype(a.deallocate(nullptr, 0)), void>::value, "");
}
{
constexpr std::size_t MA = alignof(std::max_align_t);
testForSizeAndAlign<1, 1>();
testForSizeAndAlign<1, 2>();
testForSizeAndAlign<1, MA>();
testForSizeAndAlign<2, 2>();
testForSizeAndAlign<73, alignof(void*)>();
testForSizeAndAlign<73, MA>();
testForSizeAndAlign<13, MA>();
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/destroy.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// template <class U>
// void polymorphic_allocator<T>::destroy(U * ptr);
#include <memory_resource>
#include <type_traits>
#include <new>
#include <cassert>
#include <cstdlib>
namespace ex = std::pmr;
int count = 0;
struct destroyable
{
destroyable() { ++count; }
~destroyable() { --count; }
};
int main(int, char**)
{
typedef ex::polymorphic_allocator<double> A;
{
A a;
static_assert(
std::is_same<decltype(a.destroy((destroyable*)nullptr)), void>::value,
"");
}
{
destroyable * ptr = ::new (std::malloc(sizeof(destroyable))) destroyable();
assert(count == 1);
A{}.destroy(ptr);
assert(count == 0);
std::free(ptr);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/resource.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// memory_resource *
// polymorphic_allocator<T>::resource() const
#include <memory_resource>
#include <type_traits>
#include <cassert>
namespace ex = std::pmr;
int main(int, char**)
{
typedef ex::polymorphic_allocator<void> A;
{
A const a;
static_assert(
std::is_same<decltype(a.resource()), ex::memory_resource*>::value
, ""
);
}
{
ex::memory_resource * mptr = (ex::memory_resource*)42;
A const a(mptr);
assert(a.resource() == mptr);
}
{
A const a(nullptr);
assert(a.resource() == nullptr);
assert(a.resource() == nullptr);
}
{
A const a;
assert(a.resource() == ex::get_default_resource());
}
{
ex::memory_resource * mptr = (ex::memory_resource*)42;
ex::set_default_resource(mptr);
A const a;
assert(a.resource() == mptr);
assert(a.resource() == ex::get_default_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/select_on_container_copy_construction.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// template <class T> class polymorphic_allocator
// polymorphic_allocator
// polymorphic_allocator<T>::select_on_container_copy_construction() const
#include <memory_resource>
#include <type_traits>
#include <cassert>
namespace ex = std::pmr;
int main(int, char**)
{
typedef ex::polymorphic_allocator<void> A;
{
A const a;
static_assert(
std::is_same<decltype(a.select_on_container_copy_construction()), A>::value,
"");
}
{
ex::memory_resource * mptr = (ex::memory_resource*)42;
A const a(mptr);
assert(a.resource() == mptr);
A const other = a.select_on_container_copy_construction();
assert(other.resource() == ex::get_default_resource());
assert(a.resource() == mptr);
}
{
ex::memory_resource * mptr = (ex::memory_resource*)42;
ex::set_default_resource(mptr);
A const a(nullptr);
assert(a.resource() == nullptr);
A const other = a.select_on_container_copy_construction();
assert(other.resource() == ex::get_default_resource());
assert(other.resource() == mptr);
assert(a.resource() == nullptr);
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_deque_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <deque>
// namespace std::pmr {
// template <class T>
// using deque =
// ::std::deque<T, polymorphic_allocator<T>>
//
// } // namespace std::pmr
#include <deque>
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
using StdDeque = std::deque<int, std::pmr::polymorphic_allocator<int>>;
using PmrDeque = std::pmr::deque<int>;
static_assert(std::is_same<StdDeque, PmrDeque>::value, "");
PmrDeque d;
assert(d.get_allocator().resource() == std::pmr::get_default_resource());
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_forward_list_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <forward_list>
// namespace std::pmr {
// template <class T>
// using forward_list =
// ::std::forward_list<T, polymorphic_allocator<T>>
//
// } // namespace std::pmr
#include <forward_list>
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
using StdForwardList = std::forward_list<int, std::pmr::polymorphic_allocator<int>>;
using PmrForwardList = std::pmr::forward_list<int>;
static_assert(std::is_same<StdForwardList, PmrForwardList>::value, "");
PmrForwardList d;
assert(d.get_allocator().resource() == std::pmr::get_default_resource());
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_list_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <list>
// namespace std::pmr {
// template <class T>
// using list =
// ::std::list<T, polymorphic_allocator<T>>
//
// } // namespace std::pmr
#include <list>
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
using StdList = std::list<int, std::pmr::polymorphic_allocator<int>>;
using PmrList = std::pmr::list<int>;
static_assert(std::is_same<StdList, PmrList>::value, "");
PmrList d;
assert(d.get_allocator().resource() == std::pmr::get_default_resource());
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_list_synop2.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// REQUIRES: c++17
// <list>
// namespace std::pmr {
//
// typedef ... list
//
// } // namespace std::pmr
#include <list>
int main(int, char**)
{
{
// Check that std::pmr::list is usable without <memory_resource>.
std::pmr::list<int> l;
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_map_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <map>
// namespace std::pmr {
// template <class K, class V, class Compare = less<Key> >
// using map =
// ::std::map<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
//
// template <class K, class V, class Compare = less<Key> >
// using multimap =
// ::std::multimap<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
//
// } // namespace std::pmr
#include <map>
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
using K = int;
using V = char;
using DC = std::less<int>;
using OC = std::greater<int>;
using P = std::pair<const K, V>;
{
using StdMap = std::map<K, V, DC, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::map<K, V>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
using StdMap = std::map<K, V, OC, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::map<K, V, OC>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
std::pmr::map<int, int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
{
using StdMap = std::multimap<K, V, DC, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::multimap<K, V>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
using StdMap = std::multimap<K, V, OC, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::multimap<K, V, OC>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
std::pmr::multimap<int, int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_regex_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <regex>
// namespace std::pmr {
//
// template <class BidirectionalIterator>
// using match_results =
// std::match_results<BidirectionalIterator,
// polymorphic_allocator<sub_match<BidirectionalIterator>>>;
//
// typedef match_results<const char*> cmatch;
// typedef match_results<const wchar_t*> wcmatch;
// typedef match_results<string::const_iterator> smatch;
// typedef match_results<wstring::const_iterator> wsmatch;
//
// } // namespace std::pmr
#include <regex>
#include <type_traits>
#include <cassert>
template <class Iter, class PmrTypedef>
void test_match_result_typedef() {
using StdMR = std::match_results<Iter, std::pmr::polymorphic_allocator<std::sub_match<Iter>>>;
using PmrMR = std::pmr::match_results<Iter>;
static_assert(std::is_same<StdMR, PmrMR>::value, "");
static_assert(std::is_same<PmrMR, PmrTypedef>::value, "");
}
int main(int, char**)
{
{
test_match_result_typedef<const char*, std::pmr::cmatch>();
test_match_result_typedef<const wchar_t*, std::pmr::wcmatch>();
test_match_result_typedef<std::pmr::string::const_iterator, std::pmr::smatch>();
test_match_result_typedef<std::pmr::wstring::const_iterator, std::pmr::wsmatch>();
}
{
// Check that std::match_results has been included and is complete.
std::pmr::smatch s;
assert(s.get_allocator().resource() == std::pmr::get_default_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_set_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <set>
// namespace std::pmr {
// template <class V, class Compare = less<V> >
// using set =
// ::std::set<V, Compare, polymorphic_allocator<V>>
//
// template <class V, class Compare = less<V> >
// using multiset =
// ::std::multiset<V, Compare, polymorphic_allocator<V>>
//
// } // namespace std::pmr
#include <set>
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
using V = char;
using DC = std::less<V>;
using OC = std::greater<V>;
{
using StdSet = std::set<V, DC, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::set<V>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
using StdSet = std::set<V, OC, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::set<V, OC>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
std::pmr::set<int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
{
using StdSet = std::multiset<V, DC, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::multiset<V>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
using StdSet = std::multiset<V, OC, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::multiset<V, OC>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
std::pmr::multiset<int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_string_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <string>
// namespace std::pmr {
// template <class Char, class Traits = ...>
// using basic_string =
// ::std::basic_string<Char, Traits, polymorphic_allocator<Char>>
//
// typedef ... string
// typedef ... u16string
// typedef ... u32string
// typedef ... wstring
//
// } // namespace std::pmr
#include <string>
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "constexpr_char_traits.hpp"
namespace pmr = std::pmr;
template <class Char, class PmrTypedef>
void test_string_typedef() {
using StdStr = std::basic_string<Char, std::char_traits<Char>,
std::pmr::polymorphic_allocator<Char>>;
using PmrStr = std::pmr::basic_string<Char>;
static_assert(std::is_same<StdStr, PmrStr>::value, "");
static_assert(std::is_same<PmrStr, PmrTypedef>::value, "");
}
template <class Char, class Traits>
void test_basic_string_alias() {
using StdStr = std::basic_string<Char, Traits,
std::pmr::polymorphic_allocator<Char>>;
using PmrStr = std::pmr::basic_string<Char, Traits>;
static_assert(std::is_same<StdStr, PmrStr>::value, "");
}
int main(int, char**)
{
{
test_string_typedef<char, std::pmr::string>();
test_string_typedef<wchar_t, std::pmr::wstring>();
test_string_typedef<char16_t, std::pmr::u16string>();
test_string_typedef<char32_t, std::pmr::u32string>();
}
{
test_basic_string_alias<char, constexpr_char_traits<char>>();
test_basic_string_alias<wchar_t, constexpr_char_traits<wchar_t>>();
test_basic_string_alias<char16_t, constexpr_char_traits<char16_t>>();
test_basic_string_alias<char32_t, constexpr_char_traits<char32_t>>();
}
{
// Check that std::basic_string has been included and is complete.
std::pmr::string s;
assert(s.get_allocator().resource() == std::pmr::get_default_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_string_synop2.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// REQUIRES: c++17
// <string>
// namespace std::pmr {
//
// typedef ... string
// typedef ... u16string
// typedef ... u32string
// typedef ... wstring
//
// } // namespace std::pmr
#include <string>
int main(int, char**)
{
{
// Check that std::pmr::string is usable without <memory_resource>.
std::pmr::string s;
std::pmr::wstring ws;
std::pmr::u16string u16s;
std::pmr::u32string u32s;
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_unordered_map_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <unordered_map>
// namespace std::pmr {
// template <class K, class V, class H = hash<K>, class P = equal_to<K> >
// using unordered_map =
// ::std::unordered_map<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
//
// template <class K, class V, class H = hash<K>, class P = equal_to<K> >
// using unordered_multimap =
// ::std::unordered_multimap<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
//
// } // namespace std::pmr
#include <unordered_map>
#include <memory_resource>
#include <type_traits>
#include <cassert>
template <class T>
struct MyHash : std::hash<T> {};
template <class T>
struct MyPred : std::equal_to<T> {};
int main(int, char**)
{
using K = int;
using V = char;
using DH = std::hash<K>;
using MH = MyHash<K>;
using DP = std::equal_to<K>;
using MP = MyPred<K>;
using P = std::pair<const K, V>;
{
using StdMap = std::unordered_map<K, V, DH, DP, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::unordered_map<K, V>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
using StdMap = std::unordered_map<K, V, MH, DP, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::unordered_map<K, V, MH>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
using StdMap = std::unordered_map<K, V, MH, MP, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::unordered_map<K, V, MH, MP>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
std::pmr::unordered_map<int, int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
{
using StdMap = std::unordered_multimap<K, V, DH, DP, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::unordered_multimap<K, V>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
using StdMap = std::unordered_multimap<K, V, MH, DP, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::unordered_multimap<K, V, MH>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
using StdMap = std::unordered_multimap<K, V, MH, MP, std::pmr::polymorphic_allocator<P>>;
using PmrMap = std::pmr::unordered_multimap<K, V, MH, MP>;
static_assert(std::is_same<StdMap, PmrMap>::value, "");
}
{
std::pmr::unordered_multimap<int, int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_unordered_set_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <unordered_set>
// namespace std::pmr {
// template <class V, class H = hash<V>, class P = equal_to<V> >
// using unordered_set =
// ::std::unordered_set<V, H, P, polymorphic_allocator<V>>
//
// template <class V, class H = hash<V>, class P = equal_to<V> >
// using unordered_multiset =
// ::std::unordered_multiset<V, H, P, polymorphic_allocator<V>>
//
// } // namespace std::pmr
#include <unordered_set>
#include <memory_resource>
#include <type_traits>
#include <cassert>
template <class T>
struct MyHash : std::hash<T> {};
template <class T>
struct MyPred : std::equal_to<T> {};
int main(int, char**)
{
using V = char;
using DH = std::hash<V>;
using MH = MyHash<V>;
using DP = std::equal_to<V>;
using MP = MyPred<V>;
{
using StdSet = std::unordered_set<V, DH, DP, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::unordered_set<V>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
using StdSet = std::unordered_set<V, MH, DP, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::unordered_set<V, MH>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
using StdSet = std::unordered_set<V, MH, MP, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::unordered_set<V, MH, MP>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
std::pmr::unordered_set<int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
{
using StdSet = std::unordered_multiset<V, DH, DP, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::unordered_multiset<V>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
using StdSet = std::unordered_multiset<V, MH, DP, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::unordered_multiset<V, MH>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
using StdSet = std::unordered_multiset<V, MH, MP, std::pmr::polymorphic_allocator<V>>;
using PmrSet = std::pmr::unordered_multiset<V, MH, MP>;
static_assert(std::is_same<StdSet, PmrSet>::value, "");
}
{
std::pmr::unordered_multiset<int> m;
assert(m.get_allocator().resource() == std::pmr::get_default_resource());
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.aliases/header_vector_synop.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <vector>
// namespace std::pmr {
// template <class T>
// using vector =
// ::std::vector<T, polymorphic_allocator<T>>
//
// } // namespace std::pmr
#include <vector>
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main(int, char**)
{
using StdVector = std::vector<int, std::pmr::polymorphic_allocator<int>>;
using PmrVector = std::pmr::vector<int>;
static_assert(std::is_same<StdVector, PmrVector>::value, "");
PmrVector d;
assert(d.get_allocator().resource() == std::pmr::get_default_resource());
return 0;
}

test/std/utilities/utility/mem.res/mem.res.global/default_resource.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
//-----------------------------------------------------------------------------
// TESTING memory_resource * get_default_resource() noexcept;
// memory_resource * set_default_resource(memory_resource*) noexcept;
//
// Concerns:
// A) 'get_default_resource()' returns a non-null memory_resource pointer.
// B) 'get_default_resource()' returns the value set by the last call to
// 'set_default_resource(...)' and 'new_delete_resource()' if no call
// to 'set_default_resource(...)' has occurred.
// C) 'set_default_resource(...)' returns the previous value of the default
// resource.
// D) 'set_default_resource(T* p)' for a non-null 'p' sets the default resource
// to be 'p'.
// E) 'set_default_resource(null)' sets the default resource to
// 'new_delete_resource()'.
// F) 'get_default_resource' and 'set_default_resource' are noexcept.
#include <memory_resource>
#include <cassert>
#include "test_memory_resource.hpp"
using namespace std::pmr;
int main(int, char**) {
TestResource R;
{ // Test (A) and (B)
memory_resource* p = get_default_resource();
assert(p != nullptr);
assert(p == new_delete_resource());
assert(p == get_default_resource());
}
{ // Test (C) and (D)
memory_resource *expect = &R;
memory_resource *old = set_default_resource(expect);
assert(old != nullptr);
assert(old == new_delete_resource());
memory_resource *p = get_default_resource();
assert(p != nullptr);
assert(p == expect);
assert(p == get_default_resource());
}
{ // Test (E)
memory_resource* old = set_default_resource(nullptr);
assert(old == &R);
memory_resource* p = get_default_resource();
assert(p != nullptr);
assert(p == new_delete_resource());
assert(p == get_default_resource());
}
{ // Test (F)
static_assert(noexcept(get_default_resource()),
"get_default_resource() must be noexcept");
static_assert(noexcept(set_default_resource(nullptr)),
"set_default_resource() must be noexcept");
}
return 0;
}

test/std/utilities/utility/mem.res/mem.res.global/new_delete_resource.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// memory_resource * new_delete_resource()
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "count_new.hpp"
namespace ex = std::pmr;
struct assert_on_compare : public ex::memory_resource
{
protected:
virtual void * do_allocate(size_t, size_t)
{ assert(false); }
virtual void do_deallocate(void *, size_t, size_t)
{ assert(false); }
virtual bool do_is_equal(ex::memory_resource const &) const noexcept
{ assert(false); }
};
void test_return()
{
{
static_assert(std::is_same<
decltype(ex::new_delete_resource()), ex::memory_resource*
>::value, "");
}
// assert not null
{
assert(ex::new_delete_resource());
}
// assert same return value
{
assert(ex::new_delete_resource() == ex::new_delete_resource());
}
}
void test_equality()
{
// Same object
{
ex::memory_resource & r1 = *ex::new_delete_resource();
ex::memory_resource & r2 = *ex::new_delete_resource();
// check both calls returned the same object
assert(&r1 == &r2);
// check for proper equality semantics
assert(r1 == r2);
assert(r2 == r1);
assert(!(r1 != r2));
assert(!(r2 != r1));
}
// Different types
{
ex::memory_resource & r1 = *ex::new_delete_resource();
assert_on_compare c;
ex::memory_resource & r2 = c;
assert(r1 != r2);
assert(!(r1 == r2));
}
}
void test_allocate_deallocate()
{
ex::memory_resource & r1 = *ex::new_delete_resource();
globalMemCounter.reset();
void *ret = r1.allocate(50);
assert(ret);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(globalMemCounter.checkLastNewSizeEq(50));
r1.deallocate(ret, 1);
assert(globalMemCounter.checkOutstandingNewEq(0));
assert(globalMemCounter.checkDeleteCalledEq(1));
}
int main(int, char**)
{
static_assert(noexcept(ex::new_delete_resource()), "Must be noexcept");
test_return();
test_equality();
test_allocate_deallocate();
return 0;
}

test/std/utilities/utility/mem.res/mem.res.global/null_memory_resource.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// memory_resource * null_memory_resource()
#include <memory_resource>
#include <new>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "count_new.hpp"
namespace ex = std::pmr;
struct assert_on_compare : public ex::memory_resource
{
protected:
virtual void * do_allocate(size_t, size_t)
{ assert(false); }
virtual void do_deallocate(void *, size_t, size_t)
{ assert(false); }
virtual bool do_is_equal(ex::memory_resource const &) const noexcept
{ assert(false); }
};
void test_return()
{
{
static_assert(std::is_same<
decltype(ex::null_memory_resource()), ex::memory_resource*
>::value, "");
}
// Test that the returned value is not null
{
assert(ex::null_memory_resource());
}
// Test the same value is returned by repeated calls.
{
assert(ex::null_memory_resource() == ex::null_memory_resource());
}
}
void test_equality()
{
// Same object
{
ex::memory_resource & r1 = *ex::null_memory_resource();
ex::memory_resource & r2 = *ex::null_memory_resource();
// check both calls returned the same object
assert(&r1 == &r2);
// check for proper equality semantics
assert(r1 == r2);
assert(r2 == r1);
assert(!(r1 != r2));
assert(!(r2 != r1));
// check the is_equal method
assert(r1.is_equal(r2));
assert(r2.is_equal(r1));
}
// Different types
{
ex::memory_resource & r1 = *ex::null_memory_resource();
assert_on_compare c;
ex::memory_resource & r2 = c;
assert(r1 != r2);
assert(!(r1 == r2));
assert(!r1.is_equal(r2));
}
}
void test_allocate()
{
#ifndef TEST_HAS_NO_EXCEPTIONS
DisableAllocationGuard g; // null_memory_resource shouldn't allocate.
try {
ex::null_memory_resource()->allocate(1);
assert(false);
} catch (std::bad_alloc const &) {
// do nothing
} catch (...) {
assert(false);
}
#endif
}
void test_deallocate()
{
globalMemCounter.reset();
int x = 42;
ex::null_memory_resource()->deallocate(nullptr, 0);
ex::null_memory_resource()->deallocate(&x, 0);
assert(globalMemCounter.checkDeleteCalledEq(0));
assert(globalMemCounter.checkDeleteArrayCalledEq(0));
}
int main()
{
test_return();
test_equality();
test_allocate();
test_deallocate();
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.ctor/copy_move.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// monotonic_buffer_resource(monotonic_buffer_resource const&) = delete;
// monotonic_buffer_resource& operator=(monotonic_buffer_resource const&) = delete;
#include <memory_resource>
#include <type_traits>
#include <cassert>
int main()
{
using MBR = std::pmr::monotonic_buffer_resource;
static_assert(!std::is_copy_constructible<MBR>::value, "");
static_assert(!std::is_move_constructible<MBR>::value, "");
static_assert(!std::is_copy_assignable<MBR>::value, "");
static_assert(!std::is_move_assignable<MBR>::value, "");
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.ctor/with_default_resource.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
int main()
{
std::pmr::memory_resource *expected = std::pmr::null_memory_resource();
std::pmr::set_default_resource(expected);
{
char buffer[16];
std::pmr::monotonic_buffer_resource r1;
std::pmr::monotonic_buffer_resource r2(16);
std::pmr::monotonic_buffer_resource r3(buffer, sizeof buffer);
assert(r1.upstream_resource() == expected);
assert(r2.upstream_resource() == expected);
assert(r3.upstream_resource() == expected);
}
expected = std::pmr::new_delete_resource();
std::pmr::set_default_resource(expected);
{
char buffer[16];
std::pmr::monotonic_buffer_resource r1;
std::pmr::monotonic_buffer_resource r2(16);
std::pmr::monotonic_buffer_resource r3(buffer, sizeof buffer);
assert(r1.upstream_resource() == expected);
assert(r2.upstream_resource() == expected);
assert(r3.upstream_resource() == expected);
}
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.ctor/without_buffer.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
// Constructing a monotonic_buffer_resource should not cause allocations
// by itself; the resource should wait to allocate until an allocation is
// requested.
globalMemCounter.reset();
std::pmr::set_default_resource(std::pmr::new_delete_resource());
std::pmr::monotonic_buffer_resource r1;
assert(globalMemCounter.checkNewCalledEq(0));
std::pmr::monotonic_buffer_resource r2(1024);
assert(globalMemCounter.checkNewCalledEq(0));
std::pmr::monotonic_buffer_resource r3(1024, std::pmr::new_delete_resource());
assert(globalMemCounter.checkNewCalledEq(0));
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_deallocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
{
globalMemCounter.reset();
std::pmr::monotonic_buffer_resource mono1(std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = mono1;
void *ret = r1.allocate(50);
assert(ret);
assert(globalMemCounter.checkNewCalledGreaterThan(0));
assert(globalMemCounter.checkDeleteCalledEq(0));
// mem.res.monotonic.buffer 1.2
// A call to deallocate has no effect, thus the amount of memory
// consumed increases monotonically until the resource is destroyed.
// Check that deallocate is a no-op
r1.deallocate(ret, 50);
assert(globalMemCounter.checkDeleteCalledEq(0));
mono1.release();
assert(globalMemCounter.checkDeleteCalledEq(1));
assert(globalMemCounter.checkOutstandingNewEq(0));
globalMemCounter.reset();
ret = r1.allocate(500);
assert(ret);
assert(globalMemCounter.checkNewCalledGreaterThan(0));
assert(globalMemCounter.checkDeleteCalledEq(0));
// Check that the destructor calls release()
}
assert(globalMemCounter.checkDeleteCalledEq(1));
assert(globalMemCounter.checkOutstandingNewEq(0));
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_exception_safety.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
struct repointable_resource : public std::pmr::memory_resource
{
std::pmr::memory_resource *which;
explicit repointable_resource(std::pmr::memory_resource *res) : which(res) {}
protected:
virtual void *do_allocate(size_t size, size_t align)
{ return which->allocate(size, align); }
virtual void do_deallocate(void *p, size_t size, size_t align)
{ return which->deallocate(p, size, align); }
virtual bool do_is_equal(std::pmr::memory_resource const &rhs) const noexcept
{ return which->is_equal(rhs); }
};
int main()
{
globalMemCounter.reset();
repointable_resource upstream(std::pmr::new_delete_resource());
alignas(16) char buffer[64];
std::pmr::monotonic_buffer_resource mono1(buffer, sizeof buffer, &upstream);
std::pmr::memory_resource & r1 = mono1;
void *res = r1.allocate(64, 16);
assert(res == buffer);
assert(globalMemCounter.checkNewCalledEq(0));
res = r1.allocate(64, 16);
assert(res != buffer);
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.checkDeleteCalledEq(0));
const size_t last_new_size = globalMemCounter.last_new_size;
upstream.which = std::pmr::null_memory_resource();
try {
res = r1.allocate(last_new_size, 16);
assert(false);
} catch (const std::bad_alloc&) {
// we expect this
}
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.checkDeleteCalledEq(0));
upstream.which = std::pmr::new_delete_resource();
res = r1.allocate(last_new_size, 16);
assert(res != buffer);
assert(globalMemCounter.checkNewCalledEq(2));
assert(globalMemCounter.checkDeleteCalledEq(0));
mono1.release();
assert(globalMemCounter.checkNewCalledEq(2));
assert(globalMemCounter.checkDeleteCalledEq(2));
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_from_initial_buffer.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
globalMemCounter.reset();
char buffer[100];
std::pmr::monotonic_buffer_resource mono1((void *)buffer, sizeof buffer, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = mono1;
// Check that construction with a buffer does not allocate anything from the upstream
assert(globalMemCounter.checkNewCalledEq(0));
// Check that an allocation that fits in the buffer does not allocate anything from the upstream
void *ret = r1.allocate(50);
assert(ret);
assert(globalMemCounter.checkNewCalledEq(0));
// Check a second allocation
ret = r1.allocate(20);
assert(ret);
assert(globalMemCounter.checkNewCalledEq(0));
r1.deallocate(ret, 50);
assert(globalMemCounter.checkDeleteCalledEq(0));
// Check an allocation that doesn't fit in the original buffer
ret = r1.allocate(50);
assert(ret);
assert(globalMemCounter.checkNewCalledEq(1));
r1.deallocate(ret, 50);
assert(globalMemCounter.checkDeleteCalledEq(0));
mono1.release();
assert(globalMemCounter.checkDeleteCalledEq(1));
assert(globalMemCounter.checkOutstandingNewEq(0));
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_from_underaligned_buffer.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
globalMemCounter.reset();
{
alignas(4) char buffer[17];
std::pmr::monotonic_buffer_resource mono1(buffer + 1, 16, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = mono1;
void *ret = r1.allocate(1, 1);
assert(ret == buffer + 1);
mono1.release();
ret = r1.allocate(1, 2);
assert(ret == buffer + 2);
mono1.release();
ret = r1.allocate(1, 4);
assert(ret == buffer + 4);
mono1.release();
// Test a size that is just big enough to fit in the buffer,
// but can't fit if it's aligned.
ret = r1.allocate(16, 1);
assert(ret == buffer + 1);
mono1.release();
assert(globalMemCounter.checkNewCalledEq(0));
ret = r1.allocate(16, 2);
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.last_new_size >= 16);
// assert(globalMemCounter.last_new_align >= 2);
mono1.release();
assert(globalMemCounter.checkDeleteCalledEq(1));
// assert(globalMemCounter.last_new_align == globalMemCounter.last_delete_align);
}
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_from_zero_sized_buffer.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
globalMemCounter.reset();
{
char buffer[100];
std::pmr::monotonic_buffer_resource mono1((void *)buffer, 0, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = mono1;
void *ret = r1.allocate(1, 1);
assert(ret != nullptr);
assert(globalMemCounter.checkNewCalledEq(1));
}
assert(globalMemCounter.checkDeleteCalledEq(1));
globalMemCounter.reset();
{
std::pmr::monotonic_buffer_resource mono1(nullptr, 0, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = mono1;
void *ret = r1.allocate(1, 1);
assert(ret != nullptr);
assert(globalMemCounter.checkNewCalledEq(1));
}
assert(globalMemCounter.checkDeleteCalledEq(1));
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_in_geometric_progression.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
void test_geometric_progression()
{
// mem.res.monotonic.buffer 1.3
// Each additional buffer is larger than the previous one, following a
// geometric progression.
globalMemCounter.reset();
std::pmr::monotonic_buffer_resource mono1(100, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = mono1;
assert(globalMemCounter.checkNewCalledEq(0));
size_t next_buffer_size = 100;
void *ret = r1.allocate(10, 1);
assert(ret != nullptr);
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.last_new_size >= next_buffer_size);
next_buffer_size = globalMemCounter.last_new_size + 1;
int new_called = 1;
while (new_called < 5) {
ret = r1.allocate(10, 1);
if (globalMemCounter.new_called > new_called) {
assert(globalMemCounter.new_called == new_called + 1);
assert(globalMemCounter.last_new_size >= next_buffer_size);
next_buffer_size = globalMemCounter.last_new_size + 1;
new_called += 1;
}
}
}
int main()
{
test_geometric_progression();
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_overaligned_request.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
#ifndef TEST_HAS_NO_ALIGNED_ALLOCATION
globalMemCounter.reset();
std::pmr::monotonic_buffer_resource mono1(1024, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = mono1;
constexpr size_t big_alignment = 8 * alignof(std::max_align_t);
static_assert(big_alignment > 4);
void *ret = r1.allocate(2048, big_alignment);
assert(ret != nullptr);
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.last_new_size >= 2048);
assert(globalMemCounter.last_new_align >= big_alignment);
// Check that a single highly aligned allocation request doesn't
// permanently "poison" the resource to allocate only super-aligned
// blocks of memory.
ret = r1.allocate(globalMemCounter.last_new_size, 4);
assert(ret != nullptr);
assert(globalMemCounter.checkNewCalledEq(2));
assert(globalMemCounter.last_new_align >= 4);
assert(globalMemCounter.last_new_align < big_alignment);
#endif
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/allocate_with_initial_size.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
void test(size_t initial_buffer_size)
{
globalMemCounter.reset();
std::pmr::monotonic_buffer_resource mono1(
initial_buffer_size,
std::pmr::new_delete_resource()
);
assert(globalMemCounter.checkNewCalledEq(0));
mono1.allocate(1, 1);
assert(globalMemCounter.checkNewCalledEq(1));
assert(globalMemCounter.last_new_size >= initial_buffer_size);
mono1.allocate(initial_buffer_size - 1, 1);
assert(globalMemCounter.checkNewCalledEq(1));
}
int main()
{
test(1);
test(8);
test(10);
test(100);
test(256);
test(1000);
test(1024);
test(1000000);
assert(globalMemCounter.checkOutstandingNewEq(0));
}

test/std/utilities/utility/mem.res/mem.res.monotonic.buffer/mem.res.monotonic.buffer.mem/equality.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class monotonic_buffer_resource
#include <memory_resource>
#include <new>
#include <type_traits>
#include <cassert>
struct assert_on_compare : public std::pmr::memory_resource
{
protected:
virtual void * do_allocate(size_t, size_t)
{ assert(false); }
virtual void do_deallocate(void *, size_t, size_t)
{ assert(false); }
virtual bool do_is_equal(std::pmr::memory_resource const &) const noexcept
{ assert(false); }
};
int main()
{
// Same object
{
std::pmr::monotonic_buffer_resource r1;
std::pmr::monotonic_buffer_resource r2;
assert(r1 == r1);
assert(r1 != r2);
std::pmr::memory_resource & p1 = r1;
std::pmr::memory_resource & p2 = r2;
assert(p1 == p1);
assert(p1 != p2);
assert(p1 == r1);
assert(r1 == p1);
assert(p1 != r2);
assert(r2 != p1);
}
// Different types
{
std::pmr::monotonic_buffer_resource mono1;
std::pmr::memory_resource & r1 = mono1;
assert_on_compare c;
std::pmr::memory_resource & r2 = c;
assert(r1 != r2);
assert(!(r1 == r2));
}
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/ctor_does_not_allocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class synchronized_pool_resource
// class unsynchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
template<class PoolResource>
void test()
{
// Constructing a pool resource should not cause allocations
// by itself; the resource should wait to allocate until an
// allocation is requested.
globalMemCounter.reset();
std::pmr::set_default_resource(std::pmr::new_delete_resource());
PoolResource r1;
assert(globalMemCounter.checkNewCalledEq(0));
PoolResource r2(std::pmr::pool_options{ 1024, 2048 });
assert(globalMemCounter.checkNewCalledEq(0));
PoolResource r3(std::pmr::pool_options{ 1024, 2048 }, std::pmr::new_delete_resource());
assert(globalMemCounter.checkNewCalledEq(0));
}
int main()
{
test<std::pmr::unsynchronized_pool_resource>();
test<std::pmr::synchronized_pool_resource>();
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/sync_with_default_resource.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class synchronized_pool_resource
#include <memory_resource>
#include <cassert>
int main()
{
std::pmr::memory_resource *expected = std::pmr::null_memory_resource();
std::pmr::set_default_resource(expected);
{
std::pmr::pool_options opts { 0, 0 };
std::pmr::synchronized_pool_resource r1;
std::pmr::synchronized_pool_resource r2(opts);
assert(r1.upstream_resource() == expected);
assert(r2.upstream_resource() == expected);
}
expected = std::pmr::new_delete_resource();
std::pmr::set_default_resource(expected);
{
std::pmr::pool_options opts { 1024, 2048 };
std::pmr::synchronized_pool_resource r1;
std::pmr::synchronized_pool_resource r2(opts);
assert(r1.upstream_resource() == expected);
assert(r2.upstream_resource() == expected);
}
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/unsync_with_default_resource.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class unsynchronized_pool_resource
#include <memory_resource>
#include <cassert>
int main()
{
std::pmr::memory_resource *expected = std::pmr::null_memory_resource();
std::pmr::set_default_resource(expected);
{
std::pmr::pool_options opts { 0, 0 };
std::pmr::unsynchronized_pool_resource r1;
std::pmr::unsynchronized_pool_resource r2(opts);
assert(r1.upstream_resource() == expected);
assert(r2.upstream_resource() == expected);
}
expected = std::pmr::new_delete_resource();
std::pmr::set_default_resource(expected);
{
std::pmr::pool_options opts { 1024, 2048 };
std::pmr::unsynchronized_pool_resource r1;
std::pmr::unsynchronized_pool_resource r2(opts);
assert(r1.upstream_resource() == expected);
assert(r2.upstream_resource() == expected);
}
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/equality.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class synchronized_pool_resource
// class unsynchronized_pool_resource
#include <memory_resource>
#include <new>
#include <type_traits>
#include <cassert>
#include "count_new.hpp"
class assert_on_compare : public std::pmr::memory_resource
{
void * do_allocate(size_t, size_t) override
{ assert(false); }
void do_deallocate(void *, size_t, size_t) override
{ assert(false); }
bool do_is_equal(std::pmr::memory_resource const &) const noexcept override
{ assert(false); }
};
template<class PoolResource>
void test()
{
// Same type
{
PoolResource pr1;
PoolResource pr2;
assert(pr1 == pr1);
assert(pr1 != pr2);
std::pmr::memory_resource & mr1 = pr1;
std::pmr::memory_resource & mr2 = pr2;
assert(mr1 == mr1);
assert(mr1 != mr2);
assert(mr1 == pr1);
assert(pr1 == mr1);
assert(mr1 != pr2);
assert(pr2 != mr1);
}
// Different types
{
PoolResource pr1;
std::pmr::memory_resource & mr1 = pr1;
assert_on_compare c;
std::pmr::memory_resource & mr2 = c;
assert(mr1 != mr2);
assert(!(mr1 == mr2));
}
}
int main()
{
test<std::pmr::synchronized_pool_resource>();
test<std::pmr::unsynchronized_pool_resource>();
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/sync_allocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class synchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
{
globalMemCounter.reset();
std::pmr::synchronized_pool_resource sync1(std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = sync1;
void *ret = r1.allocate(50);
assert(ret);
assert(globalMemCounter.checkNewCalledGreaterThan(0));
assert(globalMemCounter.checkDeleteCalledEq(0));
r1.deallocate(ret, 50);
sync1.release();
assert(globalMemCounter.checkDeleteCalledGreaterThan(0));
assert(globalMemCounter.checkOutstandingNewEq(0));
globalMemCounter.reset();
ret = r1.allocate(500);
assert(ret);
assert(globalMemCounter.checkNewCalledGreaterThan(0));
assert(globalMemCounter.checkDeleteCalledEq(0));
// Check that the destructor calls release()
}
assert(globalMemCounter.checkDeleteCalledGreaterThan(0));
assert(globalMemCounter.checkOutstandingNewEq(0));
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/sync_allocate_overaligned_request.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class synchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
bool is_aligned_to(void *p, size_t alignment)
{
void *p2 = p;
size_t space = 1;
void *result = std::align(alignment, 1, p2, space);
return (result == p);
}
int main()
{
#ifndef TEST_HAS_NO_ALIGNED_ALLOCATION
globalMemCounter.reset();
std::pmr::pool_options opts { 1, 1024 };
std::pmr::synchronized_pool_resource sync1(opts, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = sync1;
constexpr size_t big_alignment = 8 * alignof(std::max_align_t);
static_assert(big_alignment > 4);
assert(globalMemCounter.checkNewCalledEq(0));
void *ret = r1.allocate(2048, big_alignment);
assert(ret != nullptr);
assert(is_aligned_to(ret, big_alignment));
assert(globalMemCounter.checkNewCalledGreaterThan(0));
ret = r1.allocate(16, 4);
assert(ret != nullptr);
assert(is_aligned_to(ret, 4));
assert(globalMemCounter.checkNewCalledGreaterThan(1));
#endif
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/sync_allocate_reuse_blocks.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class synchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
static bool is_aligned_to(void *p, size_t alignment)
{
void *p2 = p;
size_t space = 1;
void *result = std::align(alignment, 1, p2, space);
return (result == p);
}
int main()
{
globalMemCounter.reset();
std::pmr::pool_options opts { 1, 256 };
std::pmr::synchronized_pool_resource sync1(opts, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = sync1;
void *ret = r1.allocate(8);
assert(ret != nullptr);
assert(is_aligned_to(ret, 8));
assert(globalMemCounter.checkNewCalledGreaterThan(0));
int new_called = globalMemCounter.new_called;
// After deallocation, the pool for 8-byte blocks should have at least one vacancy.
r1.deallocate(ret, 8);
assert(globalMemCounter.new_called == new_called);
assert(globalMemCounter.checkDeleteCalledEq(0));
// This should return an existing block from the pool: no new allocations.
ret = r1.allocate(8);
assert(ret != nullptr);
assert(is_aligned_to(ret, 8));
assert(globalMemCounter.new_called == new_called);
assert(globalMemCounter.checkDeleteCalledEq(0));
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/sync_deallocate_matches_allocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class synchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include <vector>
struct allocation_record {
size_t bytes;
size_t align;
explicit allocation_record(size_t b, size_t a) : bytes(b), align(a) {}
bool operator==(const allocation_record& rhs) const {
return (bytes == rhs.bytes) && (align == rhs.align);
}
bool operator<(const allocation_record& rhs) const {
if (bytes != rhs.bytes) return (bytes < rhs.bytes);
return (align < rhs.align);
}
};
class test_resource : public std::pmr::memory_resource {
void *do_allocate(size_t bytes, size_t align) override {
void *result = std::pmr::new_delete_resource()->allocate(bytes, align);
successful_allocations.emplace_back(bytes, align);
return result;
}
void do_deallocate(void *p, size_t bytes, size_t align) override {
deallocations.emplace_back(bytes, align);
return std::pmr::new_delete_resource()->deallocate(p, bytes, align);
}
bool do_is_equal(const std::pmr::memory_resource&) const noexcept override {
return false;
}
public:
std::vector<allocation_record> successful_allocations;
std::vector<allocation_record> deallocations;
};
template<class F>
void test_allocation_pattern(F do_pattern)
{
test_resource tr;
std::pmr::pool_options opts { 0, 256 };
std::pmr::synchronized_pool_resource spr(opts, &tr);
try {
do_pattern(spr);
} catch (const std::bad_alloc&) {}
spr.release();
assert(tr.successful_allocations.size() == tr.deallocations.size());
std::sort(tr.successful_allocations.begin(), tr.successful_allocations.end());
std::sort(tr.deallocations.begin(), tr.deallocations.end());
assert(tr.successful_allocations == tr.deallocations);
}
template<size_t Bytes, size_t Align>
auto foo() {
return [=](auto& mr) {
void *p = mr.allocate(Bytes, Align);
mr.deallocate(p, Bytes, Align);
};
}
int main()
{
test_allocation_pattern(foo<2, 1>());
test_allocation_pattern(foo<2, 8>());
test_allocation_pattern(foo<2, 64>());
test_allocation_pattern(foo<128, 1>());
test_allocation_pattern(foo<128, 8>());
test_allocation_pattern(foo<128, 64>());
test_allocation_pattern(foo<1024, 1>());
test_allocation_pattern(foo<1024, 8>());
test_allocation_pattern(foo<1024, 64>());
test_allocation_pattern([](auto& mr) {
void *p1 = mr.allocate(2, 1);
void *p2 = mr.allocate(2, 8);
void *p3 = mr.allocate(2, 64);
void *p4 = mr.allocate(128, 1);
void *p5 = mr.allocate(128, 8);
void *p6 = mr.allocate(128, 64);
void *p7 = mr.allocate(1024, 1);
void *p8 = mr.allocate(1024, 8);
void *p9 = mr.allocate(1024, 64);
mr.deallocate(p1, 2, 1);
mr.deallocate(p2, 2, 8);
mr.deallocate(p3, 2, 64);
mr.deallocate(p4, 128, 1);
mr.deallocate(p5, 128, 8);
mr.deallocate(p6, 128, 64);
mr.deallocate(p7, 1024, 1);
mr.deallocate(p8, 1024, 8);
mr.deallocate(p9, 1024, 64);
});
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_allocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class unsynchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
int main()
{
{
globalMemCounter.reset();
std::pmr::unsynchronized_pool_resource unsync1(std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = unsync1;
void *ret = r1.allocate(50);
assert(ret);
assert(globalMemCounter.checkNewCalledGreaterThan(0));
assert(globalMemCounter.checkDeleteCalledEq(0));
r1.deallocate(ret, 50);
unsync1.release();
assert(globalMemCounter.checkDeleteCalledGreaterThan(0));
assert(globalMemCounter.checkOutstandingNewEq(0));
globalMemCounter.reset();
ret = r1.allocate(500);
assert(ret);
assert(globalMemCounter.checkNewCalledGreaterThan(0));
assert(globalMemCounter.checkDeleteCalledEq(0));
// Check that the destructor calls release()
}
assert(globalMemCounter.checkDeleteCalledGreaterThan(0));
assert(globalMemCounter.checkOutstandingNewEq(0));
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_allocate_overaligned_request.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class unsynchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
bool is_aligned_to(void *p, size_t alignment)
{
void *p2 = p;
size_t space = 1;
void *result = std::align(alignment, 1, p2, space);
return (result == p);
}
int main()
{
#ifndef TEST_HAS_NO_ALIGNED_ALLOCATION
globalMemCounter.reset();
std::pmr::pool_options opts { 1, 1024 };
std::pmr::unsynchronized_pool_resource unsync1(opts, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = unsync1;
constexpr size_t big_alignment = 8 * alignof(std::max_align_t);
static_assert(big_alignment > 4);
assert(globalMemCounter.checkNewCalledEq(0));
void *ret = r1.allocate(2048, big_alignment);
assert(ret != nullptr);
assert(is_aligned_to(ret, big_alignment));
assert(globalMemCounter.checkNewCalledGreaterThan(0));
ret = r1.allocate(16, 4);
assert(ret != nullptr);
assert(is_aligned_to(ret, 4));
assert(globalMemCounter.checkNewCalledGreaterThan(1));
#endif
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_allocate_reuse_blocks.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class unsynchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include "count_new.hpp"
static bool is_aligned_to(void *p, size_t alignment)
{
void *p2 = p;
size_t space = 1;
void *result = std::align(alignment, 1, p2, space);
return (result == p);
}
int main()
{
globalMemCounter.reset();
std::pmr::pool_options opts { 1, 256 };
std::pmr::unsynchronized_pool_resource unsync1(opts, std::pmr::new_delete_resource());
std::pmr::memory_resource & r1 = unsync1;
void *ret = r1.allocate(8);
assert(ret != nullptr);
assert(is_aligned_to(ret, 8));
assert(globalMemCounter.checkNewCalledGreaterThan(0));
int new_called = globalMemCounter.new_called;
// After deallocation, the pool for 8-byte blocks should have at least one vacancy.
r1.deallocate(ret, 8);
assert(globalMemCounter.new_called == new_called);
assert(globalMemCounter.checkDeleteCalledEq(0));
// This should return an existing block from the pool: no new allocations.
ret = r1.allocate(8);
assert(ret != nullptr);
assert(is_aligned_to(ret, 8));
assert(globalMemCounter.new_called == new_called);
assert(globalMemCounter.checkDeleteCalledEq(0));
}

test/std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.mem/unsync_deallocate_matches_allocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// class unsynchronized_pool_resource
#include <memory_resource>
#include <cassert>
#include <vector>
struct allocation_record {
size_t bytes;
size_t align;
explicit allocation_record(size_t b, size_t a) : bytes(b), align(a) {}
bool operator==(const allocation_record& rhs) const {
return (bytes == rhs.bytes) && (align == rhs.align);
}
bool operator<(const allocation_record& rhs) const {
if (bytes != rhs.bytes) return (bytes < rhs.bytes);
return (align < rhs.align);
}
};
class test_resource : public std::pmr::memory_resource {
void *do_allocate(size_t bytes, size_t align) override {
void *result = std::pmr::new_delete_resource()->allocate(bytes, align);
successful_allocations.emplace_back(bytes, align);
return result;
}
void do_deallocate(void *p, size_t bytes, size_t align) override {
deallocations.emplace_back(bytes, align);
return std::pmr::new_delete_resource()->deallocate(p, bytes, align);
}
bool do_is_equal(const std::pmr::memory_resource&) const noexcept override {
return false;
}
public:
std::vector<allocation_record> successful_allocations;
std::vector<allocation_record> deallocations;
};
template<class F>
void test_allocation_pattern(F do_pattern)
{
test_resource tr;
std::pmr::pool_options opts { 0, 256 };
std::pmr::unsynchronized_pool_resource uspr(opts, &tr);
try {
do_pattern(uspr);
} catch (const std::bad_alloc&) {}
uspr.release();
assert(tr.successful_allocations.size() == tr.deallocations.size());
std::sort(tr.successful_allocations.begin(), tr.successful_allocations.end());
std::sort(tr.deallocations.begin(), tr.deallocations.end());
assert(tr.successful_allocations == tr.deallocations);
}
template<size_t Bytes, size_t Align>
auto foo() {
return [=](auto& mr) {
void *p = mr.allocate(Bytes, Align);
mr.deallocate(p, Bytes, Align);
};
}
int main()
{
test_allocation_pattern(foo<2, 1>());
test_allocation_pattern(foo<2, 8>());
test_allocation_pattern(foo<2, 64>());
test_allocation_pattern(foo<128, 1>());
test_allocation_pattern(foo<128, 8>());
test_allocation_pattern(foo<128, 64>());
test_allocation_pattern(foo<1024, 1>());
test_allocation_pattern(foo<1024, 8>());
test_allocation_pattern(foo<1024, 64>());
test_allocation_pattern([](auto& mr) {
void *p1 = mr.allocate(2, 1);
void *p2 = mr.allocate(2, 8);
void *p3 = mr.allocate(2, 64);
void *p4 = mr.allocate(128, 1);
void *p5 = mr.allocate(128, 8);
void *p6 = mr.allocate(128, 64);
void *p7 = mr.allocate(1024, 1);
void *p8 = mr.allocate(1024, 8);
void *p9 = mr.allocate(1024, 64);
mr.deallocate(p1, 2, 1);
mr.deallocate(p2, 2, 8);
mr.deallocate(p3, 2, 64);
mr.deallocate(p4, 128, 1);
mr.deallocate(p5, 128, 8);
mr.deallocate(p6, 128, 64);
mr.deallocate(p7, 1024, 1);
mr.deallocate(p8, 1024, 8);
mr.deallocate(p9, 1024, 64);
});
}

test/std/utilities/utility/mem.res/mem.res/construct.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// Check that memory_resource is not constructible
#include <memory_resource>
#include <type_traits>
#include <cassert>
namespace ex = std::pmr;
int main()
{
ex::memory_resource m; // expected-error {{variable type 'ex::memory_resource' is an abstract class}}
}

test/std/utilities/utility/mem.res/mem.res/mem.res.eq/equal.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// bool operator==(memory_resource const &, memory_resource const &) noexcept;
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
int main()
{
// check return types
{
ex::memory_resource const * mr1(nullptr);
ex::memory_resource const * mr2(nullptr);
static_assert(std::is_same<decltype(*mr1 == *mr2), bool>::value, "");
static_assert(noexcept(*mr1 == *mr2), "");
}
// equal
{
TestResource r1(1);
TestResource r2(1);
ex::memory_resource const & mr1 = r1;
ex::memory_resource const & mr2 = r2;
assert(mr1 == mr2);
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(0));
assert(mr2 == mr1);
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(1));
}
// equal same object
{
TestResource r1(1);
ex::memory_resource const & mr1 = r1;
ex::memory_resource const & mr2 = r1;
assert(mr1 == mr2);
assert(r1.checkIsEqualCalledEq(0));
assert(mr2 == mr1);
assert(r1.checkIsEqualCalledEq(0));
}
// not equal
{
TestResource r1(1);
TestResource r2(2);
ex::memory_resource const & mr1 = r1;
ex::memory_resource const & mr2 = r2;
assert(!(mr1 == mr2));
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(0));
assert(!(mr2 == mr1));
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(1));
}
}

test/std/utilities/utility/mem.res/mem.res/mem.res.eq/not_equal.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// bool operator!=(memory_resource const &, memory_resource const &) noexcept;
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
namespace ex = std::pmr;
int main()
{
// check return types
{
ex::memory_resource const * mr1(nullptr);
ex::memory_resource const * mr2(nullptr);
static_assert(std::is_same<decltype(*mr1 != *mr2), bool>::value, "");
static_assert(noexcept(*mr1 != *mr2), "");
}
// not equal
{
TestResource r1(1);
TestResource r2(2);
ex::memory_resource const & mr1 = r1;
ex::memory_resource const & mr2 = r2;
assert(mr1 != mr2);
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(0));
assert(mr2 != mr1);
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(1));
}
// equal
{
TestResource r1(1);
TestResource r2(1);
ex::memory_resource const & mr1 = r1;
ex::memory_resource const & mr2 = r2;
assert(!(mr1 != mr2));
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(0));
assert(!(mr2 != mr1));
assert(r1.checkIsEqualCalledEq(1));
assert(r2.checkIsEqualCalledEq(1));
}
// equal same object
{
TestResource r1(1);
ex::memory_resource const & mr1 = r1;
ex::memory_resource const & mr2 = r1;
assert(!(mr1 != mr2));
assert(r1.checkIsEqualCalledEq(0));
assert(!(mr2 != mr1));
assert(r1.checkIsEqualCalledEq(0));
}
}

test/std/utilities/utility/mem.res/mem.res/mem.res.private/private_members.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// memory_resource::do_allocate(size_t, size_t); /* private */
// memory_resource::do_deallocate(void*, size_t, size_t); /* private */
// memory_resource::do_is_equal(memory_resource const&); /* private */
#include <memory_resource>
namespace ex = std::pmr;
int main() {
ex::memory_resource *m = ex::new_delete_resource();
m->do_allocate(0, 0); // expected-error{{'do_allocate' is a private member}}
m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a private member}}
m->do_is_equal(*m); // expected-error{{'do_is_equal' is a private member}}
}

test/std/utilities/utility/mem.res/mem.res/mem.res.private/protected_members.fail.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
// monotonic_buffer_resource::do_allocate(size_t, size_t); /* protected */
// monotonic_buffer_resource::do_deallocate(void*, size_t, size_t); /* protected */
// monotonic_buffer_resource::do_is_equal(memory_resource const&); /* protected */
// synchronized_pool_resource::do_allocate(size_t, size_t); /* protected */
// synchronized_pool_resource::do_deallocate(void*, size_t, size_t); /* protected */
// synchronized_pool_resource::do_is_equal(memory_resource const&); /* protected */
// unsynchronized_pool_resource::do_allocate(size_t, size_t); /* protected */
// unsynchronized_pool_resource::do_deallocate(void*, size_t, size_t); /* protected */
// unsynchronized_pool_resource::do_is_equal(memory_resource const&); /* protected */
#include <memory_resource>
int main() {
{
std::pmr::monotonic_buffer_resource m;
m.do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
m.do_is_equal(m); // expected-error{{'do_is_equal' is a protected member}}
}
{
std::pmr::synchronized_pool_resource m;
m.do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
m.do_is_equal(m); // expected-error{{'do_is_equal' is a protected member}}
}
{
std::pmr::unsynchronized_pool_resource m;
m.do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
m.do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
m.do_is_equal(m); // expected-error{{'do_is_equal' is a protected member}}
}
}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/allocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <memory_resource>
// UNSUPPORTED: c++98, c++03
//------------------------------------------------------------------------------
// TESTING void * memory_resource::allocate(size_t, size_t = max_align)
//
// Concerns:
// A) 'memory_resource' contains a member 'allocate' with the required
// signature, including the default alignment parameter.
// B) The return type of 'allocate' is 'void*'.
// C) 'allocate' is not marked as 'noexcept'.
// D) Invoking 'allocate' invokes 'do_allocate' with the same arguments.
// E) If 'do_allocate' throws then 'allocate' propagates that exception.
#include <memory_resource>
#include <type_traits>
#include <cstddef>
#include <cassert>
#include "test_macros.h"
#include "test_memory_resource.hpp"
using std::pmr::memory_resource;
int main()
{
TestResource R(42);
auto& P = R.getController();
memory_resource& M = R;
{
static_assert(
std::is_same<decltype(M.allocate(0, 0)), void*>::value
, "Must be void*"
);
static_assert(
std::is_same<decltype(M.allocate(0)), void*>::value
, "Must be void*"
);
}
{
static_assert(
! noexcept(M.allocate(0, 0))
, "Must not be noexcept."
);
static_assert(
! noexcept(M.allocate(0))
, "Must not be noexcept."
);
}
{
int s = 42;
int a = 64;
void* p = M.allocate(s, a);
assert(P.alloc_count == 1);
assert(P.checkAlloc(p, s, a));
s = 128;
a = MaxAlignV;
p = M.allocate(s);
assert(P.alloc_count == 2);
assert(P.checkAlloc(p, s, a));
}
#ifndef TEST_HAS_NO_EXCEPTIONS
{
TestResource R2;
auto& P2 = R2.getController();
P2.throw_on_alloc = true;
memory_resource& M2 = R2;
try {
M2.allocate(42);
assert(false);
} catch (TestException const&) {
// do nothing.
} catch (...) {
assert(false);
}
}
#endif
}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/deallocate.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <memory_resource>
// UNSUPPORTED: c++98, c++03
//------------------------------------------------------------------------------
// TESTING void * memory_resource::deallocate(void *, size_t, size_t = max_align)
//
// Concerns:
// A) 'memory_resource' contains a member 'deallocate' with the required
// signature, including the default alignment parameter.
// B) The return type of 'deallocate' is 'void'.
// C) 'deallocate' is not marked as 'noexcept'.
// D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments.
#include <memory_resource>
#include <type_traits>
#include <cstddef>
#include <cassert>
#include "test_memory_resource.hpp"
using std::pmr::memory_resource;
int main()
{
NullResource R(42);
auto& P = R.getController();
memory_resource& M = R;
{
static_assert(
std::is_same<decltype(M.deallocate(nullptr, 0, 0)), void>::value
, "Must be void"
);
static_assert(
std::is_same<decltype(M.deallocate(nullptr, 0)), void>::value
, "Must be void"
);
}
{
static_assert(
! noexcept(M.deallocate(nullptr, 0, 0))
, "Must not be noexcept."
);
static_assert(
! noexcept(M.deallocate(nullptr, 0))
, "Must not be noexcept."
);
}
{
int s = 100;
int a = 64;
void* p = reinterpret_cast<void*>(640);
M.deallocate(p, s, a);
assert(P.dealloc_count == 1);
assert(P.checkDealloc(p, s, a));
s = 128;
a = alignof(std::max_align_t);
p = reinterpret_cast<void*>(12800);
M.deallocate(p, s);
assert(P.dealloc_count == 2);
assert(P.checkDealloc(p, s, a));
}
}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/dtor.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
//------------------------------------------------------------------------------
// TESTING virtual ~memory_resource()
//
// Concerns:
// A) 'memory_resource' is destructible.
// B) The destructor is implicitly marked noexcept.
// C) The destructor is marked virtual.
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
using std::pmr::memory_resource;
int main()
{
static_assert(
std::has_virtual_destructor<memory_resource>::value
, "Must have virtual destructor"
);
static_assert(
std::is_nothrow_destructible<memory_resource>::value,
"Must be nothrow destructible"
);
static_assert(
std::is_abstract<memory_resource>::value
, "Must be abstract"
);
// Check that the destructor of `TestResource` is called when
// it is deleted as a pointer to `memory_resource`
{
using TR = TestResource;
memory_resource* M = new TR(42);
assert(TR::resource_alive == 1);
assert(TR::resource_constructed == 1);
assert(TR::resource_destructed == 0);
delete M;
assert(TR::resource_alive == 0);
assert(TR::resource_constructed == 1);
assert(TR::resource_destructed == 1);
}
}

test/std/utilities/utility/mem.res/mem.res/mem.res.public/is_equal.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <memory_resource>
//------------------------------------------------------------------------------
// TESTING virtual bool is_equal(memory_resource const &) const noexcept
//
// Concerns:
// A) 'memory_resource' provides a function 'is_equal' with the required
// signature.
// B) 'is_equal' is noexcept.
// C) 'do_is_equal' is called using the same arguments passed to 'is_equal'
// and the resulting value is returned.
// D) 'do_is_equal' is called on the LHS object and not the RHS object.
#include <memory_resource>
#include <type_traits>
#include <cassert>
#include "test_memory_resource.hpp"
using std::pmr::memory_resource;
int main()
{
{
memory_resource const* r1 = nullptr;
memory_resource const* r2 = nullptr;
static_assert(
noexcept(r1->is_equal(*r2))
, "is_equal must be noexcept"
);
}
{
TestResource1 R1(1);
auto& P1 = R1.getController();
memory_resource const& M1 = R1;
TestResource2 R2(1);
auto& P2 = R2.getController();
memory_resource const& M2 = R2;
assert(M1.is_equal(M2) == false);
assert(P1.checkIsEqualCalledEq(1));
assert(P2.checkIsEqualCalledEq(0));
assert(M2.is_equal(M1) == false);
assert(P2.checkIsEqualCalledEq(1));
assert(P1.checkIsEqualCalledEq(1));
}
{
TestResource1 R1(1);
auto& P1 = R1.getController();
memory_resource const& M1 = R1;
TestResource1 R2(2);
auto& P2 = R2.getController();
memory_resource const& M2 = R2;
assert(M1.is_equal(M2) == false);
assert(P1.checkIsEqualCalledEq(1));
assert(P2.checkIsEqualCalledEq(0));
assert(M2.is_equal(M1) == false);
assert(P2.checkIsEqualCalledEq(1));
assert(P1.checkIsEqualCalledEq(1));
}
{
TestResource1 R1(1);
auto& P1 = R1.getController();
memory_resource const& M1 = R1;
TestResource1 R2(1);
auto& P2 = R2.getController();
memory_resource const& M2 = R2;
assert(M1.is_equal(M2) == true);
assert(P1.checkIsEqualCalledEq(1));
assert(P2.checkIsEqualCalledEq(0));
assert(M2.is_equal(M1) == true);
assert(P2.checkIsEqualCalledEq(1));
assert(P1.checkIsEqualCalledEq(1));
}
}

test/support/test_experimental_memory_resource.hpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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_EXPERIMENTAL_MEMORY_RESOURCE_HPP
#define SUPPORT_TEST_EXPERIMENTAL_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_EXPERIMENTAL_MEMORY_RESOURCE_HPP */

test/support/test_memory_resource.hpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SUPPORT_TEST_MEMORY_RESOURCE_HPP #ifndef SUPPORT_TEST_MEMORY_RESOURCE_HPP
#define SUPPORT_TEST_MEMORY_RESOURCE_HPP #define SUPPORT_TEST_MEMORY_RESOURCE_HPP
#include <experimental/memory_resource>
#include <experimental/utility>
#include <memory> #include <memory>
#include <memory_resource>
#include <type_traits> #include <type_traits>
#include <utility>
#include <cstddef> #include <cstddef>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <cstdint> #include <cstdint>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "controlled_allocators.hpp" #include "controlled_allocators.hpp"
#include "uses_alloc_types.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> template <class ProviderT, int = 0>
class TestResourceImp : public std::experimental::pmr::memory_resource class TestResourceImp : public std::pmr::memory_resource
{ {
public: public:
static int resource_alive; static int resource_alive;
static int resource_constructed; static int resource_constructed;
static int resource_destructed; static int resource_destructed;
static void resetStatics() { static void resetStatics() {
assert(resource_alive == 0); assert(resource_alive == 0);
resource_alive = 0; resource_alive = 0;
resource_constructed = 0; resource_constructed = 0;
resource_destructed = 0; resource_destructed = 0;
} }
using memory_resource = std::experimental::pmr::memory_resource; using memory_resource = std::pmr::memory_resource;
using Provider = ProviderT; using Provider = ProviderT;
int value; int value;
explicit TestResourceImp(int val = 0) : value(val) { explicit TestResourceImp(int val = 0) : value(val) {
++resource_alive; ++resource_alive;
++resource_constructed; ++resource_constructed;
} }
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

test/support/uses_alloc_types.hpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines
using EnableIfB = typename std::enable_if<Value, bool>::type; using EnableIfB = typename std::enable_if<Value, bool>::type;
} // end namespace detail } // end namespace detail
// FIXME: UsesAllocatorTestBase needs some special logic to deal with // FIXME: UsesAllocatorTestBase needs some special logic to deal with
// polymorphic allocators. However we don't want to include // polymorphic allocators. However we don't want to include
// <experimental/memory_resource> in this header. Therefore in order // <experimental/memory_resource> in this header. Therefore in order
// to inject this behavior later we use a trait. // to inject this behavior later we use a trait.
// See test_memory_resource.hpp for more info. // See test_experimental_memory_resource.hpp for more info.
template <class Alloc> template <class Alloc>
struct TransformErasedTypeAlloc { struct TransformErasedTypeAlloc {
using type = Alloc; using type = Alloc;
}; };
using detail::EnableIfB; using detail::EnableIfB;
struct AllocLastTag {}; struct AllocLastTag {};
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

utils/generate_feature_test_macro_components.py

Show First 20 Lines • Show All 279 Lines • ▼ Show 20 Linesfeature_test_macros = sorted([ add_version_header(x) for x in [
"headers": ["memory"], "headers": ["memory"],
"unimplemented": True, "unimplemented": True,
}, },
{"name": "__cpp_lib_memory_resource", {"name": "__cpp_lib_memory_resource",
"values": { "values": {
"c++17": 201603L, "c++17": 201603L,
}, },
"headers": ["memory_resource"], "headers": ["memory_resource"],
"unimplemented": True,
}, },
{"name": "__cpp_lib_boyer_moore_searcher", {"name": "__cpp_lib_boyer_moore_searcher",
"values": { "values": {
"c++17": 201603L, "c++17": 201603L,
}, },
"headers": ["functional"], "headers": ["functional"],
"unimplemented": True, "unimplemented": True,
}, },
▲ Show 20 Lines • Show All 563 Lines • ▼ Show 20 Lines
{cxx17_tests} {cxx17_tests}
#elif TEST_STD_VER > 17 #elif TEST_STD_VER > 17
{cxx2a_tests} {cxx2a_tests}
#endif // TEST_STD_VER > 17 #endif // TEST_STD_VER > 17
int main(int, char**) { return 0; } int main(int, char**) {{ return 0; }}
""".format(script_name=script_name, """.format(script_name=script_name,
header=h, header=h,
test_tags=test_tags, test_tags=test_tags,
synopsis=generate_synopsis(test_list), synopsis=generate_synopsis(test_list),
cxx11_tests=generate_std_test(test_list, 'c++11').strip(), cxx11_tests=generate_std_test(test_list, 'c++11').strip(),
cxx14_tests=generate_std_test(test_list, 'c++14').strip(), cxx14_tests=generate_std_test(test_list, 'c++14').strip(),
cxx17_tests=generate_std_test(test_list, 'c++17').strip(), cxx17_tests=generate_std_test(test_list, 'c++17').strip(),
cxx2a_tests=generate_std_test(test_list, 'c++2a').strip()) cxx2a_tests=generate_std_test(test_list, 'c++2a').strip())
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines