Маски, Каскады, использование масок вместо циклов(В некоторых случаях) + Атомарные инструкции

Привет Хабр!

Сегодня я решил закрыть трилогию статей, а закончи парой не мало важных тем. Хочу сказать огромное спасибо тем кто активничает и задает вопросы. Ну что ж, начнем.

Mask

как то я в одной из прошлых статей затрагивал данную тему рассмотрим ее поближе

Что это такое?

Согласно технической документации архитектур, SIMD-маска — это управляющий вектор (битовая или элементная последовательность), используемый для предикации (выборочного исполнения) операций над отдельными компонентами векторного регистра. Она определяет, будет ли результат инструкции записан для конкретного элемента данных или проигнорирован.

По человечески:

Маска в SIMD — это битовый фильтр, который разрешает или запрещает выполнение операции для каждого отдельного элемента в векторе.

Если коротко:

• 1 (True): элемент обрабатывается и записывается.

• 0 (False): элемент игнорируется (остается прежним или обнуляется).

Это единственный способ заставить процессор выполнять условия типа if-else параллельно, не прерывая общий поток вычислений.

Зачем это нужно когда есть ветвления?

Ветвления (if-else) — это главный враг скорости в современных процессорах они убивают производительность, вот основные причины:

1. Конвейер не ломается: Процессор — это скоростной поезд. Когда он видит обычный if, он должен угадать, куда ехать. Если не угадал (ошибка предсказания), поезду приходится тормозить, сдавать назад и ехать по другому пути. Это огромная потеря времени.

2. Параллелизм: SIMD по определению делает одно и то же действие сразу с 8 или 16 числами. Ты не можешь внутри одной инструкции отправить 4 числа «налево», а 4 «направо». Маска позволяет сделать действие со всеми сразу, но сохранить результат только для нужных.

3. Нет «прыжков»: С масками код идет строго по прямой линии. Процессор просто «проглатывает» данные, не задумываясь над выбором пути.

Итог: Маски превращают логический выбор из «куда пойти?» в «какой результат оставить?», что в десятки раз быстрее для математических расчетов.

Где, когда используется?

Опираясь на прошлые статьи рекомендую использовать все методы(Если пишете свой код). Но это очень важная тема на которой стоят все высокоскоростные системы

Вот основные ситуации и сферы:

• Обработка графики и фото: Когда нужно применить эффект (например, яркость) не ко всему изображению, а только к пикселям определенного цвета или яркости. Маска мгновенно «отфильтрует» нужные точки.

• Игровая физика и движки: В расчетах столкновений или освещения, где для каждого объекта нужно проверить условие (находится ли он в зоне видимости или в зоне взрыва).

• Математические вычисления и матрицы: Когда в массиве данных есть «плохие» значения (например, нули, на которые нельзя делить). Маска пометит безопасные элементы и позволит провести деление по всему вектору разом, игнорируя опасные участки.

• Машинное обучение (AI): При работе с нейросетями, например, в функциях активации (как ReLU), где все отрицательные числа нужно превратить в ноль, а положительные оставить как есть.

• Базы данных и поиск: Когда нужно быстро найти в огромном массиве все числа, попадающие в диапазон (например, «цена от 100 до 500»). SIMD-маска сравнит 8–16 цен за один такт процессора.

• Популярные Библиотеки: В современных высокоуровневых библиотеках для работы с данными и нейросетями (как PyTorch, TensorFlow или NumPy) SIMD-маски являются фундаментом производительности. Хотя ты пишешь код на Python, «под капотом» эти библиотеки превращают твои операции в векторные команды с масками.

Когда это НЕ нужно: Если ваш код и так работает быстро или если в алгоритме нет ветвлений (if), маски будут избыточны. Они — это «лекарство» именно от замедлений, вызванных логическими проверками внутри тяжелых циклов.

Основные регистры

Ниже представлена максимально подробная и структурированная таблица по работе с масками в библиотеке SIMDe для языка C. Она охватывает типы данных, способы создания, режимы записи и внутреннюю логику эмуляции.

Полная энциклопедия масок в SIMDe (C-интерфейс)

Внимание! Важно, не используйте k0 для масок!!! Это может вызвать пропуск данных без проверки, эту ошибку очень тяжело найти(невозможно)

Подробный разбор режимов записи (Merging vs Zeroing)

В SIMDe выбор режима критичен для производительности, особенно при эмуляции AVX-512 на старом железе:

Я очень старался, собирая инфу, но если вы хотите максимально подробно ознакомиться, то вот пару проверенных ресурсов:

1. Intel Intrinsics Guide (База всех команд):
   software.intel.com
   (Ищи по тегу mm512mask_)

2. Agner Fog’s Optimization Manuals (Теория скорости):
   www.agner.org
   (Раздел 13: Vector programming)

3. SIMDe GitHub (Реализация масок на C):
   github.com

4. Блог Daniel Lemire (Практические кейсы):
   lemire.me

5. uops.info (Задержки и производительность):
   www.uops.info

6. Stanford CS149 (Университетский курс):
   cs149.stanford.edu
   (Лекция 02: SIMD and SIMT)

   Пример

   Задача: Массовое условное преобразование данных в массиве.

   У нас есть 10 миллионов чисел. Условие простое: если число больше 500 — удваиваем его, иначе — увеличиваем на 10. Проблема в том, что в обычном цикле это условие (if-else) заставляет процессор постоянно «гадать», по какой ветке пойдет программа. Если данные случайны, процессор ошибается в предсказаниях, что катастрофически снижает скорость.

   Код показывает, как заменить «логическое ветвление» на «аппаратное маскирование», обрабатывая по 16 чисел за один такт процессора без единой паузы на «раздумья».

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// Подключаем SIMDe для работы с AVX-512 масками везде
#define SIMDE_ENABLE_NATIVE_ALIASES
#include <simde/x86/avx512.h>

#define SIZE 10000000 // 10 миллионов элементов

// 1. ОБЫЧНЫЙ ПОДХОД (Медленный if-else)
void scalar_process(float* data, int size) {
    for (int i = 0; i < size; i++) {
        if (data[i] > 500.0f) {
            data[i] = data[i] * 2.0f; // Удваиваем
        } else {
            data[i] = data[i] + 10.0f; // Прибавляем 10
        }
    }
}

// 2. МОЩЬ SIMD (Маскирование через SIMDe)
void simde_process(float* data, int size) {
    simde__m512 v_500 = simde_mm512_set1_ps(500.0f);
    simde__m512 v_10  = simde_mm512_set1_ps(10.0f);
    simde__m512 v_2   = simde_mm512_set1_ps(2.0f);

    for (int i = 0; i < size; i += 16) {
        // Загружаем 16 чисел
        simde__m512 v_in = simde_mm512_loadu_ps(&data[i]);

        // Создаем битовую МАСКУ (трафарет) за 1 такт
        simde__mmask16 mask = simde_mm512_cmp_ps_mask(v_in, v_500, SIMDE_CMP_GT_OS);

        // Считаем обе ветки параллельно
        simde__m512 v_mult = simde_mm512_mul_ps(v_in, v_2);
        simde__m512 v_add  = simde_mm512_add_ps(v_in, v_10);

        // МАГИЯ: Смешиваем результаты по маске (VBLENDPS)
        // Если бит маски 1 — берем результат умножения, если 0 — сложения
        simde__m512 v_res = simde_mm512_mask_blend_ps(mask, v_add, v_mult);

        // Выгружаем 16 готовых чисел
        simde_mm512_storeu_ps(&data[i], v_res);
    }
}

int main() {
    float *data_scalar = malloc(SIZE * sizeof(float));
    float *data_simd = malloc(SIZE * sizeof(float));

    // Заполняем случайными числами
    for(int i = 0; i < SIZE; i++) {
        float val = (float)(rand() % 1000);
        data_scalar[i] = val;
        data_simd[i] = val;
    }

    // Тест обычного способа
    clock_t start = clock();
    scalar_process(data_scalar, SIZE);
    printf("Обычный if-else: %f сек.\n", (double)(clock() - start) / CLOCKS_PER_SEC);

    // Тест с масками SIMDe
    start = clock();
    simde_process(data_simd, SIZE);
    printf("Маски SIMDe:     %f сек.\n", (double)(clock() - start) / CLOCKS_PER_SEC);

    free(data_scalar);
    free(data_simd);
    return 0;
}

clang -O3 -march=native -ffast-math -I./simde main.c -o code

данный пример показывает хорошее сравнение разных подходов. Ну ладно к следящей теме

Atomic инструкции

Переход от SIMD к Атомарным операциям (Atomics) — это переход от «параллелизма данных» к «безопасности параллельных потоков». Если SIMD ускоряет вычисления внутри одного потока, то атомарные операции позволяют разным потокам (ядрам процессора) редактировать одни и те же данные, не ломая их.

Что происходит в транзисторах?

Когда ядро процессора хочет выполнить атомарную операцию, оно должно гарантировать, что ни одно другое ядро не изменит эту ячейку памяти в тот же момент. Для этого используются два основных механизма:

1. Сигнал LOCK и блокировка шины (Bus Lock) — «Старая школа»

В старых процессорах (и в некоторых случаях сейчас) ядро буквально выставляло на шину данных специальный электрический сигнал LOCK#.

• Как это работает: Это как если бы рабочий на стройке перекрыл единственную дорогу грузовиком, пока он выгружает кирпичи. Все остальные ядра (грузовики) стоят и ждут, пока сигнал не снимется.

• Минус: Это ужасно медленно. Блокируется доступ ко всей памяти для всех ядер.

2. MESI-протокол и Cache Locking — «Современный метод»

Современные CPU (Intel Core, AMD Ryzen, Apple M1) используют протокол согласованности кэшей. Каждое ядро имеет свой кэш L1/L2. Операция происходит не в оперативной памяти, а прямо в кэше.

• Как это работает: Когда ядро хочет сделать атомарную правку, оно отправляет остальным ядрам сообщение: «Строка кэша по адресу X теперь принадлежит только мне (состояние Exclusive/Modified)».

• Магия: Если другое ядро попытается прочитать этот адрес, контроллер кэша поставит его в очередь («захолдит»), пока первая операция не завершится.

• Результат: Память не блокируется, всё происходит на частоте работы кэша (очень быстро).

Зачем они нужны, если есть Mutex (Мьютексы)?

Мьютекс — это тяжелый «замок». Поток захватывает его, делает работу и отпускает.

• Мьютекс: Дорого, долго, задействует операционную систему.

• Atomics: Выполняются на уровне железа (инструкции процессора). Это в десятки раз быстрее.

Вот базовая таблица основных инструкций которые чаще всего используются:

* CAS может тормозить при высокой конкуренции (Contention), когда много ядер "дергают" одну и ту же кэш-линию.

краткий список «золотых» источников:

1. Теория и Визуализация (Понять суть)

• Preshing on Programming — лучший блог о Memory Barriers и Acquire/Release семантике. Всё на понятных схемах.

• Herb Sutter: Atomic Weapons — культовая видеолекция (YouTube) о том, как железо и компиляторы переупорядочивают код.

2. Документация и Стандарты (Справочники)

• cppreference.com (C Atomic) — главный мануал по функциям <stdatomic.h> и режимам memory_order.

• N1570 (C11 Standard) — официальный текст стандарта (секция 7.17). Истина в последней инстанции.

3. Железо и Низкий уровень (Hardware)

• Paul McKenney: Perfbook — «библия» параллелизма от разработчика ядра Linux. Глубокий разбор кэш-линий и протокола MESI.

• Intel SDM (Vol. 3A, Ch. 8) — спецификация Intel о том, как физически работает префикс LOCK на шине.

4. Инструменты (Пощупать код)

• CppMem — интерактивный симулятор модели памяти. Показывает, как данные «разлетаются» между ядрами.

• Compiler Explorer — смотреть, в какие инструкции (LOCK ADD, CMPXCHG) Clang превращает твой C-код.

Некоторые проблемы при использовании и их рещение

1. Проблема: Reordering (Переупорядочивание)

// Поток А (Писатель)
data = 42;          // (1)
ready = true;       // (2)

Без барьеров процессор может решить, что запись ready = true важнее, и выполнит её первой. Поток Б прочитает ready == true, возьмет data, а там еще старый мусор. Это катастрофа.

2. Memory Barriers (Барьеры памяти)

Барьер — это инструкция-стопор. Она говорит процессору: «Не смей переносить операции через эту черту».

• Load Barrier (Read Barrier): Гарантирует, что все чтения после барьера увидят актуальные данные.

• Store Barrier (Write Barrier): Гарантирует, что все записи до барьера завершены и видны другим ядрам.

• Full Barrier (MFENCE): Останавливает любые перестановки в обе стороны.

3. Acquire/Release семантика (Легкие барьеры)

Это самый эффективный способ синхронизации в C11. Это не «забор» через всю память, а «односторонние двери».

Release (Освобождение) — ставится на ЗАПИСЬ

Используется при отправке данных (например, когда выставляем флаг «Готово»).

• Правило: Никакая запись в коде ДО этого момента не может переместиться ПОСЛЕ него.

• Аналогия: Ты упаковал посылку, заклеил её (Release) и только потом отправил. Посылка не может оказаться пустой, если ты сначала положил в неё товар.

Acquire (Получение) — ставится на ЧТЕНИЕ

Используется при проверке флага (например, «Данные пришли?»).

• Правило: Никакое чтение в коде ПОСЛЕ этого момента не может переместиться ДО него.

• Аналогия: Ты открыл посылку (Acquire) и только потом начал смотреть, что внутри. Ты не можешь увидеть содержимое до того, как открыл коробку.

4. Как это выглядит в коде C11

#include <stdatomic.h>

atomic_bool ready = false;
int data = 0;

// Поток А (Производитель)
void producer() {
    data = 42; // Обычная запись
    // atomic_store с Release гарантирует, что data = 42 уже "там"
    atomic_store_explicit(&ready, true, memory_order_release);
}

// Поток Б (Потребитель)
void consumer() {
    // atomic_load с Acquire гарантирует, что всё, что мы прочитаем 
    // ПОСЛЕ, будет актуальным на момент готовности
    while (!atomic_load_explicit(&ready, memory_order_acquire));
    
    printf("%d", data); // Гарантированно напечатает 42
}

5. Ультимативная таблица порядков памяти

Более подробные ресурсы выше.

Ну что ж, получилось душно, но это очень важные темы для Lock-free архитектур и высокопроизводительных архитектур

Пример объединения DOD, SIMDe и Atomic

вот код который генерирует ценники в магазине и помечает те которые больше 500

#define _POSIX_C_SOURCE 200809L
#include <stdatomic.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>  // Для getopt в Linux
#include <time.h>
#include <omp.h>     // Для многопоточности

// Включаем поддержку AVX2 через SIMDe
#define SIMDE_ENABLE_NATIVE_ALIASES
#include <simde/x86/avx2.h>

// Глобальные переменные для синхронизации
atomic_size_t global_match_count = 0;
atomic_flag   print_lock = ATOMIC_FLAG_INIT; 
atomic_bool   is_ready = false;

void process_prices_avx2(float* prices, size_t n) {
    simde__m256 v_threshold = simde_mm256_set1_ps(500.0f);
    size_t total_combined = 0;

    // --- ПАРАЛЛЕЛИЗАЦИЯ НА ВСЕ ЯДРА ---
    // reduction(+:total_combined) — каждое ядро считает в свой кэш L1,
    // искл��чая "толкотню" у общего атомика внутри цикла.
    #pragma omp parallel reduction(+:total_combined)
    {
        size_t thread_local_sum = 0;

        #pragma omp for nowait
        for (size_t i = 0; i < n; i += 8) {
            simde__m256 v_val = simde_mm256_loadu_ps(&prices[i]);
            // Сравнение: получаем векторную маску
            simde__m256 v_mask = simde_mm256_cmp_ps(v_val, v_threshold, _CMP_GT_OS);
            // Movemask: сжимаем 256 бит в 8 бит (по 1 биту на float)
            int mask = simde_mm256_movemask_ps(v_mask);
            // Popcount: аппаратный подсчет установленных бит
            thread_local_sum += __builtin_popcount(mask);
        }
        total_combined = thread_local_sum;
    }

    // Финальное обновление глобального счетчика (один раз на все потоки)
    atomic_fetch_add_explicit(&global_match_count, total_combined, memory_order_relaxed);
    // Сигнализируем монитору через Release-барьер
    atomic_store_explicit(&is_ready, true, memory_order_release);
}

void print_report() {
    // Acquire-барьер: гарантирует, что мы увидим все правки памяти
    while (!atomic_load_explicit(&is_ready, memory_order_acquire)) {
        simde_mm_pause(); 
    }

    // Spin-lock для атомарного вывода в терминал
    while (atomic_flag_test_and_set(&print_lock)); 
    printf("\n[FINAL REPORT] Найдено элементов: %zu\n", atomic_load(&global_match_count));
    atomic_flag_clear(&print_lock);
}

int main(int argc, char *argv[]) {
    size_t size = 0;
    int opt;

    while ((opt = getopt(argc, argv, "s:")) != -1) {
        if (opt == 's') size = (size_t)atoll(optarg);
    }

    if (size == 0 || size > 1000000000) {
        fprintf(stderr, "Использование: %s -s <размер_массива>\n", argv[0]);
        return EXIT_FAILURE;
    }

    // Выделение ВЫРОВНЕННОЙ памяти (32 байта для AVX2) — стандарт Linux C11
    // Это ускоряет загрузку данных в регистры
    float *price = aligned_alloc(32, size * sizeof(float));
    if (!price) {
        perror("aligned_alloc failed");
        return EXIT_FAILURE;
    }

    srand((unsigned int)time(NULL));
    for (size_t i = 0; i < size; i++) {
        price[i] = (float)(rand() % 1000);
    }

    printf("Потоков: %d, Элементов: %zu\n", omp_get_max_threads(), size);

    // Высокоточный замер времени OpenMP (Wall clock time)
    double start_time = omp_get_wtime();

    process_prices_avx2(price, size);
    print_report();

    double end_time = omp_get_wtime();
    printf("Затрачено времени: %.6f сек.\n", end_time - start_time);

    free(price);
    return 0;
}

вот в принципе и все!(для начала) Мне кажется не очень душно(я старался)