Телеграм

Грокаем C++

@grokaemcpp Программирование и разработка
РКН: проверяем Не иноагент
Два сеньора C++ - Владимир и Денис - отныне ваши гиды в этом дремучем мире плюсов.

По всем вопросам (+ реклама) @ninjatelegramm

Менеджер: @Spiral_Yuri
Реклама: https://telega.in/c/grokaemcpp
Мы на TGstat: https://tgstat.ru/channel/@grokaemcpp/stat

Статистика обновлена 17.11.2026 в 14:11 · 3 просмотра страницы · Хотите больше просмотров?

Подписчики9 357 +4 за 3 дня
Охват поста2 347 25% от подписчиков
ERR за месяц25,08%
ERR за 24 часа5,67%

Динамика за 30 дней

Рекламные публикации 1

Все рекламные посты →
Грокаем C++ tg9.4 тыс. подписчиков
Открыть пост ↗
Экскурсия по лабораториям YADRO: как тестируют серверы и телеком-оборудование

В ноябре и декабре YADRO проводит экскурсии по своим лабораториям в Санкт-Петербурге и Москве.

На маршрутах — тестовые стенды, оборудование на разных этапах отладки и рабочие пространства команд. Инженеры расскажут, какие проверки проходит железо, и ответят на вопросы.

📍Санкт-Петербург — 12 ноября и 1 декабря
📍Москва — 17 ноября и 8 декабря
Сбор гостей в 18:30, старт в 19:00.

Экскурсия занимает до двух часов. Участие бесплатное — нужно зарегистрироваться и дождаться подтверждения от организаторов. Возраст участников — от 18 лет.

Зарегистрироваться

Реклама. ООО "КНС ГРУПП". ИНН 7701411241. erid: 2W5zFGVnpQA
👁 2.8 тыс. 👍 10❤ 6🔥 6 ↻ 29 2 ноября

Последние публикации

Все посты канала →
Грокаем C++ tg9.4 тыс. подписчиков
Открыть пост ↗
​​Store buffer
#опытным

Все примерно понимают, зачем нужен кэш в ядре процессора. Процессора очень быстрый, а память либо медленная, дешевая и объемная, либо быстрая, дорогая и маленькая. Поэтому перед ОЗУ ставят каскад быстрых и небольших кэшэй, чтобы ускорить работу с памятью.

Но это все равно не до конца решает проблему, а потенциально добавляет новых. Современные процессы содержат несколько ядер, которые общаются друг с другом по протоколу когерентности кэшей(усложненные вариации MESI). Чтобы записать в свой кэш, ядро должно инвалидировать все кэш линии других ядер, содержащих копию тех же данных.

Процесс занимает какое-то время(десятки тактов), на которое ядро должно остановить конвейер и ожидать подтверждения инвалидации от других ядер.

Ждать никто не хочет, поэтому инженеры железа внедрили еще одну оптимизацию.

Когда ядро процессора делает запись в память, оно не ждёт, пока значение доедет до L1. Оно кладёт его в маленький per-core FIFO между ядром и кэшем - store buffer. Он содержит завершённые(с точки зрения CPU) записи, пока их кэш-линия не будет получена в эксклюзивное владение (M state) через MESI и не произойдет реальная запись. Только после этого можно рассчитывать, что изменения увидят другие ядра.

Глубина очереди - обычно несколько десятков записей в зависимости от процессора.

Получается, когда ядро выполняет mov [addr], value, инструкция завершается сразу как только значение попало в буфер. На конвейере при этом нет никакого ожидания - другие инструкции продолжают последовательно исполняться. Дальше буфер сам, асинхронно, сливает записи в кэш по мере получения линий.

Вещь прекрасная, но надо понимать некоторые важные моменты:

1️⃣ Буфер ограниченный. Значит аномалии в инструкциях, типа большого количества записей в разные ячейки может его заполнить до конца и ждать все-таки придется.

2️⃣ Как придется ждать всему пайплайну исполнения при L1-write промахе. Если адреса для записи нет в кэше, то надо ее подтянуть, а это очень долго.

3️⃣ Некоторые барьеры памяти форсят запись буффера в кэш-линию. Это одна из причин, почему более строгий порядок операций над атомиками может приводить к уменьшению перфа.

4️⃣ При выполнении чтения поиск в первую очередь происходит в этом буффере. Вдруг мы совсем недавно выполнили запись и хотим по горячим следам увидеть эти данные. Чтобы не искать в кэше, первым делом ядро смотрит в свой буфер.

5️⃣ Буффер записи - это инструмент спекуляции процесса. Он пытается схитрить и срезать углы. И у этого есть последствия.

Например, случилась запись переменной в каком-то потоке. Если дальше очень быстро последует чтение, то чтение из этого потока увидит обновленную информацию, а чтение из другого потока - нет.

Это будет происходить даже с атомиками с более слабыми порядками, чем memory_order_seq_cst.

6️⃣ Отложенной записью объясняется единственный вид реордеринга, который разрешается архитектурой x86 - StoreLoad. Об этом в другом посте.

То есть, это не волшебная вундервафля, решающая все проблемы. Это всего лишь инструмент спекуляции, у которого есть ограничения и последствия. И, плотно работая с продвинутой многопоточкой, важно понимать механизм его работы и эти аспекты.

Don't wait. Stay cool.

#concurrency #hardware
👁 1.3 тыс. 👍 19🔥 9❤ 4 💬 3 ↻ 18 вчера в 10:00
Грокаем C++ tg9.4 тыс. подписчиков
Открыть пост ↗
Кто в IT платит выше рынка? И какой оффер считается хорошим?

Предлагаем опытным IT-специалистам поделиться мнением о зарплатах и бенефитах в крупных технологических компаниях.

Кто, на ваш взгляд, платит выше рынка?
У кого привлекательнее премии?
Насколько важны ДМС, спорт, питание и другие бонусы при выборе работы?

👉 Поделиться мнением: https://clck.ru/3WzzJ6
👁 1.4 тыс. ❤ 4👍 4🔥 4 💬 1 ↻ 1 вчера в 07:00
Грокаем C++ tg9.4 тыс. подписчиков
Открыть пост ↗
​​Деление по модулю
#опытным

В прошлом посте в реализации скользящего среднего через ринг буффер используется формула index = (index + 1) % maxSize. Делим по модулю на максимальный размер, чтобы текущий индекс не превысил его.

Но знаете ли вы, что деление по модулю - это очень медленная операция?

Сложение, вычитание и основные битовые операции выполняются условно за 1 такт. Сигнал просто проходит через сумматор и все. Умножение - за 3-4 за счет аппаратного умножителя (Wallace tree, carry-save adder).

А вот инструкция div выполняется за 10-50 тактов. На порядок больше. Почему так?

Деление просто не имеет быстрой аппаратной схемы. Чтобы получить x / y, процессор выполняет циклический алгоритм - обычно это модификации SRT division (назван по фамилиям Sweeney, Robertson, Tocher):

1. Сравнить старшие биты делимого и делителя.
2. Вычесть (или не вычесть) делитель.
3. Сдвинуть частичный остаток.
4. Повторить для следующего бита частного.

Условно, процессор делит в столбик.

Блок деления устроен итеративно: вместо одной комбинационной схемы процессор за несколько шагов вычисляет очередные биты частного.

Теоретически можно построить полностью комбинационную схему для деления, которая выдавала бы результат сильно быстрее. Но такая схема для 64-битных чисел потребовала бы много транзисторов/много памяти и огромную площадь на кристалле.

Поскольку деление в реальных программах встречается относительно редко (по разным оценкам порядка 1% от всех инструкций), инженеры хардвара идут на компромисс: они делают блок деления компактным и последовательным, жертвуя скоростью ради экономии места на чипе для более важных блоков (например, кэш-памяти или блоков векторных инструкций AVX-512).

Вывод тут один: если вы паритесь за нано и микросекунды, то избегайте деления.

Но как?

Есть несколько методик, которые применимы в общем и в данном конкретном случае:

1️⃣ Можно сделать параметр size шаблонным. Тогда компилятор сможет применить оптимизацию "умножения на магическое число" (метод Гранлунда-Монтгомери). Главная идея - если делитель является константой на этапе выполнения или компиляции цикла, деление n / d можно заменить математически эквивалентным выражением вида (n * m) >> s, где m и s - предвычисленные константы. m - некое обратное число в модульной арифметике, а s - зависит от разрядности чисел при делении и их величины.

2️⃣ Если уж прям нельзя сделать шаблонным параметр, то тоже не страшно. maxSize же не меняется. Поэтому нам просто нужно самим сделать то, что делает компилятор. Условно, в конструкторе предрасчитать магические числа и потом использовать быстрое умножение. Для этого естественно есть библиотечки, типа libdivide. Вот небольшой отрывок кода, как ей пользоваться:

int sum_of_quotients(const int *numers, int count, int d) {
int result = 0;
libdivide::divider<int> fast_d(d); //constructs an instance of libdivide::divider
for (int i=0; i < count; i++)
result += numers[i] / fast_d; //uses faster libdivide division
return result;
}


3️⃣ Можно ограничить пространство значений размера ринг буфера до степени двойки. Тогда деление по модулю можно заменить на супербыстрое битовое умножение:

index = (index + 1) & (maxSize - 1)


По сути просто оставляем только младшие разряды числа и предотвращаем переполнение.

4️⃣ Можно просто использовать условие:

index++;
if (index >= maxSize) {
index = 0;
}


Предсказатель переходов здесь должен хорошо отрабатывать и латенси должно ощутимо снизиться.
Не во всех случаях подходит, но в этом работает прекрасно.

То есть проблему можно решить и можно(и нужно) даже побэнчмарчить, что быстрее по итогу.

Don't let the pipeline stall. Stay cool.

#performance #compiler #hardware
👁 1.7 тыс. ❤ 11🔥 8👍 6 💬 5 ↻ 21 14 ноября