TLA  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 HIT          46 : recycling_memory_resource::~recycling_memory_resource() = default;
      16                 : 
      17                 : recycling_memory_resource::pool&
      18             111 : recycling_memory_resource::global() noexcept
      19                 : {
      20             111 :     static pool p;
      21             111 :     return p;
      22                 : }
      23                 : 
      24                 : std::mutex&
      25             111 : recycling_memory_resource::global_mutex() noexcept
      26                 : {
      27                 :     static std::mutex mtx;
      28             111 :     return mtx;
      29                 : }
      30                 : 
      31                 : void*
      32             107 : recycling_memory_resource::allocate_slow(
      33                 :     std::size_t rounded, std::size_t idx)
      34                 : {
      35                 :     {
      36             107 :         std::lock_guard<std::mutex> lock(global_mutex());
      37             107 :         if(auto* p = global().buckets[idx].pop(local().buckets[idx]))
      38 MIS           0 :             return p;
      39 HIT         107 :     }
      40             107 :     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 MIS           0 :     ::operator delete(p);
      53                 : }
      54                 : 
      55                 : void*
      56 HIT        2902 : recycling_memory_resource::do_allocate(std::size_t bytes, std::size_t alignment)
      57                 : {
      58            2902 :     return allocate_fast(bytes, alignment);
      59                 : }
      60                 : 
      61                 : void
      62            2902 : recycling_memory_resource::do_deallocate(void* p, std::size_t bytes, std::size_t alignment)
      63                 : {
      64            2902 :     deallocate_fast(p, bytes, alignment);
      65            2902 : }
      66                 : 
      67                 : std::pmr::memory_resource*
      68            3068 : get_recycling_memory_resource() noexcept
      69                 : {
      70            3068 :     static recycling_memory_resource instance;
      71            3068 :     return &instance;
      72                 : }
      73                 : 
      74                 : } // namespace capy
      75                 : } // namespace boost