🦀 COW<T> 🦀

Если вы слышали про клонирование в Rust, то наверняка знаете, что эта операция может быть затратной. Особенно когда клонируем большой объем данных. 💀
Но в Rust есть инструмент, который нам поможет и в этом случае. 😘

Проблема: клонирование или заимствование?

Представьте ситуацию: у вас есть функция, которая принимает строку. В 90% случаев она просто читает эту строку, но иногда (редко) нужно её модифицировать.

Как это реализовать?🤔

- Передать &str - быстро, но что делать, когда нужна модификация?
- Передать String - всегда клонируем, даже когда не нужно. Может быть затратно.
- Передать &mut String - а если модификация не нужна?

Получается дилемма: либо мы жертвуем производительностью (постоянно клонируем), либо усложняем API (делаем несколько версий функции). 🤑

Решение: Copy-on-Write (CoW)

Rust предлагает решение - тип Cow<T> (Copy-on-Write). Это умный указатель, который может содержать либо заимствованные данные, либо владеющие. 💡

Простой пример:

use std::borrow::Cow;

fn process_text(text: Cow<str>) -> Cow<str> {
    if text.contains("bug") {
        // Только здесь происходит клонирование!
        Cow::Owned(text.replace("bug", "feature"))
    } else {
        // Просто возвращаем заимствование
        text
    }
}

fn main() {
    let text1 = "Hello, world!";
    let result1 = process_text(Cow::Borrowed(text1));
    // Клонирования не было!

    let text2 = "Found a bug";
    let result2 = process_text(Cow::Borrowed(text2));
    // Клонирование произошло только здесь
}

Как это работает? 🗒

Cow - это enum с двумя вариантами:
- Borrowed(&T) - данные заимствованы, клонирования нет
- Owned(T) - данные принадлежат нам

Когда нужна модификация, вызывается метод .to_mut(), который:

1. Проверяет текущее состояние
2. Если данные заимствованы - клонирует их один раз
3. Если уже владеющие - просто возвращает мutable ссылку


Cow<T> отлично подходит в ситуациях, когда:

✅ Функция чаще читает, чем модифицирует

✅ Хотите избежать лишних аллокаций

✅ Нужна гибкость между заимствованием и владением

Но будьте внимательны, если:

❌ Всегда нужна модификация - используйте владеющие типы

❌ Всегда только чтение - используйте ссылки

Cow - это еще один zero-cost abstraction инструмент в Rust, который позволяет писать более гибкий и производительный код.

Пользуйтесь на здоровье!👍

🚀 Пост Guru Rust: @PaulEdd

🦀 CAS 🦀

Сейчас прокачаем ваш многопоточный код 🤔

CAS (Compare-And-Swap) - это атомарная операция, которая позволяет безопасно изменять данные в многопоточных программах БЕЗ мутексов!

СAS работает по следующему принципу: 🧐

1. Читаем текущее значение
2. Вычисляем новое
3. Пытаемся заменить, но ТОЛЬКО если значение не изменилось
4. Если кто-то успел раньше - повторяем


Простой пример со счетчиками:

use std::sync::atomic::{AtomicU64, Ordering};

let counter = AtomicU64::new(0);

// В цикле пробуем увеличить счётчик
loop {
    let current = counter.load(Ordering::Acquire);
    let new = current + 1;
    
    // Если успели — выходим, если нет — повторяем
    if counter.compare_exchange(
        current, 
        new,
        Ordering::Release,
        Ordering::Acquire
    ).is_ok() {
        break;
    }
}

Конечно, в многопоточке можно использовать и Mutex, но у CAS есть очевидные преимущества:

🔥 Скорость: в 10-100 раз быстрее при низкой конкуренции
🔥 Нет блокировок: потоки не ждут друг друга
🔥 Нет дедлоков: просто невозможны по дизайну

Используйте CAS для создания быстрых параллельных процессов! ⚡️

🚀 Пост Guru Rust: @PaulEdd

🦀 Асинхронка 🦀

Я уверен, вы уже привыкли к тому, что в Rust очень много zero-cost абстракций. Асинхронка дополняет список.

Давайте посмотрим, как работать с асинхронными функциями в Rust.🧐

Простой пример - загрузка файла

use tokio;

async fn download_file(url: &str) -> String {
    println!("Начинаю загрузку {}", url);
    let response = reqwest::get(url).await.unwrap();
    println!("Получил ответ!");
    let content = response.text().await.unwrap();
    println!("Загрузил {} байт", content.len());
    content
}

#[tokio::main]
async fn main() {
    let task1 = download_file("https://example.com/file1");
    let task2 = download_file("https://example.com/file2");
    
    // Запускаем параллельно!
    let (content1, content2) = tokio::join!(task1, task2);
}

Код с виду выглядит синхронным, а компилятор под капотом превращает его в эффективный автомат состояний. И никаких накладных расходов в рантайме.

Что происходит под капотом? 🤔

1️⃣ Компилятор создаёт конечный автомат состояний.

Ваша async-функция превращается в enum с состояниями:

// Примерно так видит компилятор вашу функцию
enum DownloadFileState {
    Start {
        url: String,
    },
    WaitingForResponse {
        url: String,
        response_future: ResponseFuture,
    },
    WaitingForText {
        text_future: TextFuture,
    },
    Done,
}

2️⃣ Каждый `.await` - это точка приостановки

Когда вы пишете .await, компилятор:
- Сохраняет текущее состояние функции (все локальные переменные)
- Возвращает управление планировщику
- Запоминает, где продолжить выполнение

// Это:
let response = reqwest::get(url).await;
let content = response.text().await;

// Превращается в переключение между состояниями:
// Start → WaitingForResponse → WaitingForText → Done

Пока одна задача ждёт ответа от сервера, планировщик переключается на другие задачи. Никакого блокирования потока!

3️⃣ Рантайм крутит все задачи

Tokio/async-std работает как диспетчер:
- Опрашивает каждую задачу: "Ты готова продолжить?"
- Если нет → переключается на следующую
- Если да → выполняет следующий кусок кода до .await

Вся работа получается очень быстрой:⚡️
- Можно создать миллионы асинхронных задач
- Переключение = просто вызов функции (наносекунды)
- Нет тяжёлых системных вызовов

И в рантайме получаем только эффективный машинный код! 🚀

🚀 Пост Guru Rust: @PaulEdd

🦀 Десериализация в Rust 🦀

Тоже производительная, как и все остальное в Rust. Все потому, что она zero-copy.

Рассмотрим подробнее 🤨

При работе с большими JSON или бинарными данными традиционная десериализация создаёт копии строк и байтов. Это естественно расходует память. 💀
Система владения в Rust позволяет использовать мощную оптимизацию: zero-copy десериализацию.

Проблема:

// Обычная десериализация - создаёт owned String
#[derive(Deserialize)]
struct User {
    name: String,  // Выделяет новую память
    email: String, // Ещё одна аллокация
}

// При парсинге JSON каждая строка копируется в кучу
let json = r#"{"name": "Иван", "email": "ivan@example.com"}"#;
let user: User = serde_json::from_str(json)?;
// Данные скопированы из json в user.name и user.email

Решение:

// Zero-copy с заимствованными данными
#[derive(Deserialize)]
struct User<'a> {
    #[serde(borrow)]
    name: &'a str,  // Без аллокации!
    #[serde(borrow)]
    email: &'a str,
}

// Теперь данные НЕ копируются
let json = r#"{"name": "Иван", "email": "ivan@example.com"}"#;
let user: User = serde_json::from_str(json)?;
// user.name и user.email просто ссылаются на части json!

Преимущества очевидны 💡:

• Производительность: Устраняем аллокации для строковых/байтовых полей
• Эффективность памяти: Ссылаемся на оригинальный буфер вместо копирования
• Низкие задержки: Критично для высоконагруженных сервисов

⚠️ Но всегда стоит помнить!
Заимствованные данные должны жить дольше вашей структуры. Десериализованный объект не может пережить исходный буфер.

В сочетании с simd-json или похожими библиотеками можно достичь времени парсинга на уровне микросекунд.

Был ли у вас опыт с zero-copy в Rust? 🍷

🚀 Пост Guru Rust: @PaulEdd