C++26: Read-copy-update (RCU)

// Структура данных, которую мы защищаем
struct Config {
    std::string host;
    int port;
    std::vector<std::string> endpoints;
};
 
// Глобальный указатель на конфиг
std::atomic<Config*> g_config;
 
// Читатель - никакой синхронизации!
void reader_thread() {
    // Входим в критическую секцию RCU
    // (на самом деле это просто маркер для системы)
    Config* cfg = g_config.load(std::memory_order_acquire);
    
    // Работаем с данными свободно
    std::cout << cfg->host << ":" << cfg->port << "\n";
    
    // Выходим из секции
    // Система запоминает, что мы закончили
}

void writer_thread() {
    // Создаём новую версию
    Config* old_cfg = g_config.load(std::memory_order_relaxed);
    Config* new_cfg = new Config(*old_cfg);
    
    // Модифицируем копию
    new_cfg->port = 8080;
    new_cfg->endpoints.push_back("/api/v2");
    
    // Атомарно подменяем указатель
    g_config.store(new_cfg, std::memory_order_release);
    
    // А вот тут проблема - что делать со старым объектом?
    // delete old_cfg; // НЕЛЬЗЯ! Кто-то может ещё читать!
}

// Псевдокод внутренностей RCU-домена
class rcu_domain {
    std::atomic<uint64_t> current_epoch{0};
    std::vector<std::atomic<uint64_t>> reader_epochs; // по одному на поток
    
    void lock() {
        // Читатель фиксирует текущую эпоху
        size_t tid = get_thread_id();
        reader_epochs[tid].store(current_epoch.load(), 
                                 std::memory_order_relaxed);
    }
    
    void unlock() {
        // Читатель сигнализирует о выходе
        size_t tid = get_thread_id();
        reader_epochs[tid].store(UINT64_MAX, 
                                 std::memory_order_release);
    }
    
    void synchronize() {
        // Писатель ждёт завершения grace period
        uint64_t grace_epoch = ++current_epoch;
        
        // Ждём, пока все читатели "старой" эпохи выйдут
        for (auto& epoch : reader_epochs) {
            while (epoch.load(std::memory_order_acquire) < grace_epoch) {
                // Спин или yield
                std::this_thread::yield();
            }
        }
    }
};

struct TreeNode {
    int value;
    std::shared_ptr<TreeNode> left;
    std::shared_ptr<TreeNode> right;
};
 
// При обновлении копируем только путь до изменённого узла
std::shared_ptr<TreeNode> update_tree(
    std::shared_ptr<TreeNode> root, 
    int old_val, 
    int new_val
) {
    if (!root) return nullptr;
    
    if (root->value == old_val) {
        // Копируем только этот узел
        auto new_root = std::make_shared<TreeNode>();
        new_root->value = new_val;
        new_root->left = root->left;   // Переиспользуем
        new_root->right = root->right;
        return new_root;
    }
    
    // Копируем узел, рекурсивно обновляем детей
    auto new_root = std::make_shared<TreeNode>();
    new_root->value = root->value;
    new_root->left = update_tree(root->left, old_val, new_val);
    new_root->right = update_tree(root->right, old_val, new_val);
    return new_root;
}

void fast_reader() {
    // Маркируем начало секции
    std::rcu_default_domain().lock();
    
    Config* cfg = g_config.load(std::memory_order_acquire);
    process_config(cfg);
    
    // Маркируем конец
    std::rcu_default_domain().unlock();
}

void update_config() {
    Config* old_cfg = g_config.load(std::memory_order_relaxed);
    Config* new_cfg = new Config(*old_cfg);
    
    new_cfg->port = 9000;
    
    // Атомарная подмена
    g_config.store(new_cfg, std::memory_order_release);
    
    // Планируем удаление старой версии
    std::rcu_retire(old_cfg, [](Config* ptr) {
        delete ptr; // Будет вызван после grace period
    });
}

// Писатель
new_cfg->value = 42;              // 1
new_cfg->name = "updated";        // 2
g_config.store(new_cfg, release); // 3
 
// Читатель
auto cfg = g_config.load(acquire); // 4
int val = cfg->value;              // 5
string n = cfg->name;              // 6
 
// Гарантия: если 4 видит результат 3,
// то 5 и 6 увидят результаты 1 и 2

// Внутренности домена (упрощённо)
class rcu_domain_impl {
    std::vector<std::function<void()>> pending_deletes;
    std::mutex delete_mutex;
    
    void retire(std::function<void()> deleter) {
        std::lock_guard lock(delete_mutex);
        pending_deletes.push_back(deleter);
        
        // Если накопилось достаточно - запускаем очистку
        if (pending_deletes.size() > BATCH_SIZE) {
            flush_deletes();
        }
    }
    
    void flush_deletes() {
        auto batch = std::move(pending_deletes);
        pending_deletes.clear();
        
        // Асинхронно ждём grace period и удаляем
        std::thread([batch = std::move(batch)]() {
            wait_for_grace_period();
            for (auto& fn : batch) fn();
        }).detach();
    }
};

namespace std {
class rcu_domain {
public:
    // Маркировка начала критической секции
    void lock() noexcept;
    
    // Маркировка конца секции
    void unlock() noexcept;
    
    // Проверка, находимся ли мы в секции
    bool try_lock() noexcept;
};
 
// Глобальный домен по умолчанию
rcu_domain& rcu_default_domain() noexcept;
}

class rcu_guard {
    rcu_domain& domain_;
public:
    explicit rcu_guard(rcu_domain& d) : domain_(d) {
        domain_.lock();
    }
    
    ~rcu_guard() {
        domain_.unlock();
    }
    
    rcu_guard(const rcu_guard&) = delete;
    rcu_guard& operator=(const rcu_guard&) = delete;
};
 
// Использование
void read_operation() {
    rcu_guard guard(std::rcu_default_domain());
    
    auto* data = g_shared_data.load(std::memory_order_acquire);
    process(data);
    
    // Автоматический unlock при выходе из области видимости
}

struct Configuration : std::rcu_obj_base<Configuration> {
    std::string database_url;
    int connection_pool_size;
    std::vector<std::string> allowed_hosts;
    
    // Конструкторы, методы...
};
 
std::atomic<Configuration*> g_config{new Configuration()};
 
// Обновление
void update_database_url(std::string_view new_url) {
    auto* old = g_config.load(std::memory_order_relaxed);
    auto* updated = new Configuration(*old);
    
    updated->database_url = new_url;
    
    g_config.store(updated, std::memory_order_release);
    
    // Intrusive retire - объект сам управляет удалением
    old->retire();
}

// Обычная структура без модификаций
struct LegacyConfig {
    int timeout_ms;
    bool enable_cache;
};
 
std::atomic<LegacyConfig*> g_legacy{new LegacyConfig()};
 
void update_timeout(int new_timeout) {
    auto* old = g_legacy.load(std::memory_order_relaxed);
    auto* updated = new LegacyConfig(*old);
    
    updated->timeout_ms = new_timeout;
    
    g_legacy.store(updated, std::memory_order_release);
    
    // Явный вызов retire с лямбдой-деструктором
    std::rcu_retire(old, [](LegacyConfig* ptr) {
        delete ptr;
    });
}

void blocking_update() {
    auto* old = g_config.load(std::memory_order_relaxed);
    auto* updated = new Configuration(*old);
    
    updated->connection_pool_size = 20;
    
    g_config.store(updated, std::memory_order_release);
    
    // Ждём завершения grace period синхронно
    std::rcu_synchronize(std::rcu_default_domain());
    
    // Теперь безопасно удалить
    delete old;
}

// Писатель
std::atomic<Node*> head;
 
void insert(int value) {
    Node* new_node = new Node{value};
    Node* old_head = head.load(std::memory_order_relaxed);
    
    new_node->next = old_head;  // 1: установка связи
    
    head.store(new_node, std::memory_order_release);  // 2: публикация
}
 
// Читатель
void traverse() {
    rcu_guard guard(std::rcu_default_domain());
    
    Node* current = head.load(std::memory_order_acquire);  // 3: загрузка
    
    while (current) {
        process(current->value);  // 4: использование
        current = current->next;   // 5: переход
    }
}

class ThreadSafeCache {
    std::atomic<CacheData*> data_;
    std::mutex write_mutex_;  // Защита от конкурирующих писателей
    
public:
    std::string lookup(const std::string& key) {
        rcu_guard guard(std::rcu_default_domain());
        auto* snapshot = data_.load(std::memory_order_acquire);
        auto it = snapshot->map.find(key);
        return it != snapshot->map.end() ? it->second : "";
    }
    
    void update(const std::string& key, const std::string& value) {
        std::lock_guard lock(write_mutex_);  // Сериализация писателей
        
        auto* old = data_.load(std::memory_order_relaxed);
        auto* updated = new CacheData(*old);
        
        updated->map[key] = value;
        
        data_.store(updated, std::memory_order_release);
        std::rcu_retire(old, [](CacheData* p) { delete p; });
    }
};

template<typename T>
class RcuProtected {
    std::atomic<T*> ptr_;
    rcu_domain& domain_;
    std::mutex write_mutex_;
 
public:
    explicit RcuProtected(T* initial, 
                         rcu_domain& domain = std::rcu_default_domain())
        : ptr_(initial), domain_(domain) {}
 
    // Читатель - простой снимок
    template<typename Func>
    auto read(Func&& func) const {
        rcu_guard guard(domain_);
        T* snapshot = ptr_.load(std::memory_order_acquire);
        return func(*snapshot);
    }
 
    // Писатель - копирование, модификация, подмена
    template<typename Func>
    void update(Func&& modifier) {
        std::lock_guard lock(write_mutex_);
        
        T* old = ptr_.load(std::memory_order_relaxed);
        T* updated = new T(*old);
        
        modifier(*updated);
        
        ptr_.store(updated, std::memory_order_release);
        
        // Гарантированный retire
        std::rcu_retire(old, [](T* p) { delete p; });
    }
 
    ~RcuProtected() {
        // Синхронное ожидание перед удалением последней версии
        std::rcu_synchronize(domain_);
        delete ptr_.load(std::memory_order_relaxed);
    }
};

// Hazard pointers - стиль использования
std::atomic<Node*> head;
hazard_pointer hp;
 
void hp_reader() {
    Node* ptr;
    do {
        ptr = head.load(std::memory_order_acquire);
        hp.protect(ptr);  // Объявляем защиту
    } while (ptr != head.load(std::memory_order_acquire));  // Проверка гонки
    
    process(ptr);
    hp.reset();  // Снимаем защиту
}

void risky_operation() {
    rcu_guard guard(std::rcu_default_domain());
    
    auto* config = g_config.load(std::memory_order_acquire);
    
    if (config->value < 0) {
        throw std::runtime_error("Invalid config");  // Безопасно!
    }
    
    process(config);
    // unlock произойдёт автоматически при раскрутке стека
}

template<typename T, size_t PoolSize = 1024>
class RcuPool {
    std::array<T, PoolSize> storage_;
    std::atomic<size_t> next_{0};
    std::vector<size_t> free_list_;
    std::mutex free_mutex_;
 
public:
    T* allocate() {
        std::lock_guard lock(free_mutex_);
        if (!free_list_.empty()) {
            size_t idx = free_list_.back();
            free_list_.pop_back();
            return &storage_[idx];
        }
        
        size_t idx = next_.fetch_add(1, std::memory_order_relaxed);
        if (idx >= PoolSize) throw std::bad_alloc();
        return &storage_[idx];
    }
 
    void deallocate(T* ptr) {
        size_t idx = ptr - storage_.data();
        std::lock_guard lock(free_mutex_);
        free_list_.push_back(idx);
    }
};

void mass_update() {
    for (int i = 0; i < 1000; ++i) {
        update_config(i);  // Каждый вызывает retire
    }
    
    // Ждём завершения всех grace periods
    std::rcu_barrier(std::rcu_default_domain());
    
    // Теперь все старые версии удалены
    log("Cleanup completed");
}

class ServiceConfig {
    struct Settings {
        int timeout_ms;
        std::string backend_url;
        size_t max_connections;
        std::unordered_map<std::string, std::string> headers;
    };
    
    std::atomic<Settings*> current_;
    std::mutex update_mutex_;
    
public:
    ServiceConfig(Settings* initial) : current_(initial) {}
    
    // Читается тысячи раз в секунду - без блокировок
    template<typename Func>
    auto read(Func&& func) const {
        rcu_guard guard(std::rcu_default_domain());
        Settings* snapshot = current_.load(std::memory_order_acquire);
        return func(*snapshot);
    }
    
    // Обновляется раз в минуту - можем позволить копирование
    void update_timeout(int new_timeout) {
        std::lock_guard lock(update_mutex_);
        
        Settings* old = current_.load(std::memory_order_relaxed);
        Settings* updated = new Settings(*old);
        updated->timeout_ms = new_timeout;
        
        current_.store(updated, std::memory_order_release);
        std::rcu_retire(old, [](Settings* p) { delete p; });
    }
};
 
// Использование в hot path
void handle_request(const Request& req, ServiceConfig& cfg) {
    auto timeout = cfg.read([](const auto& s) { return s.timeout_ms; });
    auto url = cfg.read([](const auto& s) { return s.backend_url; });
    
    make_backend_call(url, timeout);
}

class EventBus {
    struct Subscribers {
        std::vector<std::function<void(const Event&)>> handlers;
    };
    
    std::atomic<Subscribers*> subs_{new Subscribers};
    std::mutex modify_mutex_;
    
public:
    // Вызывается постоянно - читаем список без блокировок
    void publish(const Event& event) {
        rcu_guard guard(std::rcu_default_domain());
        auto* snapshot = subs_.load(std::memory_order_acquire);
        
        for (const auto& handler : snapshot->handlers) {
            handler(event);
        }
    }
    
    // Вызывается редко - регистрация обработчика
    void subscribe(std::function<void(const Event&)> handler) {
        std::lock_guard lock(modify_mutex_);
        
        auto* old = subs_.load(std::memory_order_relaxed);
        auto* updated = new Subscribers(*old);
        updated->handlers.push_back(std::move(handler));
        
        subs_.store(updated, std::memory_order_release);
        std::rcu_retire(old, [](Subscribers* p) { delete p; });
    }
};

class CurrencyRates {
    struct RateTable {
        std::unordered_map<std::string, double> rates;
        std::chrono::system_clock::time_point updated_at;
    };
    
    std::atomic<RateTable*> table_{new RateTable};
    
public:
    double get_rate(const std::string& currency) const {
        rcu_guard guard(std::rcu_default_domain());
        auto* snapshot = table_.load(std::memory_order_acquire);
        
        auto it = snapshot->rates.find(currency);
        return it != snapshot->rates.end() ? it->second : 0.0;
    }
    
    void update_rates(std::unordered_map<std::string, double> new_rates) {
        auto* updated = new RateTable{
            std::move(new_rates),
            std::chrono::system_clock::now()
        };
        
        auto* old = table_.exchange(updated, std::memory_order_acq_rel);
        std::rcu_retire(old, [](RateTable* p) { delete p; });
    }
};

struct Node {
    int value;
    std::atomic<Node*> next;
    
    Node(int v, Node* n = nullptr) : value(v), next(n) {}
};
 
class RcuList {
    std::atomic<Node*> head_{nullptr};
    std::mutex write_mutex_;
    
public:
    void insert(int value) {
        std::lock_guard lock(write_mutex_);
        
        Node* new_node = new Node(value);
        Node* old_head = head_.load(std::memory_order_relaxed);
        new_node->next.store(old_head, std::memory_order_relaxed);
        
        head_.store(new_node, std::memory_order_release);
    }
    
    bool remove(int value) {
        std::lock_guard lock(write_mutex_);
        
        Node* prev = nullptr;
        Node* curr = head_.load(std::memory_order_acquire);
        
        while (curr && curr->value != value) {
            prev = curr;
            curr = curr->next.load(std::memory_order_acquire);
        }
        
        if (!curr) return false;
        
        Node* next = curr->next.load(std::memory_order_acquire);
        
        if (prev) {
            prev->next.store(next, std::memory_order_release);
        } else {
            head_.store(next, std::memory_order_release);
        }
        
        std::rcu_retire(curr, [](Node* p) { delete p; });
        return true;
    }
    
    template<typename Func>
    void for_each(Func&& func) const {
        rcu_guard guard(std::rcu_default_domain());
        Node* curr = head_.load(std::memory_order_acquire);
        
        while (curr) {
            func(curr->value);
            curr = curr->next.load(std::memory_order_acquire);
        }
    }
};

// Бенчмарк: защита простого счётчика
struct Counter {
    int value = 0;
};
 
// Вариант 1: mutex
std::mutex mtx;
Counter counter;
 
void increment_mutex() {
    std::lock_guard lock(mtx);
    counter.value++;
}
 
// Результат: 8 потоков, 1М операций
// Время: 1.2 секунды, ~800 нс на операцию
// CPU utilization: 40% (остальное - ожидание блокировки)

// Вариант 2: shared_mutex
std::shared_mutex sh_mtx;
Config config;
 
std::string read_shared() {
    std::shared_lock lock(sh_mtx);
    return config.data;  // 300 нс на операцию
}
 
// Вариант 3: RCU
std::atomic<Config*> rcu_config{&config};
 
std::string read_rcu() {
    rcu_guard guard(std::rcu_default_domain());
    auto* cfg = rcu_config.load(std::memory_order_acquire);
    return cfg->data;  // 25 нс на операцию
}

// Атомарный счётчик - просто, но дорого при contention
std::atomic<int> atomic_counter{0};
 
void increment_atomic() {
    int old = atomic_counter.load(std::memory_order_relaxed);
    while (!atomic_counter.compare_exchange_weak(
        old, old + 1,
        std::memory_order_release,
        std::memory_order_relaxed
    )) {
        // Спин в цикле при конфликте
    }
}
 
// 8 потоков, 1М операций: 800 мс
// При 32 потоках: 4.5 секунды (деградация)

// Антипаттерн: частые обновления
void hot_writer_loop() {
    for (int i = 0; i < 1000000; ++i) {
        auto* old = data.load(std::memory_order_relaxed);
        auto* updated = new Data(*old);  // Миллион аллокаций!
        updated->value = i;
        
        data.store(updated, std::memory_order_release);
        std::rcu_retire(old, [](Data* p) { delete p; });
    }
}
// Результат: OOM или жуткая фрагментация памяти

// НЕПРАВИЛЬНО - гонка между писателями!
void concurrent_writers() {
    // Поток 1
    auto* old1 = data.load(std::memory_order_relaxed);
    auto* new1 = new Config(*old1);
    new1->value = 42;
    
    // Поток 2 может прочитать тот же old1
    auto* old2 = data.load(std::memory_order_relaxed);
    auto* new2 = new Config(*old2);  
    new2->value = 100;
    
    // Оба подменяют указатель - один перетрёт другого
    data.store(new1, std::memory_order_release);
    data.store(new2, std::memory_order_release);
    
    // new1 потеряна, утечка памяти!
}

class SafeRcuData {
    std::atomic<Config*> data_;
    std::mutex write_lock_;  // Защита от конкурирующих писателей
    
public:
    void update(std::function<void(Config&)> modifier) {
        std::lock_guard lock(write_lock_);
        
        auto* old = data_.load(std::memory_order_relaxed);
        auto* updated = new Config(*old);
        modifier(*updated);
        
        data_.store(updated, std::memory_order_release);
        std::rcu_retire(old, [](Config* p) { delete p; });
    }
};

// Антипаттерн - длинная критическая секция
void slow_reader() {
    rcu_guard guard(std::rcu_default_domain());
    
    auto* config = g_config.load(std::memory_order_acquire);
    
    // Обработка занимает секунды
    for (auto& item : config->items) {
        process_item_slowly(item);  // Сетевой запрос, IO, вычисления
    }
    
    // За это время могло произойти 100 обновлений
    // Все старые версии ждут завершения ЭТОГО читателя
}

// ПРАВИЛЬНО - короткая секция
void fast_reader() {
    std::vector<Item> local_copy;
    
    {
        rcu_guard guard(std::rcu_default_domain());
        auto* config = g_config.load(std::memory_order_acquire);
        local_copy = config->items;  // Быстрое копирование
    }  // Секция закрыта
    
    // Теперь обрабатываем локальную копию без ограничений
    for (auto& item : local_copy) {
        process_item_slowly(item);
    }
}

// Катастрофа - burst обновлений
void update_burst() {
    for (int i = 0; i < 10000; ++i) {
        auto* old = data.load(std::memory_order_relaxed);
        auto* updated = new Config(*old);  // 10000 аллокаций
        updated->counter = i;
        
        data.store(updated, std::memory_order_release);
        std::rcu_retire(old, [](Config* p) { delete p; });
    }
    // Десятки тысяч версий в очереди на удаление
}

struct Metrics {
    std::atomic<uint64_t> request_count{0};
    std::atomic<uint64_t> error_count{0};
    double avg_latency{0.0};  // НЕ атомарное!
};
 
// ОПАСНО - нарушение порядка
void update_metrics() {
    auto* old = g_metrics.load(std::memory_order_relaxed);
    auto* updated = new Metrics(*old);
    
    updated->avg_latency = calculate_latency();  // 1
    updated->request_count.store(1000, std::memory_order_relaxed);  // 2
    
    g_metrics.store(updated, std::memory_order_release);  // 3
    
    // Читатель может увидеть:
    // - новый указатель (3)
    // - старое значение avg_latency (1 не синхронизировано!)
}

void safe_update() {
    auto* updated = new Metrics();
    
    updated->avg_latency = calculate_latency();
    updated->request_count.store(1000, std::memory_order_relaxed);
    
    // Явный барьер перед публикацией
    std::atomic_thread_fence(std::memory_order_release);
    
    auto* old = g_metrics.exchange(updated, std::memory_order_release);
    std::rcu_retire(old, [](Metrics* p) { delete p; });
}

struct Connection {
    int socket_fd;
    std::mutex internal_lock;
    
    ~Connection() {
        close(socket_fd);  // Когда это произойдёт?
    }
};
 
void dangerous_pattern() {
    auto* old = g_connection.load(std::memory_order_relaxed);
    auto* updated = new Connection(*old);
    
    g_connection.store(updated, std::memory_order_release);
    std::rcu_retire(old, [](Connection* p) { delete p; });
    
    // old всё ещё существует!
    // Её деструктор вызовется через 10-100 мс
    // Что если нужно освободить ресурсы немедленно?
}

struct ConnectionData {
    std::string host;
    int port;
    // Только данные, никаких ресурсов
};
 
class ConnectionManager {
    std::atomic<ConnectionData*> config_;
    std::shared_ptr<Socket> socket_;  // Ресурс живёт отдельно
    
    void update_config(ConnectionData* new_cfg) {
        auto* old = config_.exchange(new_cfg, std::memory_order_release);
        std::rcu_retire(old, [](ConnectionData* p) { delete p; });
        
        // Сокет пересоздаём явно, до retire
        socket_ = create_socket(new_cfg->host, new_cfg->port);
    }
};

// Теоретически возможно:
auto* ptr1 = new Config();  // Адрес 0x1000
g_config.store(ptr1, ...);
 
// Читатель сохраняет адрес
auto* reader_ptr = g_config.load(...);  // 0x1000
 
// Писатель обновляет
auto* ptr2 = new Config();
g_config.store(ptr2, ...);
delete ptr1;  // После grace period
 
// Позже аллокатор возвращает тот же адрес
auto* ptr3 = new Config();  // Снова 0x1000!
 
// Читатель сравнивает адреса и думает, что объект не менялся

// КАТАСТРОФА - блокировка в RCU-секции
void terrible_idea() {
    rcu_guard guard(std::rcu_default_domain());
    
    auto* config = g_config.load(std::memory_order_acquire);
    
    std::this_thread::sleep_for(std::chrono::seconds(1));  // НЕТ!!!
    
    // Grace period застрял на эту секунду
    // Все retire операции ждут
}

#include <atomic>
#include <chrono>
#include <fstream>
#include <iostream>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>
#include <experimental/simd>
 
// Структура конфигурации - только данные, без ресурсов
struct ServerConfig {
    std::string database_url;
    int connection_timeout_ms;
    size_t max_connections;
    std::unordered_map<std::string, std::string> service_endpoints;
    bool debug_mode;
    
    // Версия для отслеживания изменений
    uint64_t version{0};
    std::chrono::system_clock::time_point updated_at;
};
 
// RAII-обёртка для RCU-секций
class rcu_guard {
    std::rcu_domain& domain_;
public:
    explicit rcu_guard(std::rcu_domain& d) : domain_(d) {
        domain_.lock();
    }
    
    ~rcu_guard() {
        domain_.unlock();
    }
    
    rcu_guard(const rcu_guard&) = delete;
    rcu_guard& operator=(const rcu_guard&) = delete;
};

class ConfigManager {
    std::atomic<ServerConfig*> config_;
    std::mutex write_mutex_;
    
    // Метрики для мониторинга
    std::atomic<uint64_t> read_count_{0};
    std::atomic<uint64_t> update_count_{0};
    std::atomic<uint64_t> retire_count_{0};
    
public:
    explicit ConfigManager(ServerConfig* initial) 
        : config_(initial) {}
    
    // Безблокировочное чтение
    template<typename Func>
    auto read(Func&& func) const {
        read_count_.fetch_add(1, std::memory_order_relaxed);
        
        rcu_guard guard(std::rcu_default_domain());
        ServerConfig* snapshot = config_.load(std::memory_order_acquire);
        
        return func(*snapshot);
    }
    
    // Атомарное обновление с защитой от конкурирующих писателей
    template<typename Func>
    void update(Func&& modifier) {
        std::lock_guard<std::mutex> lock(write_mutex_);
        update_count_.fetch_add(1, std::memory_order_relaxed);
        
        ServerConfig* old = config_.load(std::memory_order_relaxed);
        ServerConfig* updated = new ServerConfig(*old);
        
        // Инкрементируем версию и обновляем timestamp
        updated->version = old->version + 1;
        updated->updated_at = std::chrono::system_clock::now();
        
        // Модификация данных через переданную функцию
        modifier(*updated);
        
        // Атомарная публикация новой версии
        config_.store(updated, std::memory_order_release);
        
        // Планируем удаление старой версии
        std::rcu_retire(old, [this](ServerConfig* ptr) {
            retire_count_.fetch_add(1, std::memory_order_relaxed);
            delete ptr;
        });
    }
    
    // Получение метрик для мониторинга
    struct Metrics {
        uint64_t reads;
        uint64_t updates;
        uint64_t retires;
        uint64_t current_version;
    };
    
    Metrics get_metrics() const {
        return {
            read_count_.load(std::memory_order_relaxed),
            update_count_.load(std::memory_order_relaxed),
            retire_count_.load(std::memory_order_relaxed),
            read([](const ServerConfig& cfg) { return cfg.version; })
        };
    }
    
    // Graceful shutdown - дожидаемся завершения всех grace periods
    ~ConfigManager() {
        std::rcu_synchronize(std::rcu_default_domain());
        delete config_.load(std::memory_order_relaxed);
    }
};

void reader_thread(const ConfigManager& mgr, int thread_id, 
                   std::atomic<bool>& running) {
    size_t local_reads = 0;
    
    while (running.load(std::memory_order_relaxed)) {
        // Читаем таймаут для эмуляции реальной работы
        auto timeout = mgr.read([](const ServerConfig& cfg) {
            return cfg.connection_timeout_ms;
        });
        
        // Эмулируем обработку - короткая пауза
        std::this_thread::sleep_for(std::chrono::microseconds(10));
        
        ++local_reads;
    }
    
    std::cout << "Reader " << thread_id << " completed " 
              << local_reads << " operations\n";
}
 
void writer_thread(ConfigManager& mgr, std::atomic<bool>& running) {
    int update_number = 0;
    
    while (running.load(std::memory_order_relaxed)) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        
        mgr.update([&](ServerConfig& cfg) {
            // Меняем таймаут каждую секунду
            cfg.connection_timeout_ms = 1000 + (update_number * 100);
            cfg.service_endpoints["api_v2"] = 
                "/api/v2/endpoint_" + std::to_string(update_number);
        });
        
        ++update_number;
        
        auto metrics = mgr.get_metrics();
        std::cout << "Update #" << update_number 
                  << " | Version: " << metrics.current_version
                  << " | Reads: " << metrics.reads
                  << " | Retires: " << metrics.retires << "\n";
    }
}

int main() {
    // Инициализация конфигурации
    auto* initial = new ServerConfig{
        "postgresql://localhost:5432/app",
        5000,
        100,
        {{"api_v1", "/api/v1"}, {"health", "/health"}},
        false,
        0,
        std::chrono::system_clock::now()
    };
    
    ConfigManager manager(initial);
    std::atomic<bool> running{true};
    
    // Запускаем читателей
    constexpr int NUM_READERS = 10;
    std::vector<std::thread> readers;
    readers.reserve(NUM_READERS);
    
    for (int i = 0; i < NUM_READERS; ++i) {
        readers.emplace_back(reader_thread, std::cref(manager), i, 
                            std::ref(running));
    }
    
    // Запускаем писателя
    std::thread writer(writer_thread, std::ref(manager), std::ref(running));
    
    // Работаем 10 секунд
    std::this_thread::sleep_for(std::chrono::seconds(10));
    
    // Останавливаем все потоки
    running.store(false, std::memory_order_relaxed);
    
    writer.join();
    for (auto& t : readers) {
        t.join();
    }
    
    // Финальная статистика
    auto final_metrics = manager.get_metrics();
    std::cout << "\n=== Final Statistics ===\n"
              << "Total reads: " << final_metrics.reads << "\n"
              << "Total updates: " << final_metrics.updates << "\n"
              << "Total retires: " << final_metrics.retires << "\n"
              << "Final version: " << final_metrics.current_version << "\n";
    
    return 0;
}

void update_with_metrics(Func&& modifier) {
    std::lock_guard<std::mutex> lock(write_mutex_);
    
    ServerConfig* old = config_.load(std::memory_order_relaxed);
    ServerConfig* updated = new ServerConfig(*old);
    
    modifier(*updated);
    config_.store(updated, std::memory_order_release);
    
    auto retire_time = std::chrono::steady_clock::now();
    
    std::rcu_retire(old, [this, retire_time](ServerConfig* ptr) {
        auto now = std::chrono::steady_clock::now();
        auto delay = std::chrono::duration_cast<std::chrono::microseconds>(
            now - retire_time
        ).count();
        
        latency_histogram_[delay / 1000]++;  // Группировка по миллисекундам
        delete ptr;
    });
}

template<size_t PoolSize = 128>
class ConfigPool {
    std::array<ServerConfig, PoolSize> storage_;
    std::bitset<PoolSize> used_;
    std::mutex pool_mutex_;
 
public:
    ServerConfig* allocate() {
        std::lock_guard lock(pool_mutex_);
        for (size_t i = 0; i < PoolSize; ++i) {
            if (!used_[i]) {
                used_[i] = true;
                return &storage_[i];
            }
        }
        throw std::bad_alloc();
    }
 
    void deallocate(ServerConfig* ptr) {
        std::lock_guard lock(pool_mutex_);
        size_t idx = ptr - storage_.data();
        used_[idx] = false;
    }
};