10 #ifndef MSGPACK_V1_CPP03_ZONE_HPP 11 #define MSGPACK_V1_CPP03_ZONE_HPP 24 finalizer(
void (*func)(
void*),
void* data):m_func(func), m_data(data) {}
25 void operator()() { m_func(m_data); }
26 void (*m_func)(
void*);
29 struct finalizer_array {
32 finalizer* fin = m_tail;
33 for(; fin != m_array; --fin) (*(fin-1))();
43 void push(
void (*func)(
void* data),
void* data)
45 finalizer* fin = m_tail;
48 push_expand(func, data);
57 void push_expand(
void (*func)(
void*),
void* data) {
58 const size_t nused = m_end - m_array;
61 nnext = (
sizeof(finalizer) < 72/2) ?
62 72 /
sizeof(finalizer) : 8;
67 static_cast<finalizer*
>(::realloc(m_array,
sizeof(finalizer) * nnext));
69 throw std::bad_alloc();
74 new (m_tail) finalizer(func, data);
86 chunk_list(
size_t chunk_size)
88 chunk* c =
static_cast<chunk*
>(::malloc(
sizeof(chunk) + chunk_size));
90 throw std::bad_alloc();
95 m_ptr =
reinterpret_cast<char*
>(c) +
sizeof(chunk);
102 chunk* n = c->m_next;
107 void clear(
size_t chunk_size)
111 chunk* n = c->m_next;
122 m_ptr =
reinterpret_cast<char*
>(m_head) +
sizeof(chunk);
129 chunk_list m_chunk_list;
130 finalizer_array m_finalizer_array;
141 template <
typename T>
147 static void*
operator new(std::size_t
size)
149 void* p = ::malloc(size);
150 if (!p)
throw std::bad_alloc();
153 static void operator delete(
void *p)
157 static void*
operator new(std::size_t
size,
void* place)
159 return ::operator
new(
size, place);
161 static void operator delete(
void* p,
void* place)
163 ::operator
delete(p, place);
167 template <
typename T>
170 template <
typename T,
typename A1>
173 template <
typename T,
typename A1,
typename A2>
176 template <
typename T,
typename A1,
typename A2,
typename A3>
179 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4>
180 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4);
182 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
183 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5);
185 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
186 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6);
188 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
189 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7);
191 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8>
192 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8);
194 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9>
195 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9);
197 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10>
198 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10);
200 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11>
201 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11);
203 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12>
204 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12);
206 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13>
207 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13);
209 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14>
210 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14);
212 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15>
213 T*
allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15);
218 void undo_allocate(
size_t size);
220 template <
typename T>
221 static void object_destruct(
void* obj);
223 template <
typename T>
224 static void object_delete(
void* obj);
226 static char* get_aligned(
char* ptr,
size_t align);
228 char* allocate_expand(
size_t size);
234 inline zone::zone(
size_t chunk_size) :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
238 inline char* zone::get_aligned(
char* ptr,
size_t align)
241 reinterpret_cast<char*
>(
242 reinterpret_cast<size_t>(
243 (ptr + (align - 1))) / align * align);
248 char* aligned = get_aligned(m_chunk_list.m_ptr, align);
249 size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
250 if (m_chunk_list.m_free < adjusted_size) {
251 size_t enough_size = size + align - 1;
252 char* ptr = allocate_expand(enough_size);
253 aligned = get_aligned(ptr, align);
254 adjusted_size = size + (aligned - m_chunk_list.m_ptr);
256 m_chunk_list.m_free -= adjusted_size;
257 m_chunk_list.m_ptr += adjusted_size;
263 char* ptr = m_chunk_list.m_ptr;
264 if(m_chunk_list.m_free < size) {
265 ptr = allocate_expand(size);
267 m_chunk_list.m_free -=
size;
268 m_chunk_list.m_ptr +=
size;
273 inline char* zone::allocate_expand(
size_t size)
275 chunk_list*
const cl = &m_chunk_list;
277 size_t sz = m_chunk_size;
280 size_t tmp_sz = sz * 2;
288 chunk* c =
static_cast<chunk*
>(::malloc(
sizeof(chunk) + sz));
289 if (!c)
throw std::bad_alloc();
291 char* ptr =
reinterpret_cast<char*
>(c) +
sizeof(chunk);
293 c->m_next = cl->m_head;
303 m_finalizer_array.push(func, data);
306 template <
typename T>
309 m_finalizer_array.push(&zone::object_delete<T>, obj.release());
314 m_finalizer_array.clear();
315 m_chunk_list.clear(m_chunk_size);
321 swap(m_chunk_size, o.m_chunk_size);
322 swap(m_chunk_list, o.m_chunk_list);
323 swap(m_finalizer_array, o.m_finalizer_array);
326 template <
typename T>
327 void zone::object_destruct(
void* obj)
329 static_cast<T*
>(obj)->~T();
332 template <
typename T>
333 void zone::object_delete(
void* obj)
335 delete static_cast<T*
>(obj);
338 inline void zone::undo_allocate(
size_t size)
340 m_chunk_list.m_ptr -=
size;
341 m_chunk_list.m_free +=
size;
347 return (size + align - 1) / align * align;
352 template <
typename T>
357 m_finalizer_array.push(&zone::object_destruct<T>, x);
359 undo_allocate(
sizeof(T));
365 --m_finalizer_array.m_tail;
366 undo_allocate(
sizeof(T));
371 template <
typename T,
typename A1>
376 m_finalizer_array.push(&zone::object_destruct<T>, x);
378 undo_allocate(
sizeof(T));
382 return new (x) T(a1);
384 --m_finalizer_array.m_tail;
385 undo_allocate(
sizeof(T));
390 template <
typename T,
typename A1,
typename A2>
395 m_finalizer_array.push(&zone::object_destruct<T>, x);
397 undo_allocate(
sizeof(T));
401 return new (x) T(a1, a2);
403 --m_finalizer_array.m_tail;
404 undo_allocate(
sizeof(T));
409 template <
typename T,
typename A1,
typename A2,
typename A3>
414 m_finalizer_array.push(&zone::object_destruct<T>, x);
416 undo_allocate(
sizeof(T));
420 return new (x) T(a1, a2, a3);
422 --m_finalizer_array.m_tail;
423 undo_allocate(
sizeof(T));
428 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4>
433 m_finalizer_array.push(&zone::object_destruct<T>, x);
435 undo_allocate(
sizeof(T));
439 return new (x) T(a1, a2, a3, a4);
441 --m_finalizer_array.m_tail;
442 undo_allocate(
sizeof(T));
447 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5>
452 m_finalizer_array.push(&zone::object_destruct<T>, x);
454 undo_allocate(
sizeof(T));
458 return new (x) T(a1, a2, a3, a4, a5);
460 --m_finalizer_array.m_tail;
461 undo_allocate(
sizeof(T));
466 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6>
471 m_finalizer_array.push(&zone::object_destruct<T>, x);
473 undo_allocate(
sizeof(T));
477 return new (x) T(a1, a2, a3, a4, a5, a6);
479 --m_finalizer_array.m_tail;
480 undo_allocate(
sizeof(T));
485 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7>
486 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
490 m_finalizer_array.push(&zone::object_destruct<T>, x);
492 undo_allocate(
sizeof(T));
496 return new (x) T(a1, a2, a3, a4, a5, a6, a7);
498 --m_finalizer_array.m_tail;
499 undo_allocate(
sizeof(T));
504 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8>
505 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
509 m_finalizer_array.push(&zone::object_destruct<T>, x);
511 undo_allocate(
sizeof(T));
515 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8);
517 --m_finalizer_array.m_tail;
518 undo_allocate(
sizeof(T));
523 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9>
524 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
528 m_finalizer_array.push(&zone::object_destruct<T>, x);
530 undo_allocate(
sizeof(T));
534 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
536 --m_finalizer_array.m_tail;
537 undo_allocate(
sizeof(T));
542 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10>
543 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
547 m_finalizer_array.push(&zone::object_destruct<T>, x);
549 undo_allocate(
sizeof(T));
553 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
555 --m_finalizer_array.m_tail;
556 undo_allocate(
sizeof(T));
561 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11>
562 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11)
566 m_finalizer_array.push(&zone::object_destruct<T>, x);
568 undo_allocate(
sizeof(T));
572 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
574 --m_finalizer_array.m_tail;
575 undo_allocate(
sizeof(T));
580 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12>
581 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12)
585 m_finalizer_array.push(&zone::object_destruct<T>, x);
587 undo_allocate(
sizeof(T));
591 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
593 --m_finalizer_array.m_tail;
594 undo_allocate(
sizeof(T));
599 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13>
600 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13)
604 m_finalizer_array.push(&zone::object_destruct<T>, x);
606 undo_allocate(
sizeof(T));
610 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
612 --m_finalizer_array.m_tail;
613 undo_allocate(
sizeof(T));
618 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14>
619 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14)
623 m_finalizer_array.push(&zone::object_destruct<T>, x);
625 undo_allocate(
sizeof(T));
629 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
631 --m_finalizer_array.m_tail;
632 undo_allocate(
sizeof(T));
637 template <
typename T,
typename A1,
typename A2,
typename A3,
typename A4,
typename A5,
typename A6,
typename A7,
typename A8,
typename A9,
typename A10,
typename A11,
typename A12,
typename A13,
typename A14,
typename A15>
638 T*
zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15)
642 m_finalizer_array.push(&zone::object_destruct<T>, x);
644 undo_allocate(
sizeof(T));
648 return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
650 --m_finalizer_array.m_tail;
651 undo_allocate(
sizeof(T));
664 #endif // MSGPACK_V1_CPP03_ZONE_HPP void * allocate_align(size_t size, size_t align=MSGPACK_ZONE_ALIGN)
Definition: cpp03_zone.hpp:246
void * allocate_no_align(size_t size)
Definition: cpp03_zone.hpp:261
Definition: adaptor_base.hpp:15
std::size_t aligned_size(std::size_t size, std::size_t align)
Definition: cpp03_zone.hpp:344
Definition: cpp03_zone.hpp:22
Definition: cpp_config_decl.hpp:47
void push_finalizer(void(*func)(void *), void *data)
Definition: cpp03_zone.hpp:301
#define MSGPACK_ZONE_ALIGN
Definition: cpp03_zone_decl.hpp:24
std::size_t size(T const &t)
Definition: size_equal_only.hpp:24
void clear()
Definition: cpp03_zone.hpp:312
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
#define MSGPACK_ZONE_CHUNK_SIZE
Definition: cpp03_zone_decl.hpp:20
#define MSGPACK_ZONE_ALIGNOF(type)
Definition: cpp03_zone_decl.hpp:30
void swap(zone &o)
Definition: cpp03_zone.hpp:318
T * allocate(Args... args)
Definition: cpp11_zone.hpp:336
zone(size_t chunk_size=MSGPACK_ZONE_CHUNK_SIZE)
Definition: cpp03_zone.hpp:234
#define MSGPACK_NULLPTR
Definition: cpp_config_decl.hpp:35