uk
Feedback

Не попадись на ботовода! Telemetrio знаходить і позначає такі канали мітками 👉 Хочеш бачити мітку, оформляй підписку

Грокаем C++

Грокаем C++

Відкрити в Telegram

Два сеньора C++ - Владимир и Денис - отныне ваши гиды в этом дремучем мире плюсов. По всем вопросам (+ реклама) @ninjatelegramm Менеджер: @Spiral_Yuri Реклама: https://telega.in/c/grokaemcpp Мы на TGstat: https://tgstat.ru/channel/@grokaemcpp/stat

Показати більше
9 357
Підписники
+324 години
+47 днів
+830 днів
Залучення підписників
лист '26
листопад '26
+71
в 0 каналах
жовтень '26
+140
в 0 каналах
Get PRO
вересень '26
+127
в 1 каналах
Get PRO
серпень '26
+113
в 0 каналах
Get PRO
липень '26
+79
в 0 каналах
Get PRO
червень '26
+111
в 0 каналах
Get PRO
травень '26
+153
в 0 каналах
Get PRO
квітень '26
+149
в 0 каналах
Get PRO
березень '26
+95
в 0 каналах
Get PRO
лютий '26
+126
в 1 каналах
Get PRO
січень '26
+128
в 0 каналах
Get PRO
грудень '25
+143
в 0 каналах
Get PRO
листопад '25
+163
в 0 каналах
Get PRO
жовтень '25
+113
в 1 каналах
Get PRO
вересень '25
+119
в 1 каналах
Get PRO
серпень '25
+228
в 1 каналах
Get PRO
липень '25
+578
в 4 каналах
Get PRO
червень '25
+724
в 2 каналах
Get PRO
травень '25
+307
в 2 каналах
Get PRO
квітень '25
+148
в 1 каналах
Get PRO
березень '25
+246
в 1 каналах
Get PRO
лютий '25
+487
в 6 каналах
Get PRO
січень '25
+233
в 1 каналах
Get PRO
грудень '24
+293
в 0 каналах
Get PRO
листопад '24
+215
в 0 каналах
Get PRO
жовтень '24
+1 593
в 18 каналах
Get PRO
вересень '24
+629
в 5 каналах
Get PRO
серпень '24
+490
в 5 каналах
Get PRO
липень '24
+206
в 2 каналах
Get PRO
червень '24
+1 383
в 19 каналах
Get PRO
травень '24
+833
в 7 каналах
Get PRO
квітень '24
+1 851
в 11 каналах
Get PRO
березень '24
+350
в 0 каналах
Get PRO
лютий '24
+691
в 0 каналах
Дата
Залучення підписників
Згадування
Канали
15 листопада+5
14 листопада+3
13 листопада+18
12 листопада+2
11 листопада+4
10 листопада+1
09 листопада+2
08 листопада+2
07 листопада+3
06 листопада+5
05 листопада+6
04 листопада+5
03 листопада+3
02 листопада+8
01 листопада+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

2
​​Скользящее среднее #новичкам Посчитать среднее для заданного набора элементов - может в принципе хороший школьник начальных классов. А что если надо посчитать среднее в скользящем окне значений? Да еще и за O(1) на добавление значения в окно и расчет среднего? Начнем с наивного линейного решения: class MovingAverage { public: explicit MovingAverage(int size) : maxSize(size) {} void addValue(double value) { buffer.push_back(value); if (buffer.size() > maxSize) { buffer.erase(buffer.begin()); // O(N) } } double getAverage() const { if (buffer.empty()) return 0.0; double sum = std::accumulate(buffer.begin(), buffer.end(), 0.0); // O(N) return sum / buffer.size(); } private: std::vector<double> buffer; int maxSize; }; Берем скучный вектор, при добавлении вставляем в конец(О(1) амортизированное) и удаляем из начала(О(N)). При запросе среднего каждый раз проходимся по всей коллекции. Это очень наивно, и очень неэффективно. Если даже просто банально поменять вектор на std::deque, то мы уже будем выполнять addValue за константу(вставка/удаление в начало/конец - константные операции для дека). Для удовлетворения требований задачи осталось только расчет среднего оптимизировать. Расчет скользящего среднего за константу - это значит, что нам надо просто сумму обновлять каждый раз. Будем каждый раз при добавлении нового значения выкидывать из суммы последний элемент дека и добавлять значение нового. Целиком выйдет что-то такое: class MovingAverage { public: explicit MovingAverage(int windowSize) : size_(windowSize), sum_(0.0) {} void addValue(double value) { prices_.push_back(price); sum_ += price; if (prices_.size() > size_) { sum_ -= prices_.front(); prices_.pop_front(); } } double getMovingAverage() const { if (prices_.empty()) return 0.0; return sum_ / prices_.size(); } private: std::deque<double> prices_; double sum_; int size_; }; Однако добавление элементов в дек все равно будет триггерить динамические аллокации на создание нового блока под элементы и деаллокацию старых. Плюс элементы рядом лежат только внутри одного блока, кэш локалити между разными блоками слабая. Все эти проблемы можно решить с помощью кольцевого буфера. В конструкторе выделяем память для вектора нужного размера и дальше просто закольцовываем операции удаления и добавления нового элемента - новый будет просто перезаписывать старый. Сумма при этом будет обновляться похожим образом: вычитаем старый элемент и прибавляем новый. Выглядит это так: class MovingAverage { public: explicit MovingAverage(int size) : buffer(size, 0.0), maxSize(size) {} void addPrice(double price) { // update sum sum -= buffer[index]; sum += price; // override buffer elem buffer[index] = price; index = (index + 1) % maxSize; if (count < maxSize) count++; } double getAverage() const { return count == 0 ? 0.0 : sum / count; } private: std::vector<double> buffer; int maxSize; int index = 0; int count = 0; double sum = 0.0; }; Дальше оптимизировать алгоритмически уже сложно. К сожалению, точное среднее не получится посчитать, не имея полного набора элементов в окне. Есть разные приближенные методы типа экспоненциального сглаживания, но использование таких методов должно быть допустимо с точки зрения домена вычислений. Use the right structure. Stay cool. #algorithms #interview
1 633
3
В России можно посещать IT-мероприятия хоть каждый день: как оффлайн, так и онлайн Но где их находить? Как узнавать о них ран
В России можно посещать IT-мероприятия хоть каждый день: как оффлайн, так и онлайн Но где их находить? Как узнавать о них раньше, чем когда все начнут выкладывать фотографии оттуда? Переходите на канал IT-Мероприятия России. В нём каждый день анонсируются мероприятия со всех городов России 📆 в канале размещаются как онлайн, так и оффлайн мероприятия; 👩‍💻 можно найти ивенты по любому стеку: программирование, frontend-backend разработка, кибербезопасность, дата-аналитика, osint, devops и другие; 🎙 разнообразные форматы мероприятий: митапы с коллегами по цеху, конференции и вебинары с известными опытными специалистами, форумы и олимпиады от важных представителей индустрии и многое другое А чтобы не искать по разным форумам и чатам новости о предстоящих ивентах: 🚀 IT-мероприятия России — подписывайся и будь в курсе всех предстоящих мероприятий!
1 619
4
​​Почему список инициализации конструктора работает не как ожидается? #новичкам Классическая проблема - вы написали какой-то класс с какими-то полями и хотите в списке инициализации задать значения этим полям. Пишите: class TcpClient { Connection conn_; Socket socket_; public: TcpClient(const std::string& host, uint16_t port) : socket_(host, port), conn_(socket_) {} }; int main() { TcpClient client("example.com", 8080); } Все бы хорошо, но при запуске получаем UB. Потому что мало ли что вы там хотели в своем порядке проинициализировать. Инициализация происходит так, как описано в списке инициализации, но в порядке объявления полей в классе. Значит conn_ будет инициализировать помойкой, так как у socket_ еще не задано корректное значение. И все, имеем коннекшен, открывающий портал в другую галактику, а не в нужную аппку. Понятное дело, что так требует стандарт: все поля инициализируются строго в порядке объявления. Но почему так? Почему нельзя просто разрешить задавать значения полям в том порядке, в котором они прописаны в list initialization? Проведем мысленный эксперимент: сделаем 3 конструктора и все 3 будут иметь разный порядок инициализации в списках. И это может работать. Но рано или поздно придет время разрушать объекты. В каком порядке будем разрушать? Надо, вообще говоря, в порядке создания. А как компилятору понять, в каком порядке разрушать поля, если каждый конструктор задает свой порядок? 1️⃣ Допустим, что компилятор будут генерить код с прежними требованиями: разрушаем поля в порядке обратном объявлению. Многие фундаментальные принципы С++, в том числе и RAII, держатся на простом контракте: ресурс захватывается в конструкторе, освобождается в деструкторе, а зависимости между ресурсами живут по принципу LIFO. Если один ресурс использует другой, то он должен быть создан после него и разрушен до него. В итоге в этом случае будет просто UB при разрушении объектов. 2️⃣ А можно ли разрушать в соответствии с созданием объекта? Это мало того, что нужно как-то идентифицировать объекты в рантайме, чтобы понимать порядок создания/уничтожения полей. Так еще потребуются фактически разные деструкторы, каждый для своего конструктора. И подумайте, что тут будет при наследовании. В общем, этот подход накладывает оверхэд и делает код менее предсказуемым. Поэтому мы и живем с такой неочевидностью в списках инициализации. Have an order in life. Stay cool. #cppcore
1 964
5
​​Ссылка внутри std::optional #опытным В прошлом посте была конструкция std::optional<std::reference_wrapper<const Value>>. Зачем так сложно? Почему нельзя было просто std::optional<const Value&>? Дело в том, что в C++17 и далее конструкция std::optional<T&> по стандарту ill-formed программе. И реализации зачастую даже ставили static_assert на ее использование. Проблема была в опасности самой конструкции, а скорее в спорах по дизайну. Что должно случиться при assignment'е: изменение объекта, ссылка на который хранится в optional, или все-таки замена самой ссылки, чтобы optional просто указывал на другой объект. В то время видимо были весомые аргументы в пользу обоих вариантов, поэтому так и не выбрали ничего. И вынудили нас использовать немного корявый вариант с std::reference_wrapper, который работает примерно так: // Переприсваивание самой ссылки int a = 1; int b = 2; std::optional<std::reference_wrapper<int>> opt = std::ref(a); // opt "смотрит" на a opt = std::ref(b); // Теперь opt "смотрит" на b. Значение a осталось равно 1. // Изменение объекта по ссылке int x = 10; std::optional<std::reference_wrapper<int>> opt = std::ref(x); opt->get() = 42; // x == 42 // или opt.value().get() = 43; // x == 43 Синтаксис выглядит не очень. Оно и понятно, учитывая вложенность классов. Но о чудо! В C++26 этот костыль больше не нужен. Был принят документ P2988R12, который добавляет частичную специализацию std::optional для lvalue-ссылок. Теперь можно писать напрямую: std::optional<int&> opt = a; opt = b; // opt теперь ссылается на b; a остается неизменным *opt = 42; // пишем в b Что важного нужно знать об этой специализации? 👉🏿 Это не владеющий nullable-тип: хранит указатель T* или nullptr, не имеет отдельного стораджа для объекта внутри себя. 👉🏿 Присваивание всегда rebind: optional начинает ссылаться на другой объект; семантика assign-through не используется. 👉🏿 Конструкторы, которые могли бы создать временный объект и dangling-ссылку, удалены. 👉🏿 const optional<T&> позволяет менять объект по ссылке, optional<const T&> - уже нет. 👉🏿 value_or возвращает T по значению, а не ссылку. 👉🏿 Конструирование тривиальное (простая обёртка над указателем). 👉🏿 Ну и наше любимое: автор пропоузала позаботился о том, чтобы по-максимуму минимизировать возможности для появления висячих ссылок. Конструкторы, которые могли бы создать временный объект и dangling-ссылку, удалены. А на другие методы наложены ограничения, которые не позволяют скомпилировать такие конструкции: opt = 42; opt = std::string("привет"); Если кто-то хотел nullable ссылку, то вот вам пожалуйста. Работает в рамках давно привычных конценций. Break crutches. Stay cool. #cpp26
2 189
6
Как перейти от ручного управления дроном к командам из собственного кода? Начать можно с наземной станции управления: Python-
Как перейти от ручного управления дроном к командам из собственного кода? Начать можно с наземной станции управления: Python-скрипта, который работает с телеметрией, выполняет проверки перед взлётом и задаёт полётный сценарий. 16 ноября в 20:00 на открытом уроке курса «Разработчик ПО для дронов: ArduPilot, C++ и ROS 2» напишете свою Ground Control Station с помощью Python и MAVSDK. Разберёте, как MAVSDK помогает программно управлять БПЛА. С нуля создадите скрипт для работы с телеметрией, предполётных проверок и автономного полёта по заданной траектории. Проследите связь между командами в коде и поведением дрона. Для практики настроите локальную среду SITL и проверите скрипт в симуляторе. Такой подход позволяет разбирать поведение программы и проверять команды без испытаний на реальном аппарате. Урок подойдёт разработчикам на Python и C/C++, инженерам встраиваемых систем и специалистам по БПЛА, которые хотят автоматизировать управление. Вы познакомитесь с основой собственной наземной станции и увидите, как объединить телеметрию, проверки и полётные команды в одном сценарии. Урок проведёт Игорь Морозов. Зарегистрироваться: https://otus.pw/J4su/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
1 885
7
​​LRU-кэш на собеседовании #опытным LRU (Least Recently Used) - классический вопрос на собеседованиях. Вроде не чистый литкоды, можно и ООП пописать, и помикроархитектурить. Но тем не менее задача проверяет знание алгоритмов и структур данных применительно к реально используемой штуке. Требования к задаче: 👉🏿 Реализовать LRU-кэш с фиксированной ёмкостью, задаваемой в конструкторе. 👉🏿 Операции get(key) и put(key, value) должны работать за O(1) в среднем. 👉🏿 При переполнении удаляется самый редкоиспользованный элемент. 👉🏿 get возвращает ссылку на значение значение, если ключ есть, иначе - сигнал об отсутствии. 👉🏿 нет требований на потокобезопасность. Типичное решение, безо всяких ухищрений: двусвязный список (std::list) для порядка использования + хеш-таблица (std::unordered_map) для доступа по ключу. template<typename Key, typename Value> class LRUCache { public: using value_type = std::pair<Key, Value>; using list_type = std::list<value_type>; using list_iterator = typename list_type::iterator; using map_type = std::unordered_map<Key, list_iterator>; explicit LRUCache(size_t capacity) : cap_(capacity) { if (cap_ == 0) throw std::invalid_argument("Capacity must be > 0"); } std::optional<std::reference_wrapper<const Value>> get(const Key& key) { auto it = idx_.find(key); if (it == idx_.end()) return std::nullopt; entries_.splice(entries_.begin(), entries_, it->second); return std::cref(it->second->second); } void put(const Key& key, Value value) { auto it = idx_.find(key); if (it != idx_.end()) { it->second->second = std::move(value); entries_.splice(entries_.begin(), entries_, it->second); return; } if (entries_.size() == cap_) { const Key& k_evict = entries_.back().first; idx_.erase(k_evict); entries_.pop_back(); } entries_.emplace_front(key, std::move(value)); idx_.emplace(key, entries_.begin()); } bool contains(const Key& key) const { return idx_.find(key) != idx_.end(); } size_t size() const { return entries_.size(); } size_t capacity() const { return cap_; } private: size_t cap_; list_type entries_; std::unordered_map<Key, list_iterator> idx_; }; Разберём ключевые моменты: Очевидно, что нам нужен ассоциативный контейнер, работающий за O(1). Из стандартного это std::unordered_map. Получим просто key-value хранилище. Теперь нам нужна логика последнего использованного. Здесь надо бы хранить последовательность ключей от самого редкоиспользуемого до последнего использованного. Подойдет какой-то последовательный контейнер. Но нам нужно уметь за константу добавлять новый элемент либо перемещать в начало вновь запрошенный элемент. За константу переместить из середины в начало может std::list. И в конце нам надо как-то связать эти две структуры. В мапке, по которой и будет происходить поиск, в качестве значения будем хранить не значение по ключу, а итератор на лист. Только зная итератор (по сути указатель на элемент) мы можем за константу переместить элемент из середины в конец. Осталось только корректно это все подружить друг с другом и получится рабочее решение. Можно поиграться на годболте. Тут есть потенциал для оптимизаций (например кэш локалити при использовании std::list), это не продовое решение. Но для собеседования это решение базово удовлетворяет всем требованиям. Good luck with interviews. Stay cool. #interview #algorithms
3 124
8
​​С++26. Или все-таки 27? Немного с опозданием, но новость все-таки на канале. Черновик С++26 не удалось утвердить с первого раза на этапе голосования национальных органов ISO. Фактически, принятие С++26 отложено на неопределенный срок. Почему так? Причиной скорее всего являются контракты. По сути, это возможность писать что-то вроде int divide(int a, int b) pre(b != 0) { ... }, где pre — это контракт, проверяемый во время выполнения или компиляции. В общем, это какие-то пред и/или постусловия, которым должны удовлетворять функции. Вроде идея-то классная. Но ее дизайн в стандарте оказался не очень удачным. Против него высказалось достаточно тяжеловесов мира плюсов, в том числе и сам Страуструп. По поводу контрактов были ожесточенные дискуссии и в драфте С++26 был скорее некий MVP контрактов, нежели полноценная функциональность. Бьерн же сказал, что «это не минимально жизнеспособный продукт. Это не минимально и не жизнеспособно», и что контракты добавляют сложность «очень неясными способами», меняя смысл кода в зависимости от контекста. Если кому очень интересно, то вот и вот две бумаги от Бьерна и его коллег, критикующих контракты. Там критика и по функционалу(очень сложно, описание примерно в 56 страниц текста), и по перформансу(не zero-cost) и по процедуре внедрения в драфт стандарта. Тем не менее Страуструп и соавторы не против идеи контрактов как таковой. Они против конкретного неудачного дизайна из черновика С++26. В качестве альтернативы они предлагают: 👉🏿 Признать контракты просто отладочным инструментом, а не функцией безопасности. 👉🏿 Использовать гораздо более простой и мощный библиотечный дизайн, который уже реализован, протестирован и совместим (ссылаются на D4324R0 / P4324R0 — "C++ Design By Contract: Minimum Language, Maximum Library"). 👉🏿 Вместо огромного и неполного языкового механизма сделать ставку на hardened standard libraries (ужесточенные стандартные библиотеки) с минимальными накладными расходами (замерено ~0.3% в production у Google) и статический анализ через C++ Core Guidelines. Ну и главное. Это не конец С++ и не конец С++26. Наоборот, процессы вокруг принятия стандарта оказались способны предотвратить попадания в него вредной функциональности. Провал голосования означает, что комитету придётся вернуться к обсуждению, вероятно, пересмотреть подход к контрактам или процедуру их принятия, и провести повторное голосование. Пишите в комментариях, что думаете по поводу контрактов и ситуации вокруг провала С++26. Ставьте ⚡️, если поддерживаете слоняру-Бьерна. Ставьте🗿, если достали эти деды, не дают языку стать безопаснее. See opportunities in failures. Stay cool.
3 151
9
Экскурсия по лабораториям YADRO: как тестируют серверы и телеком-оборудование В ноябре и декабре YADRO проводит экскурсии по
Экскурсия по лабораториям YADRO: как тестируют серверы и телеком-оборудование В ноябре и декабре YADRO проводит экскурсии по своим лабораториям в Санкт-Петербурге и Москве. На маршрутах — тестовые стенды, оборудование на разных этапах отладки и рабочие пространства команд. Инженеры расскажут, какие проверки проходит железо, и ответят на вопросы. 📍Санкт-Петербург — 12 ноября и 1 декабря 📍Москва — 17 ноября и 8 декабря Сбор гостей в 18:30, старт в 19:00. Экскурсия занимает до двух часов. Участие бесплатное — нужно зарегистрироваться и дождаться подтверждения от организаторов. Возраст участников — от 18 лет. Зарегистрироваться Реклама. ООО "КНС ГРУПП". ИНН 7701411241. erid: 2W5zFGVnpQA
2 819
10
​​Напишите в комментариях самые запоминающиеся/интересные/сложные вопросы/задачи по С++ с интервью, которые вы проходили. Надеюсь из поста читатели смогут для себя подчерпнуть интересные моменты и найти точки роста, чтобы в следующий раз точно пройти собес. Я начну. Написать потокобезопасную очередь с приоритетом. Приоритета всего 3. Количество тасок с 1 и 2 приоритетом в очереди ограничено, с наименьшим приоритетом - неограничено. При попытке вставить в очередь слишком много задач 1 или 2 приоритета, этот метод блочится. Доставаться из очереди таски должны строго по убыванию приоритета: только при отсутствии задач более высокого приоритета можно начать отдавать задачи более низкого. Practice interview. Stay cool.
3 426
11
​​Кондвар - это не брокер сообщений #новичкам Думаю, некоторые из вас работали с кафкой и наслаждались ее функционалом. Этот инструмент позволяет передавать в потоке передавать события от продюсера к консюмеру, при этом сохраняя эти события на случай сбоев, необходимости перечитывания или асинхронной работы продюсера и консюмера. Прекрасная технология. И кондвар не реализует практически ничего из этого. Главная ошибка в рассуждениях - Producer: notify_one(); Consumer: wait(); думать, что notify_one() — это сигнал, который где-то лежит и ждёт, пока потребитель вызовет wait(). Если нотификация произошла до вызова wait, то она безвозвратно потеряется. Для многих это очевидно, но этот факт смещает акценты при проектировании протокола синхронизации. Условно: пусть рядом с вашей дверью находится ваш почтовый ящик. Вы можете каждый раз, когда приходите домой проверять ящик на наличие новых писем. Но скорее всего там очень часто будет пусто. Вместо этого вы говорите почтальону: "вот у меня есть дверной звонок, звоните в него каждый раз, когда приносите письма". И это работает, когда вы дома. Но вы пропустите уведомление, если вас не будет. И по приходу никак не поймете, что приходил почтальон и звонил в звонок. Вместо простого звонка, нужно менять состояние в квартире - зажигать лампочку при звонке например. Так вы зайдете в квартиру, увидите лампочку и пойдете проверять почтовый ящик. То есть основа синхронизации тут не звонок, а лампочка. Звонок нужен, чтобы вы отреагировали, когда вы дома и ждете писем. Так и в программе. Точка синхронизации - это разделяемое состояние, которое изменяет продюсер и читает консюмер. Сам кондвар - это средство предотвращения постоянной проверки. Он не несет в себе никакой другой полезной информации, кроме "что-то произошло, но возможно и нет". Вся полезная информация - в разделяемом состоянии. Поэтому нотифай должен восприниматься: 🔍 Продюсером как клич в пустоту, что разделяемое состояние поменялось. Если никто не услышит, ну и ладно, его дело производить данные. 🔍 Консюмером как обязательный призыв еще раз проверить состояние после того, как он ушел на перекур. Это объясняет, почему: ✅ Спонтанные пробуждения абсолютно безопасны при корректном предикате и циклической проверке. Если предикат всегда чекать после пробуждения, то консюмер будет просто убеждаться в неизмененном состоянии и снова уходить на перекур. ✅ Остановка обработки всегда требует персистентного состояния stopping. Без него приказ об остановке может просто пройти мимо всех ушей обработчиков и нигде не зафиксироваться. ✅ Атомарный флаг события убирает data race, но без повторной проверки все равно вы имеете сломаный протокол: std::atomic<bool> ready{false}; if (!ready) { cv.wait(lock); } Между проверкой if (!ready) и вызовом cv.wait(lock) другой поток может выставить ready = true и вызвать notify_one(). Consumer пропустит уведомление и уснёт. Поэтому кондвар - это не примитив синхронизации. Во всяком случае, не самостоятельный. Ему нужен главный примитив, чтобы охранять разделяемое состояние, в котором будет храниться информация о событиях. Synchronize better. Stay cool. #concurrency
3 594
12
​​Какая память быстрее: стек или куча? #новичкам Это довольно общий и не совсем корректный вопрос, но он специально так поставлен, что ответ был чуть более развернутый. Все равно примерно все понимают его смысл. Работа с памятью начинается с ее выделения. Вот у нас ничего не было и мы захотели создать объект на стеке и в куче. Что будет быстрее? int main() { std::vector<int> vec; std::unique_ptr<std::vector<int>> p_vec = new std::vector<int>{}; return 0; } Тут ответ более менее однозначный. Выделение/освобождение памяти происходит быстрее на стеке. Аллокация на стеке - это просто сдвиг указателя стека на какое-то количество байт. Аллокация на куче - это поиск блока нужного размера во внутренней структуре аллокатора и, потенциально, системный вызов, если блока не нашлось. Короче, ощутимо дольше. Но! Стековая память и память кучи ничем принципиально друг от друга не отличаются. Это все та же RAM. Имея готовые куски памяти в обоих регионах, вы можете работать с ними с одинаковой скоростью чтения/записи. Стек просто заранее предвыделяется при создании потока/процесса. Он уже готовенький для использования и изолирован. Но память, которую мы получаем через new, может быть доступна другим потокам/процессам, поэтому ее надо запрашивать в общем случае через ОС, чтобы нечаянно(или чаянно) чего не натворить. В общем-то говоря, похожим образом работают быстрые кастомные аллокаторы - они заранее большую арену, которую потом очень эффективно можно использовать для размещения объектов. Be faster. Stay cool. #base
3 394
13
Доступные по цене AI-подписки, да ещё и с гарантией на весь срок? В AI Market это норма 🙃 Пользуешься сразу несколькими нейр
Доступные по цене AI-подписки, да ещё и с гарантией на весь срок? В AI Market это норма 🙃 Пользуешься сразу несколькими нейросетями, но оплата подписок быстро превращается в отдельную задачу? То карта не проходит, то продавец пропал, то цена вдруг другая. 🤖AI Market решает эти проблемы разом. Магазин подключает официальные AI-подписки прямо на ВАШ личный аккаунт — никаких общих и «левых» аккаунтов. ☺️ Гарантия не на «первые сутки, а потом как повезёт» — на весь оплаченный срок: восстановят, заменят или вернут деньги. 💡 В магазине есть подписки на ChatGPT, Claude, Gemini, Grok, Midjourney 💳 Оплата российской картой или через СБП ⏰ Активация на ваш личный аккаунт за 5–20 минут 🆓 Нет аккаунта? Создадим бесплатно ⭐️ Не первый год на рынке подписок, знаем все нюансы ⚙️ На связи живой менеджер, а не бот: поможем, если появятся вопросы. 👉 Выбрать подписку в AI Market
1 460
14
​​std::atomic::wait под капотом #опытным В C++20 у атомиков появились wait и notify_one/all. void atomic::wait( T old, std::memory_order order = std::memory_order_seq_cst ) const noexcept; void atomic::notify_one() noexcept; void atomic::notify_all() noexcept; Обычно атомики - это про спинлоки и горячие циклы, а тут какой-то интерфейс аля кондвар. В доке написано, что метод wait блокируется , пока не изменится значение атомика с old на новое. Но как это реализовано? Сегодня будем разбираться. Будем смотреть на реализацию внутри линукса, на других платформах принципы схожи. Для начала: нет, метод wait - это не спинлок. Спинлок - хороший вариант, когда ситуация меняется очень быстро. Но он будет проедать ресурсы вхолостую, если долго не будет нотификации. Поэтому в общем случае нам необходимо засыпать и делать дорогой сискол, чтобы не жечь проц. Но немного спинлока перед сном нам все равно не помешает. И что же за такой сискол, который относительно быстро блокает тред до нотификации? Конечно, наш уже знакомый и любимый futex. Именно этот примитив - основа для "атомарного" ожидания. Реализация определяет примерно такую функцию ожидания и нотификации: template<typename _Tp> __platform_wait(const _Tp* __addr, __platform_wait_t __val) noexcept { auto __e = syscall (SYS_futex, static_cast<const void*>(__addr), static_cast<int>(__futex_wait_flags::__wait_private), __val, nullptr); if (!__e || errno == EAGAIN) return; if (errno != EINTR) __throw_system_error(errno); } template<typename _Tp> void __platform_notify(const _Tp* __addr, bool __all) noexcept { syscall (SYS_futex, static_cast<const void*>(__addr), static_cast<int>(__futex_wait_flags::__wake_private), __all ? INT_MAX : 1); } Если мы поверх фьютекса накрутим несколько раундов проверки в горячем цикле, то вуаля, получили std::atomic::wait Но как всегда есть нюансы. 1️⃣ Фьютекс ассоциирован с 32-битной атомарной переменной. И конечно, такие атомики бывают, но не все они имеют такой размер. Ну то есть в кейсе с 32-битной целочисленной атомарной переменной можно внутри ядра навесить именно на нее функции "опорной переменной" для фьютекса. Но для атомиков другой размерности нужен другой подход. Можно было бы в каждый атомик класть 4 байта данных, с которыми будет ассоциироваться мьютекс. Но это будет слишком раздувать размер типа. Разработчики пошли другим путем: глобальная хэш-мапа отображения адресов атомарных переменных в данные фьютекса. 2️⃣ Есть же версии платформы, на которых нет futex'а. В этом случае в глобальной хэш мапе хранится мьютекс и кондвар и атомарное ожидание вырождается в ожидание на кондваре. Итак, алгоритм ожидания выглядит так: 1. Загружаем текущее значение атомика и сравниваем с old. Если уже не равно — выходим, ждать нечего. 2. Крутимся в спин-цикле фиксированное число итераций, на каждой проверяя значение. Если изменилось — выходим. Это спасает от дорогого сискола, когда ожидание короткое. 3. Если тип атомика — скаляр размером ровно с __platform_wait_t (32 бита на Linux) и с правильным выравниванием, то futex можно повесить прямо на адрес атомика: if constexpr (__platform_wait_uses_type<_Tp>) __platform_wait(__addr, __old); // futex_wait на самом атомике 4. Иначе — идём в глобальную хэш-таблицу __waiter_pool, которая отображает адрес атомика на один из 16 пулов. Внутри каждого пула есть своё 32-битное слово _M_ver, на котором и будет висеть futex: auto& __w = __waiter_pool::_S_for(__addr); __w._M_do_wait(&__w._M_ver, __w._M_ver); // futex_wait на версии пула 5. Если платформенного wait нет вообще (экзотические платформы), в том же пуле лежат mutex и condition_variable, и ожидание вырождается в классический cv.wait(lock, pred) на версии пула. Be efficient. Stay cool. #concurrency #cppcore
3 818
15
​​Оптимистичные и пессимистичные блокировки #опытным Концепция блокировок уходит далеко за пределы языковых примитивов синхронизации. Блокировки актуальны в принципе для любых систем, с которыми можно работать конкурентно. И идейно для таких систем существует 2 типа локов: оптимистичные и пессимистичные. Они имеют принципиальные отличия и это важно понимать для того, чтобы корректно оперировать данными и их обновлениями. Разница между ними в том, как предотвращается конфликт изменения данных из-за конкурентного доступа и что происходит с потоком/транзакцией до этого момента. Пусть для примера у нас будет какая-то ассоциативная структура с кучей записей. И приходит очередной запрос на изменение одной конкретной записи. Начнем с простого. Пессимистичная блокировка. Ее используют, когда есть риск конкурентного доступа/изменения данных и мы не хотим принимать этот риск. Например, в системах, где очень важна консистентность данных - банковский сектор. При пессимистичной блокировке мы запрашиваем эксклюзивный доступ к конкретной записи и при получении доступа больше никто не может изменять ее одновременно с нами. Реализацией пессимистичной блокировки в С++ является всем известный мьютекс. Он обеспечивает эксклюзивный доступ к данным: struct Record { int value = 0; std::mutex mtx; }; void update_record(Record& rec, int new_value) { std::lock_guard<std::mutex> lock(rec.mtx); rec.value = new_value; } Поток, который хочет изменить запись, сначала захватывает мьютекс. Если мьютекс уже кем-то занят, поток встаёт в очередь ожидания и спит, пока владелец не освободит его. В этот момент никто другой не может изменить rec.value — мы работаем в условиях полной изоляции. Плюсами являются предсказуемость, отсутствие откатов, гарантированная консистентность данных. Но за это приходится платить: блокировка и ожидание других запросов, возможность дедлоков, никакого параллелизма и оверхэд на сам факт блокировки записи(например системные вызовы и тд). Теперь представим, что конфликты редки. Например, у нас миллиарды записей, и запросы на изменение приходят к разным записям. Блокировать каждую запись мьютексом — значит платить за блокировку там, где она почти никогда не нужна. Именно для таких случаев придумали оптимистичную блокировку. Идея проста: мы не блокируем запись. Мы читаем её, запоминаем версию (или timestamp), работаем, а перед записью проверяем — не изменил ли кто-то запись, пока мы думали. Если не изменил - записываем. Если изменил - откатываемся и повторяем. Для С++ нет отдельного примитива под это дело, потому что оптимистическая блокировка - это скорее паттерн, который надо отдельно внедрять в логику работы с данными. Но его легко собрать из std::atomic и CAS (compare-exchange): struct Record { // [ version: 32 бита ][ value: 32 бита ] std::atomic<uint64_t> state{0}; }; bool try_update(Record& rec, int new_value) { uint64_t old = rec.state.load(); uint32_t version = uint32_t(old >> 32); uint64_t desired = (uint64_t(version + 1) << 32) | uint32_t(new_value); return rec.state.compare_exchange_strong( old, desired); } void update_with_retry(Record& rec, int new_value) { while (!try_update(rec, new_value)) { } } Здесь state - это счётчик версии, который увеличивается при каждом успешном обновлении, + само значение value. Если между нашим чтением и попыткой записи кто-то другой уже обновил запись, первая часть state изменится, и compare_exchange_strong вернёт false. Тогда просто повторяем попытку. Плюсами здесь будет: отсутствие блокировок и накладных расходов на них, нет ожиданий, высокая параллельность при редких конфликтах. Минусы - при частых конфликтах много откатов и повторной работы, нагрузка на CPU. Ну и для некоторых доменов просто неприемлемо будет ретраить запросы и/или повторно пересчитывать актуальное значение. Выбор между двумя типами блокировок - это выбор между гарантией и параллелизмом. И хороший инженер должен уметь считать, что более важно в его конкретной задаче. Give guarantees. Stay cool. #concurrency
3 552
16
​​Что внутри std::condition_variable? #опытным Более менее все знакомы с примитивом синхронизации "условная переменная". При наличии мьютекса она может погрузить поток в сон до тех пор, пока не поступит уведомлении и условие пробуждение не будет истинным. Сильно упрощая, в консюмере ждем события на wait, а в продюсере уведомляем через notify о возникновении события. std::mutex mtx; std::condition_variable cv; bool ready = false; void consumer() { std::unique_lock lock(mtx); cv.wait(lock, []{ return ready; }); // Wait until 'ready' is true // Proceed with work } void producer() { { std::lock_guard<std::mutex> lock(mtx); ready = true; } cv.notify_one(); // Wake up one waiting thread } Но как это работает под катопом? Если задуматься, то кондвар очень похож на семафор и мьютекс. По сути оба отправляют поток спать, когда счетчик пытаются декрементить ниже 0. И они оба уведомляют одного из ожидающих, когда счетчик становится равным 1 или больше. Да, семантика разная, но факт на лицо: есть и ожидание и уведомление. Так может у кондваров и мьютексов/семафоров есть общие инструменты реализации? Бинго! На линуксе есть такая штука - futex. Fast Userspace muTEX. Это низкоуровневый примитив синхронизации в ядре. Главная идея: быстрый путь (захват/освобождение без конкуренции) делается в userspace обычными атомарными операциями. Ядро вызывается только когда нужно усыпить или разбудить поток. Если надо усыпить поток - он помещается в очередь ожидания. Если надо разбудить поток - он достается из головы очереди и продолжает исполнение. Так вот кондвары и реализованы на основе такой очереди. Конечно, нужно довольно много всего построить вокруг помещения потока в ожидание, но принцип такой. При вызове wait поток освобождает переданный мьютекс и засыпает(вызывается условный futex_wait), помещаясь в очередь ожидания. При уведомлении (вызов futex_wake) о наступлении условия поток достается из очереди, будится и конкурирует за захват мьютекса, чтобы честно проверить верность условия(может быть stolen wakeup и поток обратно уйдет спать). Прямым аналогом futex в Windows является семейство функций WaitOnAddress и WakeByAddressSingle/WakeByAddressAll. Don't busy wait. Stay cool. #concurrency #OS
3 280
17
​​WAT #новичкам Как вы думаете, результат выражения: bool math = -1 < 1U; будет правдой или ложью? Нормальный человек думает, что математика работает. Но С++ выкидывает ее в мусор и по итогу math == false. #ЧЗХ ? Вместо того, чтобы приводить беззнаковое число к знаковому, С++ делает наоборот. В итоге -1 должен конвертироваться в неотрицательное число. В дополненном коде -1 это 0xFFFFFFFF ака все единички, поэтому при касте к беззнаковому числу оно просто становится UINT32_MAX. И оно конечно больше 1. Выход тут один. Не сравнивать знаковые и беззнаковые числа в одном выражении. Включайте -Wall -Werror и получите ошибку компиляции. После исправления арифметика будет работать как ожидается. Mix things consciously. Stay cool #cppcore
3 328
18
​​Strict weak ordering #опытным На первый взгляд, всё выглядит рабочим: мы создаём 40 заказов с одинаковой ценой 100 и уникальными id, затем сортируем по возрастанию цены, используя <=. Программа компилируется и даже выполняется без ошибок… пока не достигнет определённого размера. Тогда она падает с segmentation fault. struct Order { int price; int id; }; int main() { std::vector<Order> book; for (int i = 0; i < 40; ++i) { book.push_back({100, i}); } std::sort(book.begin(), book.end(), [](const Order& a, const Order& b) { return a.price <= b.price; }); std::cout << "book.size() = " << book.size() << '\n'; return 0; } Но почему так? Мы же вообще ничего криминального не делали, а получили UB. Баг на самом деле в том, что компаратор не удовлетворяет требованию strict weak ordering. Конкретно проблема в иррефлексивности компаратора. Для любых двух элементов с одинаковой ценой (в нашем случае все цены равны 100) компаратор возвращает true в обе стороны: - comp(a, b) = 100 <= 100 → true - comp(b, a) = 100 <= 100 → true Это означает, что comp(a,a) тоже true (так как 100 <= 100). Согласно стандарту, компаратор должен возвращать false для сравнения объекта с самим собой. Это и есть требование иррефлексивности. Нарушение этого правила приводит к тому, что алгоритм сортировки некорректно сравнивает одинаковые элементы и по итогу входит за границы последовательности Ну окей. "А почему эффекты проявляются только после определенного размера последовательности?" Потому что реализация std::sort в стандартной библиотеке обычно использует интроспективную сортировку (introsort), которая выбирает стратегию в зависимости от размера диапазона: 1️⃣ Для малых подмассивов (обычно < 16 элементов) используется сортировка вставками (insertion sort). На каждом шаге работы эта сортировка проходится по всем предыдущим элементам и меняет текущий, если компаратор возвращает true. Есть четкая граница остановки - первый элемент. Поэтому даже если компаратор будет возвращать true для одинаковых элементов, то это приведет лишь к лишним обменам элементов. 2️⃣ Для больших диапазонов introsort переключается на быструю сортировку (quicksort) с разбиением (partitioning) вокруг опорного элемента (pivot). Именно в фазе разбиения и прячется баг. Алгоритм разбиения тут примерно следующий. Обычно выбирается опорный элемент pivot. Затем два указателя двигаются навстречу друг другу, пока не найдут элементы, которые должны быть поменяны местами: while (comp(*left, pivot)) ++left; // пока левый < pivot while (comp(pivot, *right)) --right; // пока pivot < правый Если comp использует <=, то для равных элементов оба условия вернут true: - comp(*left, pivot) вернёт true (если *left == pivot, то pivot <= pivot → true) - comp(pivot, *right) тоже true (если *right == pivot). Таким образом, левый указатель будет двигаться вправо, пока не выйдет за границы, а правый — влево, также за пределы. Это приводит к чтению/записи за пределами массива и, в конечном счёте, к крашу. Решение тут простое и даже есть соответствующая мемная паста на кодфосес. "Компаратор в С++ должен возвращать false, если аргументы равны". Или в нашем примере: std::sort(book.begin(), book.end(), [](const Order& a, const Order& b) { return a.price < b.price; }); Reflect on your life. Stay cool. #STL
3 717
19
Немного поиграл с настройками и собрал город в духе La Belle Époque: с исторической застройкой, насыщенными улицами и минимум
Немного поиграл с настройками и собрал город в духе La Belle Époque: с исторической застройкой, насыщенными улицами и минимумом футуризма 🚂 Это не свежая часть SimCity, а новая игра от YADRO, где смешались архитектура прошлого, современные технологии и массовая культура — от здания Наркомфина до «Бегущего по лезвию». А какой город получится у вас? Выкрутите память на максимум — и построите известные шедевры прошлого 🏛 Или выберете летающие автомобили и технологии будущего 🚄 Вам решать! И не забудьте поддержать YADRO в рейтинге работодателей hh 😎
1 190
20
​​Где-то баг... #опытным Вот вам код: struct Order { int price; int id; }; int main() { std::vector<Order> book; for (int i = 0; i < 40; ++i) { book.push_back({100, i}); } std::sort(book.begin(), book.end(), [](const Order& a, const Order& b) { return a.price <= b.price; }); std::cout << "book.size() = " << book.size() << '\n'; return 0; } Все ли в нем хорошо? Вы уверены? В чем здесь могут быть проблемы и какие у них проявления? Напишите в комментах. Prevent bugs. Stay cool.
3 324