DiscoverБитовые маски: о системном программировании простыми словами
Claim Ownership
Битовые маски: о системном программировании простыми словами
Author: Елена Лепилкина и Антон Афанасьев
Subscribed: 20Played: 106Subscribe
Share
2024 © Елена Лепилкина и Антон Афанасьев. Все права защищены.
Description
Системное программирование и разработка процессоров — область довольно узкая. Но именно в ней работает множество отличных профессионалов, создавших продукты, которыми программисты пользуются ежедневно. Мы познакомим вас с этими экспертами, расскажем об актуальных задачах, которые решают в отрасли, и покажем варианты развития для системных программистов и тех, кто хочет ими стать.
11 Episodes
Reverse
В гостях у «Битовых масок» — Алексей Бродкин из Synopsys. Он работает в компании уже 16 лет и сейчас руководит инженерами, которые разрабатывают Linux и операционные системы реального времени. Поговорим с гостем об особенностях ОС и их поддержки для разных процессоров и архитектур. А еще обсудим на примере ARC-V, зачем большому вендору вкладываться в создание процессорного семейства, которое будет использовать набор команд открытой архитектуры RISC-V.
Почему вероятность появления новой большой и полноценной операционной системы очень мала? Что представляет из себя уровень аппаратных абстракций в ОС? Можно ли начинать разработку операционной системы до появления микросхемы в кремнии? Как взаимосвязаны прерывания, их обработчики и планировщик задач? Ответы на эти и другие вопросы — в одиннадцатом эпизоде «Битовых масок».Упомянутые полезные ссылки вы найдёте в описании к видеоверсии выпуска: https://youtu.be/e8CidbF_OiU00:00:00 — Тизер
00:01:31 — Вступление
00:01:50 — Представление Алексея
00:02:41 — Начало карьеры и текущая деятельность Алексея
00:07:00 — Микроконтроллер vs. микропроцессор
00:10:43 — ОС, над которыми работает команда Алексея
00:11:45 — Почему может появиться/не появиться еще одна ОС/RTOS
00:16:13 — Что такое ОС и зачем она нужна
00:20:41 — Создание драйверов
00:27:23 — Микроядерные ОС
00:32:40 — Уровень аппаратных абстракций: HAL и BSP
00:40:29 — Разница между полномасштабной ОС и RTOS
00:47:14 — Миграция фич из полномасштабных ОС в RTOS
00:57:41 — POSIX как механизм абстракции
01:01:16 — Дорастет ли Zephyr до полномасштабной ОС
01:05:59 — Управление проектом Zephyr RTOS
01:08:41 — Поддержка новой архитектуры в Linux
01:18:18 — Linux в гетерогенных системах
01:22:44 — Использование компонентов других производителей крупными производителями
01:26:11 — Обработка прерываний и планировщик задач в ОС
01:36:50 — Семейство ARC-V на базе RISC-V от Synopsys
01:50:03 — Заключение
01:50:41 — Благодарности✅ Подписывайтесь на Telegram-канал подкаста: https://t.me/+bx50QfUlw4pkZDEy
В этом выпуске мы возвращаемся на уровень разработки аппаратного обеспечения. В гостях у «Битовых масок» — Алексей Ковалов, руководитель группы модульной верификации в YADRO, который в прошлом успел поработать как в стартапе, так и в глобальной корпорации. Он расскажет, как устроен процесс верификации аппаратуры, а также какие языки и методологии в нем применяют.
Как инженеры принимают решение о том, что конкретный блок верифицирован? Нужно ли тестировать тестовое окружение? Какие особенности есть у языка SystemVerilog и можно ли писать TestBench на C++ или Python? Что такое «токсичные» интерфейсы? Является ли UVM серебряной пулей? Как выглядит рынок труда в hardware-разработке и как его особенности влияют на подходы к работе? Обсудим эти и другие связанные с верификацией вопросы в десятом эпизоде «Битовых масок».
Видеоверсия выпуска: https://youtu.be/A3Y5gb4YIt4Подписывайтесь на Telegram-канал подкаста: https://t.me/+bx50QfUlw4pkZDEy
0:00:00 — Тизер
0:00:46 — Представление Алексея
0:01:55 — Как Алексей попал в верификацию
0:08:33 — Как часто выходят новые стандарты SystemVerilog
0:11:22 — В чем заключается верификация аппаратуры, ее виды и подходы
0:25:29 — Особенности работы в командах с legacy-кодом
0:29:16 — Как должен работать верификатор и какие задачи у верификаторов
0:33:25 — Нужно ли писать тесты на сам TestBench
0:35:10 — Помощь от верификаторов для воспроизведения и фикса багов
0:39:55 — Особенности и магические сущности несинтезируемой части языка SystemVerilog
0:50:07 — Может ли верификатор верифицировать любые аппаратные блоки
0:51:15 — «Токсичные» интерфейсы (CHI)
0:54:19 — Верификация на VHDL
0:56:08 — UVM
1:01:49 — Проблемы с готовыми VIP от различных вендоров
1:07:23 — Проблемы UVM
1:10:56 — Уникальные вещи в SystemVerilog
1:16:11 — Верификация на С++
1:17:54 — Верификация на Python, cocotb
1:27:37 — Верификация на Chisel
1:29:47 — Особенности рынка труда в hardware-разработке
1:41:12 — Как проходят собеседования и их недостатки
1:58:15 — Заключение
Гость выпуска — инженер Дмитрий Рябцев, который начинал свою карьеру в команде Intel и больше 20 лет разрабатывал Intel VTune, инструмент анализа производительности программ для компьютеров на базе x86-процессоров. Дмитрий расскажет, как профилировщики устроены изнутри, а также даст подсказку, с чего стоит начинать профилирование различных систем.
Почему профилировщиков сравнительно немного? Какими они бывают? Как устроена аппаратная поддержка профилирования? Что скрывается за аббревиатурой TMA? В чем заключается фундаментальная проблема инструментов для анализа производительности программ? Почему Intel VTune долгое время был платным? Ответы на эти и многие другие вопросы — в девятом эпизоде «Битовых масок».
Смотреть видеоверсию выпуска: https://youtu.be/zIdySCwntXcКстати, у подкаста появился канал в Telegram. В нем мы будем публиковать анонсы новых выпусков, вместе с вами выбирать следующие темы для обсуждения и интересных гостей, а также делиться фотографиями и видео со съемок. Подписывайтесь по ссылке: https://t.me/+vCkZB-u3bgEyZDli 00:00:00 — Тизер выпуска
00:01:00 — Представление гостя
00:01:56 — Начало карьеры в Intel
00:04:44 — Зачем нужны профилировщики
00:08:14 — Типы профилировщиков и как они работают
00:12:01 — Профилировщики для нативных приложений и для систем с managed runtime
00:15:51 — Почему профилировщиков немного
00:16:52 — Почему Intel VTune был платным
00:19:15 — Фундаментальная проблема профилировщиков
00:22:19 — Влияние профилировщиков на результаты
00:26:20 — С чего начать профилирование сложной системы
00:28:44 — Особенности Intel VTune
00:31:03 — Аппаратная поддержка для профилирования
00:39:33 — Внутренние и внешние пользователи Intel VTune
00:42:17 — Top-down Microarchitecture Analysis Method
00:55:26 — Боятся ли вендоры реверс-инжиниринга
00:57:25 — Накладные расходы счетчиков
00:59:23 — Основные микроархитектурные bottlenecks
01:09:33 — Почему сложно сделать универсальный профилировщик для всех микроархитектур
01:13:58 — Верификация формул TMA для микроархитектуры
01:16:59 — Профилирование многопоточных приложений
01:23:44 — Заключение
Во второй части выпуска «Битовых масок» Константин Владимиров, инженер с 20-летним опытом разработки на C/C++, расскажет об особенностях разработки компиляторов для GPU. А также порассуждает о новых полезных вещах в стандартах C++ и объяснит, почему разработчикам компиляторов так важно знать стандарт.
Чем отличаются CPU и GPU? В чем сложность гетерогенного программирования? Почему MLIR не применяется в графических компиляторах? Как использовать LLVM для GPU-компиляторов, несмотря на его недостатки для подобных архитектур? Когда мешает SSA? Почему наличие undefined behaviour — это хорошо? Что может быть включено в C++26? Ответы на эти и другие вопросы вы узнаете из второй части выпуска.
Видеоверсия выпуска: https://youtu.be/_SIBiSR8rzM00:00:00 — Тизер второй части
00:01:00 — Отличия CPU и GPU
00:02:33 — Особенности компиляторов для GPU
00:04:31 — Сложности применения LLVM для GPU-компиляторов
00:06:43 — Spill’ы в шейдерах
00:10:45 — Сложность гетерогенного программирования
00:11:48 — Проблемы компиляторных инженеров
00:13:57 — Использование LLVM в GPU-компиляторах
00:19:27 — MLIR и возможность его применения
00:21:43 — Особенности языков для GPU
00:26:37 — Backend в GPU-компиляторах
00:27:12 — Интересный баг
00:32:56 — Стоит ли писать на ассемблере
00:34:19 — Почему важно знать стандарты C++
00:36:40 — Ошибка в Linux
00:39:26 — Польза undefined behaviour
00:46:04 — Новшества в C++23 и C++26
00:56:07 — Участие в разработке стандартов C++
01:01:30 — Заключение
В этом выпуске Константин Владимиров, занимавшийся разработкой компиляторов для CPU и GPU, расскажет о том достоинствах и недостатках GCC и LLVM. Константин опишет различные современные подходы к аллокации регистров, применяемых в компиляторах. А также поделится базовыми рекомендациями для пользователей компиляторов, желающих улучшить производительность своих программ с помощью компиляторов. Кроме того, мы обсудили животрепещущий вопрос об IT-образовании.
Насколько больно переходить на новые версии компилятора? По каким причинам выбирают LLVM? Какие достоинства и недостатки GCC и LLVM? Какие методы решения задачи аллокации регистров существуют? Насколько этот этап влияет на скорость работы программы? Почему инженерам полезно идти преподавать в ВУЗы? Какие проблемы есть у современного высшего образования в сфере IT? Ответы на эти и другие вопросы вы узнаете из этого эпизода. Больше интересного обсудим с Константином во второй части выпуска, которая выйдет чуть позже.
Видеоверсия выпуска: https://youtu.be/oXjS8mJk6VEСсылка на канал Константина: https://www.youtube.com/@tilir00:00:00 - Тизер
00:00:22 - В гостях Константин Владимиров
00:01:40 - Карьерный путь Константина
00:08:16 - Как Константин попал в сферу разработки компиляторов
00:10:05 - Процесс проектирования микроархитектуры
00:11:39 - Сравнение GCC и LLVM, преимущества и недостатки
00:15:47 - LLVM IR
00:16:41 - Все крупные системы должны быть переписаны на C++
00:17:18 - Преимущества C
00:18:57 - Наследие, оставшееся от С, в GCC
00:20:19 - Ниши gcc и clang
00:22:26 - Отсутствие бинарной совместимости для LLVM IR
00:24:42 - Различные методы аллокации регистров в компиляторах
00:34:47 - Как аллокация регистров влияет на качество сгенерированного кода
00:36:15 - Рекомендации для пользователей компиляторов
00:37:02 - Архитектурные решения проблемы аллокации регистров
00:40:07 - Польза преподавательской деятельности
00:43:43 - Собеседования при найме
00:45:27 - Что полезно для развития специалиста
00:46:56 - Проблемы IT-кафедр
00:52:10 - Участие компаний в высшем образовании
00:55:27 - Новогоднее пожелание будущим инженерам от Константина
В этом выпуске Александр Разинков, работавший во множестве компаний в сфере разработки встраиваемых систем, расскажет о том, как происходит передача данных в беспроводных сетях. Александр объяснит алгоритм работы передачи данных, а также расскажет о задачах операционных систем. Что может привести к замедлению передачи данных по Wi-Fi? Какие ограничения скорости передачи данных существуют? Насколько устройства отстают от самых современных стандартов? Для чего нужны гетерогенные системы? В чем отличие Linux от RTOS? Можно ли написать ядро ОС на C++? Эти и многие другие вопросы обсудили в этом выпуске «Битовых масок».Смотреть видеоверсию выпуска: https://youtu.be/IfRLOYb00kw00:00:00 - Вступление
00:01:38 - Начало работы в сфере встраиваемого ПО
00:05:03 - Сетевые протоколы, стандарты, особенности и сферы применения
00:09:24 - Ограничения и возможности для развития существующих и появления новых стандартов
00:12:40 - Модуляция сигнала
00:13:40 - Алгоритм передачи данных в сети без коллизий
00:17:19 - Что может создавать помехи для работы сетей
00:21:03 - Multi-user MIMO
00:25:00 - Отставание устройств от стандартов и протоколов
00:28:30 - Internet of Things
00:29:56 - Отладка беспроводных сетевых протоколов
00:35:10 - Гетерогенные системы
00:40:32 - Необходимость знания алгоритмов и особенности работы
00:43:37 - Комбинация baremetal и linux в гетерогенных системах и взаимодействие между ядрами
00:47:08 - ARM big.LITTLE
00:50:03 - Операционные системы, планировщик, отличия RTOS
01:07:29 - Можно ли написать ядро ОС на C++
01:11:17 - Заключение
В этом выпуске Никита Поляков, работавший в МЦСТ и Syntacore, позволит понять, как выглядит работа разработчика процессоров. Никита рассказал о различных специализациях, которые есть внутри профессии, какие тулы используются и на какие этапы делится разработка процессоров. В чем преимущества и недостатки архитектуры Эльбрус(VLIW) и RISC-V? Какие языки разработки аппаратуры бывают и в чем их отличие от языков программирования? Как происходит отладка? Как происходит синтез многоядерных процессоров? Нужно ли уметь обращаться с паяльником и осциллографом разработчику процессоров? Что вообще могут и в каком виде продавать компании, специализирующиеся на разработке аппаратуры? И многие другие вопросы обсудили в этом выпуске.00:00:00 - Тизер
00:00:52 - Представление гостя
00:02:17 - Как Никита стал разработчиком процессоров, учеба в МФТИ
00:05:33 - Начало работы в МЦСТ
00:06:45 - Различные специализации разработчиков процессоров
00:08:37 - Языки описания аппаратуры и инструменты для разработки процессоров
00:13:26 - Сходства Verilog и языков программирования
00:14:43 - Отличия Verilog и языков программирования
00:17:49 - Моделирование/верификация и синтез с помощью Verilog
00:20:50 - Автоматические и ручные оптимизации схемы во время синтеза
00:23:07 - Тулы симуляции и синтеза, этапы разработки
00:27:11 - Баги и процесс отладки
00:31:15 - Процесс синтеза больших устройств, синтез многоядерных процессоров
00:37:35 - Этап верификации аппаратуры
00:41:47 - Результирующие продукты, Soft IP
00:48:29 - Как справляться с багами в уже выпущенных модулях и процессорах
00:51:39 - Развитие языка Verilog и его стандарты
00:55:23 - Баги в тулах для разработки процессоров
00:58:26 - Chisel
01:04:25 - Архитектура Эльбрус
01:10:55 - Различия RISC-V и Эльбруса
01:22:17 - Где учиться разработке процессоров, что должен знать разработчик процессоров
01:25:46 - Связь между программированием и разработкой аппаратуры, миграция фич из ПО в аппаратуру
01:28:48 - Возможен ли переход в разработчики процессоров из другой специальности
01:35:42 - Нужны ли паяльник и осциллограф при работе
01:40:22 - Заключение
В этом выпуске Владимир Кемпик, имеющий опыт работы в Oracle, Azul и Syntacore, погрузил нас в мир JVM. Он рассказал об огромном разнообразии различных компиляторов и сборщиков мусора, применяемых в Java мире. Какие трюки для оптимизации кода может позволить себе JIT? Зачем нужны AOT-компиляторы? Какие альтернативные решения придумали JVM-инженеры, чтобы ужиться с запросами микросервисов? Как происходит поддержка новых архитектур в JVM? Почему бэкпорт поддержки RISC-V в JDK17 значимое событие?
00:00:00 - Тизер
00:00:47 - Представление гостя
00:01:41 - Работа в Oracle
00:03:21 - Работа в Azul и поддержка Apple M1 в JVM
00:08:53 - Базовые понятия: JRE, JDK, JVM
00:11:21 - Принцип "Write once, run everywhere"
00:12:49 - Мифы о Java
00:14:24 - Разнообразие сборщиков мусоров
00:16:42 - Баг с утечкой памяти
00:22:10 - Компиляторы и интерпретаторы в JVM
00:32:02 - Компиляторные оптимизации
00:38:24 - Компромисс между временем компиляции и эффективностью сгенерированного кода
00:40:49 - AOT-компиляторы в Java мире
00:42:24 - Альтернативные решения для быстрого старта микросервисов
00:45:52 - Чем компилировать C1 и С2
00:52:28 - Поддержка новой архитектуры в JVM
00:53:54 - Работа с разными версиями Java
00:56:20 - Поддержка RISC-V в JDK17 (LTS)
00:59:33 - Текущее состояние поддержки RISC-V в JVM
01:04:03 - Поддержка расширений RISC-V
01:08:19 - Поддержка runtime в самой архитектуре
01:14:22 - Учитываются ли особенности микроархитектуры процессора
01:16:48 - Перенос изменений в upstream JVM
01:18:57 - Заключение
Говорим с Антоном Колесовым о дебаггерах для C/C++, в основном о gdb. Опираясь на 10-летний опыт работы в команде отладчиков Synopsys, он рассказал о внутреннем устройстве отладчиков, DWARF, отладке gdb с его же помощью и кастомных тулчейнах, связи с компилятором и интеграции в IDE.
00:00:00 - моменты о бажных компиляторах и дебаггерах
00:00:36 - представление гостя
00:00:46 - учеба и начало карьеры
00:03:00 - легко ли построить GNU toolchain
00:04:30 - как Антон пришел к разработке дебаггеров
00:05:18 - внутреннее устройство дебаггеров
00:08:44 - dwarf-информация и почему виноваты компиляторы
00:22:12 - правильный алгоритм отладки
00:23:15 - как уронить gdb
00:23:53 - пишут ли код компилятора разработчики дебаггеров
00:24:18 - незавидная доля дебаггеров
00:26:04 - как отлаживать дебаггер
00:34:36 - баги в дебаггерах
00:37:01 - взаимодействие деббагера и операционной системы
00:39:56 - отладка многопоточных приложений
00:42:35 - non-stop debugging
00:45:06 - real-time tracing
00:51:52 - отличия работы дебаггера при отладке baremetal-приложений
00:56:38 - информация об архитектуре в дебаггере
01:03:59 - lldb vs gdb
01:10:29 - покупают ли сейчас коммерческие компиляторы и дебаггеры
01:12:16 - интеграция дебаггера в IDE
01:17:28 - заключение
В этом выпуске беседуем с Александром Чуйковым, который помогал клиентам из крупных компаний в отладке множества системных и встраиваемых приложений, работая в отделах технической поддержки STMicroelectronics, Synopsys и Syntacore. Он расскажет, как происходит отладка функциональных и performance проблем различных систем (в том числе и baremetal) на самом разном уровне и поделится примерами интересных и сложных багов.00:00:00 - Смешная история про баг00:00:30 - Представление гостя
00:02:25 - Чем занимается Customer Support в системном программировании и кто там работает
00:09:40 - Особенности отладки функциональных багов системных и низкоуровневых приложений
00:16:53 - Баг, воспроизводящийся только через долгое время
00:18:18 - Отладка многопоточных приложений на низком уровне
00:20:18 - Идеальный отладчик существует?
00:21:35 - Неожиданный и сложный функциональный баг, который долго пытались воспроизвести
00:24:27 - История о том, как чтение warning-ов компилятора может помочь при отладке
00:27:32 - Поиск и отладка performance-проблем
00:28:50 - Профилирование baremetal-приложений
00:30:42 - Изменение приложений для ускорения и портирования приложений на архитектуру
00:32:42 - Пример performance-проблемы из-за кэшей
00:34:20 - Как компиляторы могут помочь при наличии performance-проблем
00:40:36 - Reducing performance-проблем
00:42:10 - Когда нужно идти с проблемой к аппартчикам
00:42:50 - Тайные знания, которыми владеет отдел customer support
00:44:13 - История про проектирование процессора по интересным требованиям заказчика
00:48:02 - Помощь аппаратчиков при отладке сложных проблем
00:49:55 - Пример комбо-бага
00:53:55 - Когда и что стоит писать на ассемблере
00:56:02 - Реальные случаи одновременной отладки проблем людьми из разных команд
00:58:12 - Самый забавный баг
01:00:17 - Сколько NDA с клиентами подписал Александр за свою карьеру
01:01:59 - Заключение
В первом выпуске беседуем с Дмитрием Петровым – он участвовал в разработке С/С++ компилятора в МЦСТ и Kotlin компилятора в JetBrains. А теперь снова вернулся к компилятору C/C++, но уже для RISC-V архитектуры, в Syntacore.0:00:00 - Представление гостя0:01:53 - Устройство компилятора (верхнеуровнево)
0:03:33 - Задачи фронтенда и бэкенда компилятора
0:06:08 - Параллелизм на уровне инструкций, instruction scheduling
0:21:52 - Бенчмарки и performance компиляторов
0:25:21 - Взаимосвязь instruction scheduling и register allocation
0:31:12 - Начало карьеры: МЦСТ, Sun Microsystems
0:39:44 - Работа в Intel
0:43:37 - Разработка Kotlin-компилятора и работа в JetBrains
0:59:31 - Инструменты разработки
1:02:24 - Совет начинающим программистам