]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/libc++/include/experimental/memory_resource
Merge libc++ trunk r300890, and update build glue.
[FreeBSD/FreeBSD.git] / contrib / libc++ / include / experimental / memory_resource
1 // -*- C++ -*-
2 //===------------------------ memory_resource -----------------------------===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10
11 #ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
12 #define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
13
14 /**
15     experimental/memory_resource synopsis
16
17 // C++1y
18
19 namespace std {
20 namespace experimental {
21 inline namespace fundamentals_v1 {
22 namespace pmr {
23
24   class memory_resource;
25
26   bool operator==(const memory_resource& a,
27                   const memory_resource& b) noexcept;
28   bool operator!=(const memory_resource& a,
29                   const memory_resource& b) noexcept;
30
31   template <class Tp> class polymorphic_allocator;
32
33   template <class T1, class T2>
34   bool operator==(const polymorphic_allocator<T1>& a,
35                   const polymorphic_allocator<T2>& b) noexcept;
36   template <class T1, class T2>
37   bool operator!=(const polymorphic_allocator<T1>& a,
38                   const polymorphic_allocator<T2>& b) noexcept;
39
40   // The name resource_adaptor_imp is for exposition only.
41   template <class Allocator> class resource_adaptor_imp;
42
43   template <class Allocator>
44     using resource_adaptor = resource_adaptor_imp<
45       allocator_traits<Allocator>::rebind_alloc<char>>;
46
47   // Global memory resources
48   memory_resource* new_delete_resource() noexcept;
49   memory_resource* null_memory_resource() noexcept;
50
51   // The default memory resource
52   memory_resource* set_default_resource(memory_resource* r) noexcept;
53   memory_resource* get_default_resource() noexcept;
54
55   // Standard memory resources
56   struct pool_options;
57   class synchronized_pool_resource;
58   class unsynchronized_pool_resource;
59   class monotonic_buffer_resource;
60
61 } // namespace pmr
62 } // namespace fundamentals_v1
63 } // namespace experimental
64 } // namespace std
65
66  */
67
68 #include <experimental/__config>
69 #include <experimental/__memory>
70 #include <limits>
71 #include <memory>
72 #include <new>
73 #include <stdexcept>
74 #include <tuple>
75 #include <type_traits>
76 #include <utility>
77 #include <cstddef>
78 #include <cstdlib>
79 #include <__debug>
80
81 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
82 #pragma GCC system_header
83 #endif
84
85 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
86
87 // Round __s up to next multiple of __a.
88 inline _LIBCPP_INLINE_VISIBILITY
89 size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
90 {
91     _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows");
92     return (__s + __a - 1) & ~(__a - 1);
93 }
94
95 // 8.5, memory.resource
96 class _LIBCPP_TEMPLATE_VIS memory_resource
97 {
98     static const size_t __max_align = alignof(max_align_t);
99
100 // 8.5.2, memory.resource.public
101 public:
102     virtual ~memory_resource() = default;
103
104     _LIBCPP_INLINE_VISIBILITY
105     void* allocate(size_t __bytes, size_t __align = __max_align)
106         { return do_allocate(__bytes, __align); }
107
108     _LIBCPP_INLINE_VISIBILITY
109     void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
110         { do_deallocate(__p, __bytes, __align); }
111
112     _LIBCPP_INLINE_VISIBILITY
113     bool is_equal(memory_resource const & __other) const _NOEXCEPT
114         { return do_is_equal(__other); }
115
116 // 8.5.3, memory.resource.priv
117 protected:
118     virtual void* do_allocate(size_t, size_t) = 0;
119     virtual void do_deallocate(void*, size_t, size_t) = 0;
120     virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
121 };
122
123 // 8.5.4, memory.resource.eq
124 inline _LIBCPP_INLINE_VISIBILITY
125 bool operator==(memory_resource const & __lhs,
126                 memory_resource const & __rhs) _NOEXCEPT
127 {
128     return &__lhs == &__rhs || __lhs.is_equal(__rhs);
129 }
130
131 inline _LIBCPP_INLINE_VISIBILITY
132 bool operator!=(memory_resource const & __lhs,
133                 memory_resource const & __rhs) _NOEXCEPT
134 {
135     return !(__lhs == __rhs);
136 }
137
138 _LIBCPP_FUNC_VIS
139 memory_resource * new_delete_resource() _NOEXCEPT;
140
141 _LIBCPP_FUNC_VIS
142 memory_resource * null_memory_resource() _NOEXCEPT;
143
144 _LIBCPP_FUNC_VIS
145 memory_resource * get_default_resource() _NOEXCEPT;
146
147 _LIBCPP_FUNC_VIS
148 memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
149
150 // 8.6, memory.polymorphic.allocator.class
151
152 // 8.6.1, memory.polymorphic.allocator.overview
153 template <class _ValueType>
154 class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
155 {
156 public:
157     typedef _ValueType value_type;
158
159     // 8.6.2, memory.polymorphic.allocator.ctor
160     _LIBCPP_INLINE_VISIBILITY
161     polymorphic_allocator() _NOEXCEPT
162       : __res_(_VSTD_LFTS_PMR::get_default_resource())
163     {}
164
165     _LIBCPP_INLINE_VISIBILITY
166     polymorphic_allocator(memory_resource * __r) _NOEXCEPT
167       : __res_(__r)
168     {}
169
170     polymorphic_allocator(polymorphic_allocator const &) = default;
171
172     template <class _Tp>
173     _LIBCPP_INLINE_VISIBILITY
174     polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
175       : __res_(__other.resource())
176     {}
177
178     polymorphic_allocator &
179     operator=(polymorphic_allocator const &) = delete;
180
181     // 8.6.3, memory.polymorphic.allocator.mem
182     _LIBCPP_INLINE_VISIBILITY
183     _ValueType* allocate(size_t __n) {
184         if (__n > __max_size()) {
185             __throw_length_error(
186                 "std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)"
187                 " 'n' exceeds maximum supported size");
188         }
189         return static_cast<_ValueType*>(
190             __res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
191         );
192     }
193
194     _LIBCPP_INLINE_VISIBILITY
195     void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
196         _LIBCPP_ASSERT(__n <= __max_size(),
197                        "deallocate called for size which exceeds max_size()");
198         __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
199     }
200
201     template <class _Tp, class ..._Ts>
202     _LIBCPP_INLINE_VISIBILITY
203     void construct(_Tp* __p, _Ts &&... __args)
204     {
205         _VSTD_LFTS::__lfts_user_alloc_construct(
206             __p, resource(), _VSTD::forward<_Ts>(__args)...
207           );
208     }
209
210     template <class _T1, class _T2, class ..._Args1, class ..._Args2>
211     _LIBCPP_INLINE_VISIBILITY
212     void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
213                    tuple<_Args1...> __x, tuple<_Args2...> __y)
214     {
215         ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
216           , __transform_tuple(
217               typename __lfts_uses_alloc_ctor<
218                   _T1, memory_resource*, _Args1...
219               >::type()
220             , _VSTD::move(__x)
221             , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
222           )
223           , __transform_tuple(
224               typename __lfts_uses_alloc_ctor<
225                   _T2, memory_resource*, _Args2...
226               >::type()
227             , _VSTD::move(__y)
228             , typename __make_tuple_indices<sizeof...(_Args2)>::type{}
229           )
230         );
231     }
232
233     template <class _T1, class _T2>
234     _LIBCPP_INLINE_VISIBILITY
235     void construct(pair<_T1, _T2>* __p) {
236         construct(__p, piecewise_construct, tuple<>(), tuple<>());
237     }
238
239     template <class _T1, class _T2, class _Up, class _Vp>
240     _LIBCPP_INLINE_VISIBILITY
241     void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
242         construct(__p, piecewise_construct
243           , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
244           , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
245     }
246
247     template <class _T1, class _T2, class _U1, class _U2>
248     _LIBCPP_INLINE_VISIBILITY
249     void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
250         construct(__p, piecewise_construct
251             , _VSTD::forward_as_tuple(__pr.first)
252             , _VSTD::forward_as_tuple(__pr.second));
253     }
254
255     template <class _T1, class _T2, class _U1, class _U2>
256     _LIBCPP_INLINE_VISIBILITY
257     void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
258         construct(__p, piecewise_construct
259             , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
260             , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
261     }
262
263     template <class _Tp>
264     _LIBCPP_INLINE_VISIBILITY
265     void destroy(_Tp * __p) _NOEXCEPT
266         { __p->~_Tp(); }
267
268     _LIBCPP_INLINE_VISIBILITY
269     polymorphic_allocator
270     select_on_container_copy_construction() const _NOEXCEPT
271         { return polymorphic_allocator(); }
272
273     _LIBCPP_INLINE_VISIBILITY
274     memory_resource * resource() const _NOEXCEPT
275         { return __res_; }
276
277 private:
278     template <class ..._Args, size_t ..._Idx>
279     _LIBCPP_INLINE_VISIBILITY
280     tuple<_Args&&...>
281     __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
282                       __tuple_indices<_Idx...>) const
283     {
284         return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
285     }
286
287     template <class ..._Args, size_t ..._Idx>
288     _LIBCPP_INLINE_VISIBILITY
289     tuple<allocator_arg_t const&, memory_resource*, _Args&&...>
290     __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
291                       __tuple_indices<_Idx...>) const
292     {
293         using _Tup = tuple<allocator_arg_t const&, memory_resource*, _Args&&...>;
294         return _Tup(allocator_arg, resource(),
295                     _VSTD::get<_Idx>(_VSTD::move(__t))...);
296     }
297
298     template <class ..._Args, size_t ..._Idx>
299     _LIBCPP_INLINE_VISIBILITY
300     tuple<_Args&&..., memory_resource*>
301     __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
302                       __tuple_indices<_Idx...>) const
303     {
304         using _Tup = tuple<_Args&&..., memory_resource*>;
305         return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., resource());
306     }
307
308     _LIBCPP_INLINE_VISIBILITY
309     size_t __max_size() const _NOEXCEPT
310         { return numeric_limits<size_t>::max() / sizeof(value_type); }
311
312     memory_resource * __res_;
313 };
314
315 // 8.6.4, memory.polymorphic.allocator.eq
316
317 template <class _Tp, class _Up>
318 inline _LIBCPP_INLINE_VISIBILITY
319 bool operator==(polymorphic_allocator<_Tp> const & __lhs,
320                 polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
321 {
322     return *__lhs.resource() == *__rhs.resource();
323 }
324
325 template <class _Tp, class _Up>
326 inline _LIBCPP_INLINE_VISIBILITY
327 bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
328                 polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
329 {
330     return !(__lhs == __rhs);
331 }
332
333 // 8.7, memory.resource.adaptor
334
335 // 8.7.1, memory.resource.adaptor.overview
336 template <class _CharAlloc>
337 class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
338   : public memory_resource
339 {
340     using _CTraits = allocator_traits<_CharAlloc>;
341     static_assert(is_same<typename _CTraits::value_type, char>::value
342                && is_same<typename _CTraits::pointer, char*>::value
343                && is_same<typename _CTraits::void_pointer, void*>::value, "");
344
345     static const size_t _MaxAlign = alignof(max_align_t);
346
347     using _Alloc = typename _CTraits::template rebind_alloc<
348             typename aligned_storage<_MaxAlign, _MaxAlign>::type
349         >;
350
351     using _ValueType = typename _Alloc::value_type;
352
353     _Alloc __alloc_;
354
355 public:
356     typedef _CharAlloc allocator_type;
357
358     __resource_adaptor_imp() = default;
359     __resource_adaptor_imp(__resource_adaptor_imp const &) = default;
360     __resource_adaptor_imp(__resource_adaptor_imp &&) = default;
361
362     // 8.7.2, memory.resource.adaptor.ctor
363
364     _LIBCPP_INLINE_VISIBILITY
365     explicit __resource_adaptor_imp(allocator_type const & __a)
366       : __alloc_(__a)
367     {}
368
369     _LIBCPP_INLINE_VISIBILITY
370     explicit __resource_adaptor_imp(allocator_type && __a)
371       : __alloc_(_VSTD::move(__a))
372     {}
373
374     __resource_adaptor_imp &
375     operator=(__resource_adaptor_imp const &) = default;
376
377     _LIBCPP_INLINE_VISIBILITY
378     allocator_type get_allocator() const
379     { return __alloc_; }
380
381 // 8.7.3, memory.resource.adaptor.mem
382 protected:
383     virtual void * do_allocate(size_t __bytes, size_t)
384     {
385         if (__bytes > __max_size()) {
386             __throw_length_error(
387                 "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)"
388                 " 'bytes' exceeds maximum supported size");
389         }
390         size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
391         return __alloc_.allocate(__s);
392     }
393
394     virtual void do_deallocate(void * __p, size_t __bytes, size_t)
395     {
396         _LIBCPP_ASSERT(__bytes <= __max_size(),
397             "do_deallocate called for size which exceeds the maximum allocation size");
398         size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
399         __alloc_.deallocate((_ValueType*)__p, __s);
400     }
401
402     virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT {
403         __resource_adaptor_imp const * __p
404           = dynamic_cast<__resource_adaptor_imp const *>(&__other);
405         return __p  ? __alloc_ == __p->__alloc_ : false;
406     }
407
408 private:
409     _LIBCPP_INLINE_VISIBILITY
410     size_t __max_size() const _NOEXCEPT {
411         return numeric_limits<size_t>::max() - _MaxAlign;
412     }
413 };
414
415 template <class _Alloc>
416 using resource_adaptor = __resource_adaptor_imp<
417     typename allocator_traits<_Alloc>::template rebind_alloc<char>
418   >;
419
420 _LIBCPP_END_NAMESPACE_LFTS_PMR
421
422 #endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */