// shared_ptr.cc
#include "mutex_pool.h"

namespace __gnu_internal _GLIBCXX_VISIBILITY(hidden)
{
  /* Returns different instances of __mutex depending on the passed index
   * in order to limit contention.
   */
  __gnu_cxx::__mutex&
  get_mutex(unsigned char i)
  {
#ifdef _GLIBCXX_CAN_ALIGNAS_DESTRUCTIVE_SIZE
    // Increase alignment to put each lock on a separate cache line.
    struct alignas(__GCC_DESTRUCTIVE_SIZE) M : __gnu_cxx::__mutex { };
#else
    using M = __gnu_cxx::__mutex;
#endif
    // Use a static buffer, so that the mutexes are not destructed
    // before potential users (or at all)
    static __attribute__ ((aligned(__alignof__(M))))
      char buffer[(sizeof (M)) * (mask + 1)];
    static M *m = new (buffer) M[mask + 1];
    return m[i];
  }
}

// mutex_pool.h
namespace __gnu_internal _GLIBCXX_VISIBILITY(hidden)
{
  const unsigned char mask = 0xf;
  const unsigned char invalid = mask + 1;

  /* Returns different instances of __mutex depending on the passed index
   * in order to limit contention.
   */
  __gnu_cxx::__mutex& get_mutex(unsigned char i);
}

template<typename _Tp>
struct _Sp_atomic { // 假设 64 位环境，16 字节
    // ...
    // An atomic version of __shared_count<> and __weak_count<>.
    // Stores a _Sp_counted_base<>* but uses the LSB as a lock.
    struct _Atomic_count // 8 字节
      {
      private:
        // 里面实际上是存储了一个指针，并且最低位有特殊含义。
        // 因为 atomic 模板类对指针类型有偏特化，而这里需要直接操作位表示，
        // 所以存储选择 uintptr_t 类型。
    	mutable __atomic_base<uintptr_t> _M_val{0}; // 8 字节
    	static constexpr uintptr_t _S_lock_bit{1};  // 注意是静态，在实例中不占空间
      };
private:
    typename _Tp::element_type* _M_ptr = nullptr; // 8 字节
    _Atomic_count _M_refcount;                    // 8 字节
};

template<typename _Tp>
struct atomic<shared_ptr<_Tp>> {
    // ...
    // 将实现转发到 _M_impl 上
private:
    _Sp_atomic<shared_ptr<_Tp>> _M_impl;
};

#include <benchmark/benchmark.h>
#include <memory>
#include <atomic>
#include <thread>
#include <vector>
#include <mutex>

// 可调整的常量
const int N_THREADS = 8;       // 线程数
const int N_SHARED_PTRS = 4;   // 共享指针数
const int N_OPERATIONS = 1000; // 每个线程的操作次数

// 共享指针数组
std::vector<std::shared_ptr<int>> shared_ptrs(N_SHARED_PTRS);

// 用于保护共享指针的互斥锁数组
std::vector<std::mutex> mutexes(N_SHARED_PTRS);

// 初始化共享指针（只执行一次）
void initialize_shared_ptrs() {
    for (int i = 0; i < N_SHARED_PTRS; ++i) {
        shared_ptrs[i] = std::make_shared<int>(0);
    }
}

// 使用 std::atomic_load 和 std::atomic_store
static void BM_AtomicLoadStore(benchmark::State& state) {
    // 初始化共享指针（只执行一次）
    initialize_shared_ptrs();

    for (auto _ : state) {
        std::vector<std::thread> threads;

        // 创建线程
        for (int i = 0; i < N_THREADS; ++i) {
            threads.emplace_back([i]() {
                int ptr_index = i % N_SHARED_PTRS; // 分配给线程的共享指针索引
                for (int j = 0; j < N_OPERATIONS; ++j) {
                    auto local_ptr = std::atomic_load(&shared_ptrs[ptr_index]);
                    std::atomic_store(&shared_ptrs[ptr_index], 
                        std::make_shared<int>(*local_ptr + 1));
                }
            });
        }

        // 等待所有线程完成
        for (auto& t : threads) {
            t.join();
        }
    }
}
BENCHMARK(BM_AtomicLoadStore);

// 使用 std::mutex 保护共享指针
static void BM_MutexProtected(benchmark::State& state) {
    // 初始化共享指针（只执行一次）
    initialize_shared_ptrs();

    for (auto _ : state) {
        std::vector<std::thread> threads;

        // 创建线程
        for (int i = 0; i < N_THREADS; ++i) {
            threads.emplace_back([i]() {
                int ptr_index = i % N_SHARED_PTRS; // 分配给线程的共享指针索引
                for (int j = 0; j < N_OPERATIONS; ++j) {
                    // Not exactly equivalent to std::atomic_load + std::atomic_store
                    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                    // std::lock_guard<std::mutex> lock(mutexes[ptr_index]);
                    // auto local_ptr = shared_ptrs[ptr_index];
                    // shared_ptrs[ptr_index] = std::make_shared<int>(*local_ptr + 1);
                    std::shared_ptr<int> local_ptr;
                    {
                        std::lock_guard<std::mutex> lock(mutexes[ptr_index]);
                        local_ptr = shared_ptrs[ptr_index];
                    }
                    {
                        std::lock_guard<std::mutex> lock(mutexes[ptr_index]);
                        shared_ptrs[ptr_index] = std::make_shared<int>(*local_ptr + 1);
                    }
                }
            });
        }

        // 等待所有线程完成
        for (auto& t : threads) {
            t.join();
        }
    }
}
BENCHMARK(BM_MutexProtected);

BENCHMARK_MAIN();

#1
-------------------------------------------------------------
Benchmark                   Time             CPU   Iterations
-------------------------------------------------------------
BM_AtomicLoadStore  248032779 ns     28470177 ns           13
BM_MutexProtected   237027562 ns     28843112 ns           25
BM_AtomicSharedPtr 1.8736e+10 ns     43095100 ns            1

#2
-------------------------------------------------------------
Benchmark                   Time             CPU   Iterations
-------------------------------------------------------------
BM_AtomicLoadStore  168213275 ns     46402056 ns           16
BM_MutexProtected   320855445 ns     39238330 ns           10
BM_AtomicSharedPtr 8455017155 ns     32803500 ns            1

import matplotlib.pyplot as plt

# 读取文件并提取数据
with open('benchmark.log', 'r') as file:
    lines = file.readlines()

# 初始化存储数据的字典
data = {
    'BM_AtomicLoadStore': {'n': [], 'time': []},
    'BM_MutexProtected': {'n': [], 'time': []},
    'BM_AtomicSharedPtr': {'n': [], 'time': []}
}

# 解析数据
current_n = None
for line in lines:
    if line.startswith('#'):
        current_n = int(line.strip().replace('#', ''))
    elif 'BM_' in line:
        parts = line.split()
        benchmark_name = parts[0]
        time_ns = float(parts[1].replace('ns', ''))
        data[benchmark_name]['n'].append(current_n)
        data[benchmark_name]['time'].append(time_ns)

# 绘制图形
plt.figure(figsize=(10, 6))

# 极端大的数据影响画图，头两个数据就不要了
data['BM_AtomicSharedPtr']['time'][0] = float('nan')
data['BM_AtomicSharedPtr']['time'][1] = float('nan')

for benchmark_name, values in data.items():
    plt.plot(values['n'], values['time'], marker='o', markersize=5, label=benchmark_name)

plt.xlabel('n')
plt.ylabel('Time (ns)')
plt.title('Benchmark Time vs n')
plt.legend()
plt.grid(True)
plt.show()

$ perf record ./build/main
...
$ perf report --demangle
... # 这里会在终端中显示不同函数运行占用的 CPU 时间

// 新增：atomic shared_ptr 数组
std::vector<std::atomic<std::shared_ptr<int>>> atomic_shared_ptrs(N_SHARED_PTRS);

static void BM_AtomicSharedPtr(benchmark::State& state) {
    // 初始化共享指针（只执行一次）
    initialize_shared_ptrs();

    for (auto _ : state) {
        std::vector<std::thread> threads;

        // 创建线程
        for (int i = 0; i < N_THREADS; ++i) {
            threads.emplace_back([i]() {
                int ptr_index = i % N_SHARED_PTRS; // 分配给线程的共享指针索引
                for (int j = 0; j < N_OPERATIONS; ++j) {
                    auto local_ptr = atomic_shared_ptrs[ptr_index].load(); // load
                    atomic_shared_ptrs[ptr_index].store(
                        std::make_shared<int>(*local_ptr + 1)); // store
                }
            });
        }

        // 等待所有线程完成
        for (auto& t : threads) {
            t.join();
        }
    }
}

BENCHMARK(BM_AtomicSharedPtr);