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