// Структура данных, которую мы защищаем
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;
    }
};

// Типичный код с интринсиками до C++26
__m128 a = _mm_set_ps(4.0f, 3.0f, 2.0f, 1.0f);
__m128 b = _mm_set_ps(8.0f, 7.0f, 6.0f, 5.0f);
__m128 c = _mm_add_ps(a, b);  // Векторное сложение

// Современный подход с data-parallel types в C++26
std::simd<float> a = {1.0f, 2.0f, 3.0f, 4.0f};
std::simd<float> b = {5.0f, 6.0f, 7.0f, 8.0f};
std::simd<float> c = a + b;  // То же самое векторное сложение, но портабельно!

std::vector<float> a = {1.0f, 2.0f, 3.0f, 4.0f};
std::vector<float> b = {5.0f, 6.0f, 7.0f, 8.0f};
std::vector<float> result(a.size());
 
for (size_t i = 0; i < a.size(); ++i) {
    result[i] = a[i] + b[i];  // Последовательная обработка
}

std::simd<float> a = {1.0f, 2.0f, 3.0f, 4.0f};
std::simd<float> b = {5.0f, 6.0f, 7.0f, 8.0f};
std::simd<float> result = a + b;  // Параллельная обработка всех элементов

#ifdef __AVX2__
    // Реализация для AVX2
#elif defined(__ARM_NEON)
    // Реализация для NEON
#else
    // Обычная реализация
#endif

template <typename T>
void process_array(T* data, size_t size) {
    using simd_t = std::simd<T>;
    constexpr size_t simd_size = simd_t::size();
    
    size_t i = 0;
    for (; i + simd_size <= size; i += simd_size) {
        simd_t values(data + i);
        values = some_operation(values);
        values.copy_to(data + i);
    }
    
    // Обработка остатка
    for (; i < size; ++i) {
        data[i] = some_operation_scalar(data[i]);
    }
}

for (int i = 0; i < size; ++i) {
    histogram[data[i]]++;
}

void add_arrays(float* a, float* b, float* result, int size) {
    for (int i = 0; i < size; ++i) {
        result[i] = a[i] + b[i];
    }
}

template <typename T>
void process_array(T* data, size_t size) {
    using simd_t = std::simd<T>;
    constexpr size_t simd_size = simd_t::size();
    
    // Обработка полных SIMD-векторов
    size_t i = 0;
    for (; i + simd_size <= size; i += simd_size) {
        simd_t values(data + i);
        // Обработка полного вектора
        values.copy_to(data + i);
    }
    
    // Обработка "хвоста" с помощью маски
    if (i < size) {
        size_t remaining = size - i;
        std::simd_mask<T> mask(false);
        for (size_t j = 0; j < remaining; ++j) {
            mask[j] = true;
        }
        
        simd_t values(data + i, mask);  // Загрузка с маской
        // Обработка с учетом маски
        values.copy_to(data + i, mask);  // Сохранение с маской
    }
}

// Выделение выровненной памяти (до C++17)
float* aligned_data = static_cast<float*>(
    _mm_malloc(size * sizeof(float), 32)  // Выравнивание на 32 байта (AVX)
);
 
// Современный подход с C++17
std::vector<float, aligned_allocator<float, 32>> data(size);

template <typename T>
void process_with_prefetch(T* data, size_t size) {
    using simd_t = std::simd<T>;
    constexpr size_t simd_size = simd_t::size();
    
    for (size_t i = 0; i < size; i += simd_size) {
        // Предварительная загрузка данных, которые понадобятся через несколько итераций
        if (i + simd_size * 16 < size) {
            __builtin_prefetch(data + i + simd_size * 16);
        }
        
        simd_t values(data + i);
        // Обработка...
        values.copy_to(data + i);
    }
}

std::vector<float> input = /* ... */;
std::vector<float> output(input.size());
 
std::transform(
    std::execution::par_unseq,  // Параллельное и векторизуемое выполнение
    input.begin(), input.end(),
    output.begin(),
    [](float x) { return std::sin(x); }
);

// Предполагаемый синтаксис в C++26
void f(std::vector<float>& data) {
    std::for_each(std::execution::simd, data.begin(), data.end(),
        [](auto& v) {
            v = std::sin(v);
        }
    );
}

// Создание вектора и заполнение одним значением
std::simd<float> a(3.14f);  // Все элементы равны 3.14
 
// Инициализация из массива
float data[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
std::simd<float> b(data);  // Загрузка из массива
 
// Инициализация списком (если количество элементов совпадает с шириной вектора)
std::simd<int> c = {1, 2, 3, 4};  // Работает только если std::simd<int>::size() == 4
 
// Инициализация с использованием генератора
std::simd<double> d = std::experimental::simd_cast<double>(
    std::iota(std::experimental::simd_index<std::simd<double>>)
);  // Заполнение последовательными числами [0, 1, 2, ...]

std::simd<float> a = {1.0f, 2.0f, 3.0f, 4.0f};
std::simd<float> b = {5.0f, 6.0f, 7.0f, 8.0f};
 
// Арифметические операции
std::simd<float> sum = a + b;      // {6.0f, 8.0f, 10.0f, 12.0f}
std::simd<float> diff = a - b;     // {-4.0f, -4.0f, -4.0f, -4.0f}
std::simd<float> prod = a * b;     // {5.0f, 12.0f, 21.0f, 32.0f}
std::simd<float> div = a / b;      // {0.2f, 0.333f, 0.428f, 0.5f}
 
// Смешанные операции со скалярами
std::simd<float> scaled = a * 2.0f;  // {2.0f, 4.0f, 6.0f, 8.0f}
 
// Встроенные функции
std::simd<float> sqr = std::sqrt(a); // {1.0f, 1.414f, 1.732f, 2.0f}
std::simd<float> e_pow = std::exp(a); // {2.718f, 7.389f, 20.086f, 54.598f}

std::simd<float> values = {1.0f, 2.0f, 3.0f, 4.0f};
std::simd<float> threshold(2.5f);
 
// Создание маски: true для элементов, где условие выполняется
std::simd_mask<float> mask = values > threshold;  // {false, false, true, true}
 
// Условное присваивание: заменить только элементы, где маска true
std::simd<float> result = values;
where(mask, result) = result * 2.0f;  // {1.0f, 2.0f, 6.0f, 8.0f}
 
// Условный выбор между двумя векторами
std::simd<float> a = {10.0f, 20.0f, 30.0f, 40.0f};
std::simd<float> b = {1.0f, 2.0f, 3.0f, 4.0f};
std::simd<float> selected = std::experimental::choose(mask, a, b);
// {1.0f, 2.0f, 30.0f, 40.0f}

std::simd<float> angles = {0.0f, 0.5f, 1.0f, 1.5f};
 
// Тригонометрические функции
std::simd<float> sines = std::sin(angles);
std::simd<float> cosines = std::cos(angles);
std::simd<float> tangents = std::tan(angles);
 
// Экспоненциальные и логарифмические функции
std::simd<float> logs = std::log(angles + 1.0f);  // +1.0f чтобы избежать log(0)
std::simd<float> exp_values = std::exp(angles);
std::simd<float> pow_values = std::pow(angles + 1.0f, 2.0f);
 
// Округление и абсолютное значение
std::simd<float> rounded = std::round(angles);
std::simd<float> abs_values = std::abs(angles - 1.0f);

void process_array(float* input, float* output, size_t size) {
    using simd_t = std::simd<float>;
    constexpr size_t simd_size = simd_t::size();
    
    // Обработка основной части массива блоками по simd_size элементов
    size_t i = 0;
    for (; i + simd_size <= size; i += simd_size) {
        simd_t block(input + i);
        
        // Выполнение каких-то вычислений над блоком
        block = std::sqrt(block) + simd_t(1.0f);
        
        // Сохранение результатов обратно в массив
        block.copy_to(output + i);
    }
    
    // Обработка оставшихся элементов
    for (; i < size; ++i) {
        output[i] = std::sqrt(input[i]) + 1.0f;
    }
}

void process_array(std::vector<float>& data) {
    std::transform(
        std::execution::simd,
        data.begin(), data.end(),
        data.begin(),
        [](float x) { return std::sqrt(x) + 1.0f; }
    );
}

void blur_image(uint8_t* input, uint8_t* output, int width, int height) {
    using simd_t = std::simd<float>;
    constexpr size_t simd_size = simd_t::size();
    
    for (int y = 1; y < height - 1; ++y) {
        for (int x = 1; x < width - 1; x += simd_size) {
            // Ограничиваем ширину блока, чтобы не выйти за границы
            int block_size = std::min<int>(simd_size, width - 1 - x);
            std::simd_mask<float> mask = std::simd_mask<float>(true);
            for (int i = block_size; i < simd_size; ++i) {
                mask[i] = false;
            }
            
            // Загружаем 9 блоков пикселей (матрица 3x3 вокруг текущего пикселя)
            simd_t top_left(input + (y-1)*width + (x-1), mask);
            simd_t top(input + (y-1)*width + x, mask);
            simd_t top_right(input + (y-1)*width + (x+1), mask);
            
            simd_t left(input + y*width + (x-1), mask);
            simd_t center(input + y*width + x, mask);
            simd_t right(input + y*width + (x+1), mask);
            
            simd_t bottom_left(input + (y+1)*width + (x-1), mask);
            simd_t bottom(input + (y+1)*width + x, mask);
            simd_t bottom_right(input + (y+1)*width + (x+1), mask);
            
            // Вычисляем среднее значение (простейший фильтр размытия)
            simd_t result = (top_left + top + top_right +
                            left + center + right +
                            bottom_left + bottom + bottom_right) / 9.0f;
            
            // Сохраняем результат
            result.copy_to(output + y*width + x, mask);
        }
    }
}

// Вычисление полинома a*x^3 + b*x^2 + c*x + d
std::vector<float> evaluate_polynomial(
    const std::vector<float>& x_values,
    float a, float b, float c, float d
) {
    std::vector<float> results(x_values.size());
    
    using simd_t = std::simd<float>;
    constexpr size_t simd_size = simd_t::size();
    
    simd_t a_vec(a), b_vec(b), c_vec(c), d_vec(d);
    
    for (size_t i = 0; i + simd_size <= x_values.size(); i += simd_size) {
        simd_t x(x_values.data() + i);
        
        // Вычисление полинома методом Горнера
        simd_t result = a_vec;
        result = result * x + b_vec;
        result = result * x + c_vec;
        result = result * x + d_vec;
        
        result.copy_to(results.data() + i);
    }
    
    // Обработка оставшихся элементов
    for (size_t i = (x_values.size() / simd_size) * simd_size; i < x_values.size(); ++i) {
        float x = x_values[i];
        results[i] = ((a * x + b) * x + c) * x + d;
    }
    
    return results;
}

void compress_audio(float* samples, size_t count, float threshold, float ratio) {
    using simd_t = std::simd<float>;
    constexpr size_t simd_size = simd_t::size();
    
    simd_t threshold_vec(threshold);
    simd_t ratio_vec(ratio);
    simd_t one(1.0f);
    
    for (size_t i = 0; i + simd_size <= count; i += simd_size) {
        simd_t input(samples + i);
        simd_t abs_input = std::abs(input);
        
        // Создаем маску для значений выше порога
        simd_mask<float> mask = abs_input > threshold_vec;
        
        // Применяем компрессию только к значениям выше порога
        simd_t compressed = input;
        where(mask, compressed) = threshold_vec + 
            (abs_input - threshold_vec) / ratio_vec * 
            (input / abs_input);
        
        compressed.copy_to(samples + i);
    }
    
    // Обработка оставшихся элементов скалярным кодом
    for (size_t i = (count / simd_size) * simd_size; i < count; ++i) {
        float input = samples[i];
        float abs_input = std::abs(input);
        if (abs_input > threshold) {
            float sign = (input > 0.0f) ? 1.0f : -1.0f;
            samples[i] = sign * (threshold + (abs_input - threshold) / ratio);
        }
    }
}

template <typename T, typename Func>
bool verify_simd_computation(const std::vector<T>& input, Func scalar_func) {
    // Вычисление с использованием SIMD
    std::vector<T> simd_result(input.size());
    {
        using simd_t = std::simd<T>;
        constexpr size_t simd_size = simd_t::size();
        
        for (size_t i = 0; i + simd_size <= input.size(); i += simd_size) {
            simd_t x(input.data() + i);
            simd_t result = scalar_func(x);  // Векторизованная функция
            result.copy_to(simd_result.data() + i);
        }
        
        // Обработка оставшихся элементов
        for (size_t i = (input.size() / simd_size) * simd_size; i < input.size(); ++i) {
            simd_result[i] = scalar_func(input[i]);  // Скалярная функция
        }
    }
    
    // Вычисление с использованием скалярных операций
    std::vector<T> scalar_result(input.size());
    for (size_t i = 0; i < input.size(); ++i) {
        scalar_result[i] = scalar_func(input[i]);
    }
    
    // Сравнение результатов с допустимой погрешностью
    constexpr T epsilon = std::numeric_limits<T>::epsilon() * 10;  // Допустимая погрешность
    for (size_t i = 0; i < input.size(); ++i) {
        if (std::abs(simd_result[i] - scalar_result[i]) > epsilon * std::abs(scalar_result[i])) {
            std::cerr << "Несоответствие в позиции " << i 
                      << ": SIMD=" << simd_result[i] 
                      << ", скаляр=" << scalar_result[i] << std::endl;
            return false;
        }
    }
    
    return true;
}

// Векторизованная сортировка битонной последовательности
void bitonic_sort_simd(float* data, size_t size) {
    using simd_t = std::simd<float>;
    constexpr size_t simd_size = simd_t::size();
    
    // Предполагаем, что size кратно simd_size и является степенью 2
    for (size_t k = 2; k <= size; k *= 2) {
        for (size_t j = k / 2; j > 0; j /= 2) {
            for (size_t i = 0; i < size; i += j * 2) {
                for (size_t l = 0; l < j; l += simd_size) {
                    simd_t a(data + i + l);
                    simd_t b(data + i + j + l);
                    
                    // Сравнение и обмен векторов
                    simd_t min_vals = std::min(a, b);
                    simd_t max_vals = std::max(a, b);
                    
                    min_vals.copy_to(data + i + l);
                    max_vals.copy_to(data + i + j + l);
                }
            }
        }
    }
}

// Векторизованный бинарный поиск
template <typename T>
std::vector<size_t> simd_binary_search(
    const std::vector<T>& sorted_array,
    const std::vector<T>& keys
) {
    using simd_t = std::simd<T>;
    using index_t = std::simd<int>;
    constexpr size_t simd_size = simd_t::size();
    
    std::vector<size_t> results(keys.size(), -1);
    
    for (size_t k = 0; k + simd_size <= keys.size(); k += simd_size) {
        simd_t key_vec(keys.data() + k);
        
        // Начальные границы поиска
        index_t left(0);
        index_t right(sorted_array.size() - 1);
        
        // Векторизованный бинарный поиск
        simd_mask<T> not_found = left <= right;
        while (any_of(not_found)) {
            index_t mid = (left + right) / 2;
            
            // Загружаем средние элементы для всех ключей
            simd_t mid_vals;
            for (size_t i = 0; i < simd_size; ++i) {
                if (not_found[i]) {
                    mid_vals[i] = sorted_array[mid[i]];
                }
            }
            
            // Обновляем границы поиска
            simd_mask<T> is_less = key_vec < mid_vals;
            where(is_less && not_found, right) = mid - 1;
            where(!is_less && not_found, left) = mid + 1;
            
            // Нашли точное совпадение?
            simd_mask<T> found = mid_vals == key_vec;
            
            // Сохраняем результаты
            for (size_t i = 0; i < simd_size; ++i) {
                if (found[i]) {
                    results[k + i] = mid[i];
                    not_found[i] = false;
                }
            }
            
            // Выход из цикла, если все не найдены и границы поиска пересеклись
            not_found &= left <= right;
        }
    }
    
    // Обработка оставшихся ключей скалярным методом
    // ...
    
    return results;
}

// Векторизованное умножение разреженной матрицы на вектор (формат CSR)
void sparse_matrix_vector_mul_simd(
    const std::vector<float>& values,     // Ненулевые элементы
    const std::vector<int>& col_indices,  // Индексы столбцов
    const std::vector<int>& row_ptr,      // Указатели на начало строк
    const std::vector<float>& x,          // Вектор, на который умножаем
    std::vector<float>& result            // Результат
) {
    using simd_t = std::simd<float>;
    constexpr size_t simd_size = simd_t::size();
    
    for (size_t i = 0; i < row_ptr.size() - 1; ++i) {
        int row_start = row_ptr[i];
        int row_end = row_ptr[i+1];
        
        simd_t sum(0.0f);
        
        for (int j = row_start; j + simd_size <= row_end; j += simd_size) {
            simd_t val_vec(values.data() + j);
            
            // Собираем значения из вектора x по индексам столбцов
            simd_t x_vec;
            for (size_t k = 0; k < simd_size; ++k) {
                x_vec[k] = x[col_indices[j + k]];
            }
            
            sum += val_vec * x_vec;
        }
        
        // Суммируем элементы вектора
        float row_result = reduce(sum, std::plus<float>());
        
        // Обработка оставшихся элементов скалярным способом
        for (int j = row_end - ((row_end - row_start) % simd_size); j < row_end; ++j) {
            row_result += values[j] * x[col_indices[j]];
        }
        
        result[i] = row_result;
    }
}