100.00% Lines (69/69)
100.00% Functions (10/10)
| TLA | Baseline | Branch | ||||||
|---|---|---|---|---|---|---|---|---|
| Line | Hits | Code | Line | Hits | Code | |||
| 1 | // | 1 | // | |||||
| 2 | // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) | 2 | // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) | |||||
| 3 | // Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com) | 3 | // Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com) | |||||
| 4 | // | 4 | // | |||||
| 5 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | 5 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |||||
| 6 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | 6 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |||||
| 7 | // | 7 | // | |||||
| 8 | // Official repository: https://github.com/boostorg/json | 8 | // Official repository: https://github.com/boostorg/json | |||||
| 9 | // | 9 | // | |||||
| 10 | 10 | |||||||
| 11 | #ifndef BOOST_JSON_IMPL_MONOTONIC_RESOURCE_IPP | 11 | #ifndef BOOST_JSON_IMPL_MONOTONIC_RESOURCE_IPP | |||||
| 12 | #define BOOST_JSON_IMPL_MONOTONIC_RESOURCE_IPP | 12 | #define BOOST_JSON_IMPL_MONOTONIC_RESOURCE_IPP | |||||
| 13 | 13 | |||||||
| 14 | #include <boost/json/monotonic_resource.hpp> | 14 | #include <boost/json/monotonic_resource.hpp> | |||||
| 15 | #include <boost/json/detail/except.hpp> | 15 | #include <boost/json/detail/except.hpp> | |||||
| 16 | - | #include <boost/throw_exception.hpp> | ||||||
| 17 | #include <boost/core/max_align.hpp> | 16 | #include <boost/core/max_align.hpp> | |||||
| 18 | 17 | |||||||
| 19 | - | #include <new> | ||||||
| 20 | #include <memory> | 18 | #include <memory> | |||||
| 21 | 19 | |||||||
| 22 | namespace boost { | 20 | namespace boost { | |||||
| 23 | namespace json { | 21 | namespace json { | |||||
| 24 | 22 | |||||||
| 25 | struct alignas(core::max_align_t) | 23 | struct alignas(core::max_align_t) | |||||
| 26 | monotonic_resource::block : block_base | 24 | monotonic_resource::block : block_base | |||||
| 27 | { | 25 | { | |||||
| 28 | }; | 26 | }; | |||||
| 29 | 27 | |||||||
| 30 | constexpr | 28 | constexpr | |||||
| 31 | std::size_t | 29 | std::size_t | |||||
| HITCBC | 32 | 210 | monotonic_resource:: | 30 | 165 | monotonic_resource:: | ||
| 33 | max_size() | 31 | max_size() | |||||
| 34 | { | 32 | { | |||||
| HITCBC | 35 | 210 | return std::size_t(-1) - sizeof(block); | 33 | 165 | return std::size_t(-1) - sizeof(block); | ||
| 36 | } | 34 | } | |||||
| 37 | 35 | |||||||
| 38 | // lowest power of 2 greater than or equal to n | 36 | // lowest power of 2 greater than or equal to n | |||||
| 39 | std::size_t | 37 | std::size_t | |||||
| HITCBC | 40 | 46 | monotonic_resource:: | 38 | 43 | monotonic_resource:: | ||
| 41 | round_pow2( | 39 | round_pow2( | |||||
| 42 | std::size_t n) noexcept | 40 | std::size_t n) noexcept | |||||
| 43 | { | 41 | { | |||||
| HITCBC | 44 | 46 | if(n & (n - 1)) | 42 | 43 | if(n & (n - 1)) | ||
| HITCBC | 45 | 8 | return next_pow2(n); | 43 | 7 | return next_pow2(n); | ||
| HITCBC | 46 | 38 | return n; | 44 | 36 | return n; | ||
| 47 | } | 45 | } | |||||
| 48 | 46 | |||||||
| 49 | // lowest power of 2 greater than n | 47 | // lowest power of 2 greater than n | |||||
| 50 | std::size_t | 48 | std::size_t | |||||
| HITCBC | 51 | 55 | monotonic_resource:: | 49 | 53 | monotonic_resource:: | ||
| 52 | next_pow2( | 50 | next_pow2( | |||||
| 53 | std::size_t n) noexcept | 51 | std::size_t n) noexcept | |||||
| 54 | { | 52 | { | |||||
| HITCBC | 55 | 55 | std::size_t result = min_size_; | 53 | 53 | std::size_t result = min_size_; | ||
| HITCBC | 56 | 225 | while(result <= n) | 54 | 216 | while(result <= n) | ||
| 57 | { | 55 | { | |||||
| HITCBC | 58 | 171 | if(result >= max_size() - result) | 56 | 164 | if(result >= max_size() - result) | ||
| 59 | { | 57 | { | |||||
| 60 | // overflow | 58 | // overflow | |||||
| HITCBC | 61 | 1 | result = max_size(); | 59 | 1 | result = max_size(); | ||
| HITCBC | 62 | 1 | break; | 60 | 1 | break; | ||
| 63 | } | 61 | } | |||||
| HITCBC | 64 | 170 | result *= 2; | 62 | 163 | result *= 2; | ||
| 65 | } | 63 | } | |||||
| HITCBC | 66 | 55 | return result; | 64 | 53 | return result; | ||
| 67 | } | 65 | } | |||||
| 68 | 66 | |||||||
| 69 | //---------------------------------------------------------- | 67 | //---------------------------------------------------------- | |||||
| 70 | 68 | |||||||
| HITCBC | 71 | 53 | monotonic_resource:: | 69 | 51 | monotonic_resource:: | ||
| HITCBC | 72 | 53 | ~monotonic_resource() | 70 | 51 | ~monotonic_resource() | ||
| 73 | { | 71 | { | |||||
| HITCBC | 74 | 53 | release(); | 72 | 51 | release(); | ||
| HITCBC | 75 | 53 | } | 73 | 51 | } | ||
| 76 | 74 | |||||||
| HITCBC | 77 | 43 | monotonic_resource:: | 75 | 41 | monotonic_resource:: | ||
| 78 | monotonic_resource( | 76 | monotonic_resource( | |||||
| 79 | std::size_t initial_size, | 77 | std::size_t initial_size, | |||||
| HITCBC | 80 | 43 | storage_ptr upstream) noexcept | 78 | 41 | storage_ptr upstream) noexcept | ||
| HITCBC | 81 | 43 | : buffer_{ | 79 | 41 | : buffer_{ | ||
| 82 | nullptr, 0, 0, nullptr} | 80 | nullptr, 0, 0, nullptr} | |||||
| HITCBC | 83 | 86 | , next_size_(round_pow2(initial_size)) | 81 | 82 | , next_size_(round_pow2(initial_size)) | ||
| HITCBC | 84 | 43 | , upstream_(std::move(upstream)) | 82 | 41 | , upstream_(std::move(upstream)) | ||
| 85 | { | 83 | { | |||||
| HITCBC | 86 | 43 | } | 84 | 41 | } | ||
| 87 | 85 | |||||||
| HITCBC | 88 | 10 | monotonic_resource:: | 86 | 10 | monotonic_resource:: | ||
| 89 | monotonic_resource( | 87 | monotonic_resource( | |||||
| 90 | unsigned char* buffer, | 88 | unsigned char* buffer, | |||||
| 91 | std::size_t size, | 89 | std::size_t size, | |||||
| HITCBC | 92 | 10 | storage_ptr upstream) noexcept | 90 | 10 | storage_ptr upstream) noexcept | ||
| HITCBC | 93 | 10 | : buffer_{ | 91 | 10 | : buffer_{ | ||
| 94 | buffer, size, size, nullptr} | 92 | buffer, size, size, nullptr} | |||||
| HITCBC | 95 | 20 | , next_size_(next_pow2(size)) | 93 | 20 | , next_size_(next_pow2(size)) | ||
| HITCBC | 96 | 10 | , upstream_(std::move(upstream)) | 94 | 10 | , upstream_(std::move(upstream)) | ||
| 97 | { | 95 | { | |||||
| HITCBC | 98 | 10 | } | 96 | 10 | } | ||
| 99 | 97 | |||||||
| 100 | void | 98 | void | |||||
| HITCBC | 101 | 54 | monotonic_resource:: | 99 | 52 | monotonic_resource:: | ||
| 102 | release() noexcept | 100 | release() noexcept | |||||
| 103 | { | 101 | { | |||||
| HITCBC | 104 | 54 | auto p = head_; | 102 | 52 | auto p = head_; | ||
| HITCBC | 105 | 91 | while(p != &buffer_) | 103 | 88 | while(p != &buffer_) | ||
| 106 | { | 104 | { | |||||
| HITCBC | 107 | 37 | auto next = p->next; | 105 | 36 | auto next = p->next; | ||
| HITCBC | 108 | 37 | upstream_->deallocate(p, sizeof(block) + p->size); | 106 | 36 | upstream_->deallocate(p, sizeof(block) + p->size); | ||
| HITCBC | 109 | 37 | p = next; | 107 | 36 | p = next; | ||
| 110 | } | 108 | } | |||||
| HITCBC | 111 | 54 | buffer_.p = reinterpret_cast< | 109 | 52 | buffer_.p = reinterpret_cast< | ||
| HITCBC | 112 | 54 | unsigned char*>(buffer_.p) - ( | 110 | 52 | unsigned char*>(buffer_.p) - ( | ||
| HITCBC | 113 | 54 | buffer_.size - buffer_.avail); | 111 | 52 | buffer_.size - buffer_.avail); | ||
| HITCBC | 114 | 54 | buffer_.avail = buffer_.size; | 112 | 52 | buffer_.avail = buffer_.size; | ||
| HITCBC | 115 | 54 | head_ = &buffer_; | 113 | 52 | head_ = &buffer_; | ||
| HITCBC | 116 | 54 | } | 114 | 52 | } | ||
| 117 | 115 | |||||||
| 118 | void* | 116 | void* | |||||
| HITCBC | 119 | 129502 | monotonic_resource:: | 117 | 129500 | monotonic_resource:: | ||
| 120 | do_allocate( | 118 | do_allocate( | |||||
| 121 | std::size_t n, | 119 | std::size_t n, | |||||
| 122 | std::size_t align) | 120 | std::size_t align) | |||||
| 123 | { | 121 | { | |||||
| HITCBC | 124 | 129502 | auto p = std::align(align, n, head_->p, head_->avail); | 122 | 129500 | auto p = std::align(align, n, head_->p, head_->avail); | ||
| HITCBC | 125 | 129502 | if(p) | 123 | 129500 | if(p) | ||
| 126 | { | 124 | { | |||||
| HITCBC | 127 | 129464 | head_->p = reinterpret_cast< | 125 | 129464 | head_->p = reinterpret_cast< | ||
| HITCBC | 128 | 129464 | unsigned char*>(p) + n; | 126 | 129464 | unsigned char*>(p) + n; | ||
| HITCBC | 129 | 129464 | head_->avail -= n; | 127 | 129464 | head_->avail -= n; | ||
| HITCBC | 130 | 129464 | return p; | 128 | 129464 | return p; | ||
| 131 | } | 129 | } | |||||
| 132 | 130 | |||||||
| HITGIC | 133 | - | // a new block is only aligned to alignof(block), so an | 131 | + | 36 | if(next_size_ < n) | |
| HITGIC | 134 | - | // over-aligned request may need up to align - alignof(block) | 132 | + | 2 | next_size_ = round_pow2(n); | |
| 135 | - | // bytes of padding in addition to n | ||||||
| DCB | 136 | - | 38 | std::size_t const pad = align > alignof(block) | ||||
| DCB | 137 | - | 38 | ? align - alignof(block) : 0; | ||||
| DCB | 138 | - | 38 | if(n > max_size() - pad) | ||||
| DCB | 139 | - | 2 | throw_exception( std::bad_alloc(), BOOST_CURRENT_LOCATION ); | ||||
| DCB | 140 | - | 37 | if(next_size_ < n + pad) | ||||
| DCB | 141 | - | 3 | next_size_ = round_pow2(n + pad); | ||||
| HITCBC | 142 | 37 | auto b = ::new(upstream_->allocate( | 133 | 36 | auto b = ::new(upstream_->allocate( | ||
| HITCBC | 143 | 37 | sizeof(block) + next_size_)) block; | 134 | 36 | sizeof(block) + next_size_)) block; | ||
| HITCBC | 144 | 37 | b->p = b + 1; | 135 | 36 | b->p = b + 1; | ||
| HITCBC | 145 | 37 | b->avail = next_size_; | 136 | 36 | b->avail = next_size_; | ||
| HITCBC | 146 | 37 | b->size = next_size_; | 137 | 36 | b->size = next_size_; | ||
| HITCBC | 147 | 37 | b->next = head_; | 138 | 36 | b->next = head_; | ||
| HITCBC | 148 | 37 | head_ = b; | 139 | 36 | head_ = b; | ||
| HITCBC | 149 | 37 | next_size_ = next_pow2(next_size_); | 140 | 36 | next_size_ = next_pow2(next_size_); | ||
| 150 | 141 | |||||||
| HITCBC | 151 | 37 | p = std::align(align, n, head_->p, head_->avail); | 142 | 36 | p = std::align(align, n, head_->p, head_->avail); | ||
| HITCBC | 152 | 37 | BOOST_ASSERT(p); | 143 | 36 | BOOST_ASSERT(p); | ||
| HITCBC | 153 | 37 | head_->p = reinterpret_cast< | 144 | 36 | head_->p = reinterpret_cast< | ||
| HITCBC | 154 | 37 | unsigned char*>(p) + n; | 145 | 36 | unsigned char*>(p) + n; | ||
| HITCBC | 155 | 37 | head_->avail -= n; | 146 | 36 | head_->avail -= n; | ||
| HITCBC | 156 | 37 | return p; | 147 | 36 | return p; | ||
| 157 | } | 148 | } | |||||
| 158 | 149 | |||||||
| 159 | void | 150 | void | |||||
| HITCBC | 160 | 29 | monotonic_resource:: | 151 | 29 | monotonic_resource:: | ||
| 161 | do_deallocate( | 152 | do_deallocate( | |||||
| 162 | void*, | 153 | void*, | |||||
| 163 | std::size_t, | 154 | std::size_t, | |||||
| 164 | std::size_t) | 155 | std::size_t) | |||||
| 165 | { | 156 | { | |||||
| 166 | // do nothing | 157 | // do nothing | |||||
| HITCBC | 167 | 29 | } | 158 | 29 | } | ||
| 168 | 159 | |||||||
| 169 | bool | 160 | bool | |||||
| HITCBC | 170 | 1 | monotonic_resource:: | 161 | 1 | monotonic_resource:: | ||
| 171 | do_is_equal( | 162 | do_is_equal( | |||||
| 172 | memory_resource const& mr) const noexcept | 163 | memory_resource const& mr) const noexcept | |||||
| 173 | { | 164 | { | |||||
| HITCBC | 174 | 1 | return this == &mr; | 165 | 1 | return this == &mr; | ||
| 175 | } | 166 | } | |||||
| 176 | 167 | |||||||
| 177 | } // namespace json | 168 | } // namespace json | |||||
| 178 | } // namespace boost | 169 | } // namespace boost | |||||
| 179 | 170 | |||||||
| 180 | #endif | 171 | #endif | |||||