Line data    Source code

       1              : //
       2              : // Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)
       3              : //
       4              : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5              : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6              : //
       7              : // Official repository: https://github.com/cppalliance/capy
       8              : //
       9              : 
      10              : #include <boost/capy/ex/recycling_memory_resource.hpp>
      11              : 
      12              : namespace boost {
      13              : namespace capy {
      14              : 
      15           37 : recycling_memory_resource::~recycling_memory_resource() = default;
      16              : 
      17              : recycling_memory_resource::pool&
      18           97 : recycling_memory_resource::global() noexcept
      19              : {
      20           97 :     static pool p;
      21           97 :     return p;
      22              : }
      23              : 
      24              : std::mutex&
      25           97 : recycling_memory_resource::global_mutex() noexcept
      26              : {
      27              :     static std::mutex mtx;
      28           97 :     return mtx;
      29              : }
      30              : 
      31              : void*
      32           93 : recycling_memory_resource::allocate_slow(
      33              :     std::size_t rounded, std::size_t idx)
      34              : {
      35              :     {
      36           93 :         std::lock_guard<std::mutex> lock(global_mutex());
      37           93 :         if(auto* p = global().buckets[idx].pop(local().buckets[idx]))
      38            0 :             return p;
      39           93 :     }
      40           93 :     return ::operator new(rounded);
      41              : }
      42              : 
      43              : void
      44            4 : recycling_memory_resource::deallocate_slow(
      45              :     void* p, std::size_t idx)
      46              : {
      47              :     {
      48            4 :         std::lock_guard<std::mutex> lock(global_mutex());
      49            4 :         if(global().buckets[idx].push(p))
      50            4 :             return;
      51            4 :     }
      52            0 :     ::operator delete(p);
      53              : }
      54              : 
      55              : void*
      56         2012 : recycling_memory_resource::do_allocate(std::size_t bytes, std::size_t alignment)
      57              : {
      58         2012 :     return allocate_fast(bytes, alignment);
      59              : }
      60              : 
      61              : void
      62         2012 : recycling_memory_resource::do_deallocate(void* p, std::size_t bytes, std::size_t alignment)
      63              : {
      64         2012 :     deallocate_fast(p, bytes, alignment);
      65         2012 : }
      66              : 
      67              : std::pmr::memory_resource*
      68         2141 : get_recycling_memory_resource() noexcept
      69              : {
      70         2141 :     static recycling_memory_resource instance;
      71         2141 :     return &instance;
      72              : }
      73              : 
      74              : } // namespace capy
      75              : } // namespace boost