**Секреты Concurrency: от процессора до атомиков в Go | Полное руководство — Transcript & Summary | SozAI**
Source: https://sozai.app/transcript/concurrency-secrets-go-processor-atomics-guide/

Видео о многопоточном программировании: от пакетной обработки и однозадачных систем до многозадачности, закона Мура и атомарных операций в Go на ассемблере.

## Key Takeaways

- Рост производительности перешёл от одного быстрого ядра к множеству ядер, что сделало многопоточность необходимой
- Атомарные операции и примитивы синхронизации лежат в основе любого многопоточного кода
- Понимание аппаратного уровня (кэши, прерывания, инструкции процессора) важно для написания корректного конкурентного кода

## What the video covers

- Введение в многопоточное программирование и рост числа ядер процессоров
- История: пакетная обработка и её неэффективность (блокировка при IO, невозможность отмены задач)
- Однозадачные системы и ограничения последовательного выполнения
- Кооперативная многозадачность (например, MS-DOS) и её недостатки
- Вытесняющая многозадачность, роль аппаратных прерываний и планировщика ОС
- Появление Unix и IBM OS/360 как прорыв в многозадачности
- Закон Мура и рост числа транзисторов, его постепенное замедление
- Переход к многоядерным процессорам из-за утечек заряда и предела частоты
- Проблемы когерентности кэшей и необходимость синхронизации между ядрами
- Реализация атомарных операций (CAS, Fetch-and-Add) на ассемблере и их роль в консенсусе потоков

## Chapters

1. 00:00 Введение и мотивация
2. 05:30 Пакетная обработка и однозадачные системы
3. 16:00 Кооперативная и вытесняющая многозадачность
4. 25:00 Закон Мура и переход к многоядерности
5. 40:00 Когерентность кэшей и синхронизация ядер
6. 51:40 Атомарные операции и консенсус
7. 65:00 Реализация атомиков в Go на ассемблере
8. 75:00 Производительность и заключение

Answers

## Questions about this video

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

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

Что такое кооперативная многозадачность и чем она отличается от вытесняющей?

При кооперативной многозадачности задача сама отдаёт управление, и её нельзя прервать извне. При вытесняющей ОС контролирует распределение процессора и может прервать задачу через аппаратные прерывания.

Зачем в многопоточном программировании нужны атомарные операции?

Они позволяют потокам безопасно обновлять общие данные и достигать консенсуса, например через операции CAS, без гонок данных, которые возникают при обычном доступе из нескольких ядер.

## Full Transcript — Download SRT & Markdown

00:00

Speaker A

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

00:15

Speaker A

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

00:27

Speaker A

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

00:42

Speaker A

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

00:56

Speaker A

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

01:11

Speaker A

процессора. Вы пишете программу, понятно, о дебаггеров тут речь не идёт, засовываете её в машину, она вам потом выдаёт ответ, и вы смотрите, что получилось. Вот. Ну, эта штука работала довольно долго по сравнению с текущими мощностями. И, ну, понятно, то есть вы

01:24

Speaker A

засунули задачку и там через какое-то время получили ответ. Вот у этого и всей истории было довольно неэффективной исполнение. В каком плане? Если, например, какая-то вот понятно, есть пакет задач. Если какая-то одна задача, например, взаимодействует с каким-то IO устройством, ну, например, там с

01:42

Speaker A

принтером, да, условно, там надо напечатать что-то или там с какими-то файлами, ну что угодно, какое-то i, короче, то все остальные задачи ждали.

01:51

Speaker A

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

02:03

Speaker A

там бага, к сожалению, задачку отменить нельзя. То есть такие вот штуки, они не позволяли сделать с конation задачи. И вот если вы её поставили, то уже как бы отменить её нельзя. Дальше у нас идёт следующая ступенька развития - это так называемая

02:17

Speaker A

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

02:30

Speaker A

уже более такие истории, когда вот как переносимо устройство, как компьютер. У нас есть, понятно, возможность исполнять одну задачу за раз. Всё, мы как бы что-то сказали, делая, и оно исполняется. Вот. Пока опять же задача не завершилась, все остальные её ждут.

02:44

Speaker A

То есть, если вы, допустим, запустили какую-то задачу, которая там в бесконечном цикле крутится, то все остальные задачи вынуждены её вот дожидаться, потому что, ну, вот всё, да, у нас одна задача, которую нельзя никак извне отменить. Есть небольшие, сказать,

02:59

Speaker A

доработки в том плане, что вот ближе к концу развития вот этих систем появились, вроде бы как раз-таки MSdos была такой системой. Вот в то, идея в том, что задача могла добровольно отдать управление. Это называется кооперативная многозадачность. То есть когда,

03:13

Speaker A

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

03:25

Speaker A

полагаться не стоит. Хотя тоже небольшой такой дисклеймер, в год до годень 14 была именно кооперативная многого заздачность. То есть у вас, грубо говоря, если мы ещё не говорили про грутины, там, про потоки, да, но вот у вас как бы только одна задача могла

03:38

Speaker A

отдать другой доступ, да, другой вот ресурсы, а прервать её было никак нельзя. Далее у нас появились многозадачные системы. Это вот уже полноценная история, когда есть прерывание, то есть у нас есть множество задач. Эти задачи, они конкурируют за процессор. То есть понятно, у меня

03:56

Speaker A

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

04:14

Speaker A

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

04:30

Speaker A

как раз-таки ресурсы, то есть процессор другому, другой задаче, другому процессу. Вот опять же, кто не знает, что такое прерывание, вот это всё, я вот чуть позже буду об этом говорить. И более того, есть будет отдельно большой материал про

04:44

Speaker A

операционные системы. Там на 2 часа почти весь полноценный курс Осей будет умещён в одно небольшое видео. Ну как небольшое, ну как по сравнению с материалом обычный, который читаются про Оси, это довольно короткое будет видео.

04:57

Speaker A

Как раз-таки в это время появился Unix и ещё была такая штука IBM OS360. То есть тоже понятно, они появились плюс-минус одно время. И вот это был такой прорыв, что вот мы научились запускать на одной машине сразу много процессов. При этом

05:12

Speaker A

мы умеем их менеджить сами извне, то есть можем их прерывать и обеспечивать некоторую честность. Вот. Но есть небольшие проблемы. А давайте посмотрим вот такую штуку. Значит, был есть, точнее, был и есть такой закон. Он называется закон Мура. В чём этот закон?

05:28

Speaker A

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

05:44

Speaker A

утверждается, что каждые там 2 года у нас x2 количество транзисторов. Вот. То есть вот на таком графике, что видно, да? У нас снизу это как раз-таки время.

05:52

Speaker A

Вот. А, ну то есть ось X, а ось Y у нас, соответственно, количество транзисторов.

05:56

Speaker A

Вот, давайте с ходу, как бы, кто не знает, что такое транзистор, проговорю. Вот у нас есть в компьютере такие штуки, называются транзисторы. Они бывают разные, там всякие популярные. Ну, в общем, идейно опять же, у кого было ВМ, это вот NMOS

06:10

Speaker A

PМОС, вот эта история. У нас есть некоторая железка такая небольшая, которая умеет по специальному сигналу либо ток пропускать, либо не пропускать.

06:18

Speaker A

Ну, не ток, а сигнал скорее. Вот. И, соответственно, там оно запитывается от земли и от тока. И используя эти штуки, можно запрограммировать самые простейшие логические конструкции. Там условно из там дальше из Нанда, норы, энды, понятно, оры и вот это всё там ксор и

06:36

Speaker A

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

06:49

Speaker A

оно всё скелится дальше там на понятноче бита и так далее. То есть, в общем, это такое база АМ. Вот. Ну, утверждается, что чем больше у вас транзисторов, тем у вас в за один такт процессор может больше исполнять всяких, ээ, понятно

07:04

Speaker A

вещей, то есть различных вычислений. Вот. И закон Мура выбран про это, что как бы каждые там 2 года у нас x2, соответственно, традиров. Но если посмотреть, на самом деле он был примерно прав. То есть реально каждые 2 года его вот предсказание сбывалось. Там

07:19

Speaker A

последние, на самом деле, года это всё ещё работает, вот, но уже не так сильно.

07:24

Speaker A

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

07:38

Speaker A

оранжевая линия. Вот график - это количество транзисторов. То есть у нас с каждым годом количество транзисторов растёт. Более того, даже сейчас там количество транзисторов, оно тоже вырастает. Вот. Но об этом позже. То есть это опять же закон в целом Мура

07:51

Speaker A

выполняется. Но есть проблема. Смотрите, вот это график частоты одного ядра. То есть, ну, грубо говоря, это мощность одного ядра. И случилась некоторая проблема. Человечество вот в 2000000чных годах, вот ближе к 2010 упёрлось в то, что на халяву больше скелить одно ядро

08:10

Speaker A

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

08:25

Speaker A

как бы внимательные слушатели могли заметить, что есть ещё такая штука, как single performance, и она как бы растёт.

08:32

Speaker A

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

08:45

Speaker A

как бы борется со спички. Вот. То есть важно, что именно вот упёрлось в лимит история то, что нельзя больше накидывать ресурсов на одно ядро, то есть увеличивать количество транзисторов, потому что у нас буквально, соответственно, физически опять же есть

08:59

Speaker A

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

09:15

Speaker A

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

09:30

Speaker A

нас вот этот standby power - это сколько энергии тратится в покое. Вот там, давайте глобальное две проблемы есть.

09:37

Speaker A

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

09:51

Speaker A

вообще в целом начинает утекать, у нас количество батарейки, то есть энергии, которая расходует наше устройство в таком покое даже, да, вот standby Power - это количество энергии, которое мы расходуем в покое. Вот exive P вычислениях. И чем ближе у нас опять же

10:05

Speaker A

вот этот лимит в чём состоит, да, что если мы ближе будем располагать транзисторы, то у нас просто будет энергия утекать, ну, буквально из физического строения, вот, э, и будет нагреваться микросхема, у нас будет больше энергии уходить, что очень сильно

10:19

Speaker A

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

10:31

Speaker A

Вот. То есть, да, даже вот в id state называется это, когда вот ядро как бы ничего не делает в таком празном состоянии, даже тогда у нас утекает энергия, потому что просто вот у нас течёт наша железка на наши транзисторы

10:43

Speaker A

просто за счасть того, что они близко друг друга расположены, у нас утекает заряд. Вот. И какая случилась, ну вот решение, какое было принято, люди поняли, что о'кей, мы не можем больше накидывать ресурсов на один процессор.

10:56

Speaker A

То есть у нас проблема, что мы вертикально называется вертикальное масштабирование. Вот вертикальное масштабирование - это когда мы накидываем ресурсов на одну один какой-то компонент. То есть пытаемся ускориться за счёт того, что мы пытаемся накинуть ресурсов на один какой-то

11:08

Speaker A

компонент. Вот. И решили масштабировать горизонтально. Вот горизонтальное масштабирование - это когда вы накидываете не ресурсов не на один компонент, а делаете много компонентов.

11:17

Speaker A

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

11:31

Speaker A

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

11:45

Speaker A

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

11:56

Speaker A

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

12:08

Speaker A

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

12:23

Speaker A

одну ноду, то есть на вот один компьютер, и будем так жить. То есть это тоже вариант, но опять же это дороже, то есть вот гораздо дешевле поставить вот несколько компьютеров. Вот я пытаюсь как бы так простыми словами говорить про там

12:34

Speaker A

не употреблять всякие слова ноды, поды, вот это всё. То есть это как, чтобы все поняли. Вот. И то же самое здесь, да?

12:38

Speaker A

Зачем нам один процессор как-то пытаться улучшать? Ну то есть то, что у нас мы упёрлись в лимит. Давайте будем пытаться их скелить, масштабировать, то есть больше процессоров. Вот. И как раз-таки появляются мультипроцессоры, это когда у нас множество процессоров. И, ну, дальше

12:53

Speaker A

Multiore Systems, то есть многоядерные. То есть отличие многоядерных от многопроцессора в том, что у вас внутри процессора есть ядра. Вот. И понятно, то есть как бы как программистам нам не очень важно, там под капотом у нас два процессора или два ядра на самом деле.

13:05

Speaker A

То есть, ладно, это всё ещё важно для всяких нумаварит алгоритмов, но это тоже большая тема, типа тут не будем углубляться, как бы, как в плане многопоточного программирования, не очень важно, как бы, у нас два процессора или два ядра. Как бы нам всё

13:18

Speaker A

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

13:35

Speaker A

понятно, если у вас много ядер, у вас большая вероятность того, что что-то сломается, поэтому там во всяких ракетах и на самолётах делают упорну надёжность.

13:42

Speaker A

То есть там дублируют регистры, дублируют логику, чтобы просто было надёжнее, потому что понятно, катастрофа может случиться, если будет не такая маленькая вероятность какой-то ошибки.

13:51

Speaker A

То есть, как бы, если у вас сломается там ноутбук дома, то как бы, ну, всё равно, а, почти. Ну, понятно, будет неприятно, но как бы катастрофы не будет. А если там самолёт упадёт, то как бы будет грустно. Вот. А, и сейчас на

14:02

Speaker A

данный момент в мире примерно 300 ядер - это вот максимум. Понятно, есть всякие суперкомпьютеры компьютеры которые собирают в университете там исследователи. Ну, понятно, вот серийное производство сейчас вот примерно максимум 300 ядер. Там Intel там выпустили недавно что-то типа там 270,

14:18

Speaker A

что-то такое. Вот. И в чём у нас основная сложность? То есть вообще чего мы как программисты хотим и зачем нам это надо? Вообще всё, к сожалению, к сожалению из коробки просто накинуть, то есть из коробки я имею в виду, что

14:30

Speaker A

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

14:44

Speaker A

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

14:55

Speaker A

будем задумываться о том, что он запущен на двух ядрах, случится неприятная ситуация. То есть у нас будет неконсистентное состояние. Вот задача у нас, как программистов, написать такой код, чтобы он, во-первых, утилизировал ресурсы правильно и эффективно, чтобы мы там, ну, называется ещё эффективно

15:10

Speaker A

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

15:22

Speaker A

сложные задачи. Вот. И более того, даже там у вас у каждого в телефоне сейчас скорее всего архитектура, то есть uniform memory access. У вас на вашем телефоне есть много-много ядер. При этом некоторые из них э могут быть так

15:35

Speaker A

называемые performance или большие ядра big core. Некоторые могут быть маленькими, то есть efficient little course. Вот. То есть в телефонах, например, прямо очень сейчас идёт большой упор на то, чтобы правильно писать планировщик, да, который будет в нужных случаях использовать большие ядра

15:52

Speaker A

эффективные и в нужных случаях маленькие. Ну, например, у вас там есть какая-то игра, вы хотите её запустить на, понятно, перформанс ядре. А если у вас какое-нибудь приложение, там, музычка, то как бы можно запустить на маленьком ядре. И при этом маленькое

16:02

Speaker A

ядро употребляет батарейки меньше, чем большое. И получается, что как бы вот так можно и экономить батарейку. Это называется умными словами Energy Aware scheduling, то есть когда у вас ваш шедулер, ваш планировщик понимает, в каком случае можно какое ядро

16:15

Speaker A

использовать. Это не относится вот к ГО, это просто вот вам для общего развития, что как бы там всё гораздо сложнее и просто раскинуть даже на ядр - это тоже не очень тривальная задача. Вот. Более того, как мы как-то уже увидим, нам бы

16:26

Speaker A

хотелось бы, чтобы наш код крутился всё время на одном ядре, потому что иначе у нас будут проблемы с кошами. Это тоже как бы, то есть там очень много, в общем, неочевидностей, которые мы будем смотреть. Перед тем, как мы уже

16:36

Speaker A

приступим к вот го и как это всё работает, чуть-чуть совсем капельку приправы, связанные с теорией из операционных систем, потому что, опять же, я понимаю, что многие могут, например, чего-то не знать. Я постараюсь вкратце сейчас там 40 минут осей уложить

16:51

Speaker A

в один слайд. Вот у нас в оси есть абстракции. Абстракции - это у нас что?

16:56

Speaker A

Понятно, процессы и потоки. То есть у нас есть ти на физическом уровне у нас есть какие-то ядра либо, понятно, наши процессоры. То есть в каждом процессоре есть какое-то количество ядер. Вот. И наша операционная система хочет как-то, понятно, раскидывать по этим ядрам свои

17:10

Speaker A

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

17:22

Speaker A

выделен. Вот тут понятно, что есть есть э данные с кодом. То есть у вас есть секци есть сегмент данных, в которых лежит ваша бинарные инструкции вашей программы. Есть сегмент данных с вашими стическими данными. Дальше есть сегмент данных с динамическими данными всяки. То

17:37

Speaker A

есть понятно, когда вы выделяете слайс какой-то, данные именно здесь находятся. Есть сегмент данных со стеком. Вот сейчас я про это скажу. И вот сегмент данных дляспейса, где прихранивается разная информация. Эта картинка вот старенькая, когда ещё было адресное пространство 4 Гб. Так вот, какая идея?

17:52

Speaker A

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

18:07

Speaker A

программы, которая имеет доступ к адресному пространству. То есть поток может доступаться до вашей кучи. То есть как бы между потоками общая память у вас. То есть у вас есть в вашем, понятно, адресном пространстве какие-то данные. И потоки - это просто как

18:21

Speaker A

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

18:38

Speaker A

как раз-таки ядрам. Просто вот говоря так. Значит, э понятно, там всё очень очевидно. Например, там всякие completely fair скедлеры с красно-чёрными деревьями, как бы это тоже очень нетриальная задача, как это правильно сделать, чтобы ещё всё было честно. Вот это всё как бы тоже большой

18:53

Speaker A

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

19:06

Speaker A

Вот. Ну почему так? Потому что понятное дело, что если вы кусочек памяти выделили вот здесь вот для потока, то, ну, расширить вы его не сможете, потому что как бы тут дальше уже кусочки заняты. Вот. Либо как-то пытаться его

19:16

Speaker A

переносить куда-то, но что не очень очевидно. Вот поэтому вот по умолчанию в осях стек он неизменяем. Вот что опять же в го это не так. Мы тоже это будем смотреть, что допустим в го у так называемой горутины стек может

19:27

Speaker A

расширяться или сужаться. Вот соответственно итого немножко опять же теории. Вот сейчас за 40 40 минут осей я пытался уложить в один слайд, но идея такая, что у вас есть ваши ядра вычислительные, есть ваше приложение, которое может создавать потоки. Потоки -

19:43

Speaker A

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

19:56

Speaker A

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

20:12

Speaker A

текущий момент, на текущие занятия мы будем считать, что у нас гарутина - это поток оси. Просто потому, что за одну вот за один раз очень сложно всё это рассказать. То есть пока можно считать, что у нас вот в горутина называется- это

20:25

Speaker A

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

20:39

Speaker A

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

20:53

Speaker A

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

21:08

Speaker A

работал на нескольких ядрах? Смотрите, тут тоже как бы опять же, понимаете, сложно как бы заодно один раз уместить всё сразу, поэтому мы сейчас пойдём постепенно. Смотрите, есть два вида задач. CPU баound задачи и баound задачи. В чём различие? Смотрите, CP

21:21

Speaker A

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

21:35

Speaker A

многоточного программирования. Так вот, CPU Bound задачи - это задачи, которые требуют непосредственно вычислительных ресурсов вашего процессора. Вот вашего процессора, вашего ядра. Опять же, тут неважно, буду говорить ядра. Пример, какое-то шиширование, криптография, кодирование, декодирование. То есть это задачи, которые прямо посчитать, то есть

21:54

Speaker A

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

22:02

Speaker A

Ещё существуют так называемые IO bound задачи, например, чтение файлов, чтение сетевых сокетов, то есть, например, запрос к базе данных, да, обслуживание.

22:11

Speaker A

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

22:29

Speaker A

есть как бы у вас вы ограничены вашими ресурсами вычислительными, вашими ядрами. А в случае баound задачами там есть много разных интересностей.

22:36

Speaker A

Например, а что будет, если нам не блокироваться на сетевой вызов? Вот как здесь, да, смотрите, у вас а кто-то там ждёт кого-то, вот что будет, если не ждать, пока там нам ответят, а в это время сделать ещё какую-то полезную

22:48

Speaker A

работу. Вот. То есть как бы вот там очень большое количество всяких коверистик, чтобы опять же это вот с 2010 годов пошло вот вей, вот это всё.

22:57

Speaker A

То есть как бы как бы так нам сделать, чтобы максимальное количество сетевых каких-то, ну, то есть iбаound задач исполнять, да, при этом не блокироваться. То есть в этом случае у нас основной ресурс - это наш процессор, а в этом случае у нас основной ресурс -

23:10

Speaker A

это наши потоки, которые блокируются. Вот. То есть про IO bound будет отдельное большое тоже занятие. Я пока вот сегодня об этом не буду говорить.

23:18

Speaker A

Сегодня будем говорить про CPU баound задачи. То есть опять же CPU баound задачи - это задача, которая непосредственно про вычисление, там про сложение матриц, там работа с тензорами, криптография. Вот баount - это вот непосредственно того, что мы как бы

23:30

Speaker A

послали куда-то запрос и ждём чего-то. То есть, допустим, там послали запрос в базу данных, она нам пока отвечает, мы как бы ждём её ответа. Вот, чтобы не ждать и быстрее всё это делать, тоже есть множество разных как раз-таки

23:40

Speaker A

подходов. Ну и сегодня будем говорить про CPU bounce задачи, потому что на них проще всего объяснять базу многопоточного программирования. Вот. Но знаете просто, что даже с одним, я, ну, допустим, давайте, у вас есть две задачи, вот и одно ядро всего. Вот

23:53

Speaker A

утверждается, что CPU баound задача, например, ну, она как бы вот у вас одно ядро, вы особо сильно как бы ничего не сделаете. А вот баo задача, у вас даже одно ядро может обслуживать 10.000 соединений при правильном, понятно, подходе. То есть там, кто может знает,

24:08

Speaker A

это всякие истории с е-полами на Линуксе, там nonблокинг io, в джаве это называется selector. То есть это вот как раз-таки подходы, чтобы не блокировать ээ ваши потоки при Ioо нагрузке. То есть э направление начало развиваться в то время, когда у вас на появились системы,

24:27

Speaker A

которые держат огромное количество запросов. То есть вот тогда люди задались вопросом: "А как бы сделать так, чтобы не блокироваться, не ждать, пока нам ответят, а как-то быстрее всё это сделать?" Вот. Но ещё раз, мы сегодня обсуждаем именно CPU баun

24:37

Speaker A

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

24:58

Speaker A

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

25:10

Speaker A

трет, на котором горутина исполняется. Опять же просто вот для простоты пока что можно вот это опустить. Можно как бы Давайте пока это уберём вообще. Вот что здесь происходит. Смотрите, у меня есть какая-то переменная V. Я запускаю 1.000 грутин. То есть как бы можно пока

25:24

Speaker A

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

25:38

Speaker A

продвинутые примитивы, мы как бы вот так подождём, как бы. О'кей, нам не очень важно. Давайте вот у кого какие прогнозы, вот давайте в чат напишите, кто считает, что здесь будет выведено в конце просто ради интереса. Вот. Максим считает, что будет меньше 1.ся, да,

25:53

Speaker A

говорит умные слова data Race. Ну да, видимо, кто-то уже в курсе. Хорошо. Действительно, если мы этот код запустим, а у нас получится, значит, всё не очень радужно, а именно мы получим 965. Вот. Хотя, казалось бы, почему так?

26:07

Speaker A

Мы же сделали частный инкремент. Давайте разберёмся, почему так случилось. Сейчас будет так сказать за 30 минут, даже давайте даже за три слайда, скорее не 30 минут, я расскажу примерно там час-два.

26:19

Speaker A

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

26:33

Speaker A

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

26:48

Speaker A

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

27:03

Speaker A

инструкция декомпозируется на различные стадии, там instruction f, instruction decд execution wr back, перед этим ещё взаимодействие с памятью. То есть там, в общем, я отдельно скинул материалы, это тоже ВМ уже, но идея в том, что ядра могут читать и писать из своего кэша

27:19

Speaker A

локального. Вот. И в чём проблема? Операция V+ - это что такое на самом деле? Это прочитать V, сделать плюс и записать V. То есть эта операция на самом деле три операции, если смотреть.

27:33

Speaker A

То есть V+ - это сначала взять, прочитать значение, потом его увеличить на единичку и потом записать обратно. И вот как бы вопрос, да, почему у нас там получилось не 1.000? Потому что, во-первых, да, то есть я как сказал,

27:47

Speaker A

однозначного ответа нету, потому что нам дают модель всегда. То есть мы не знаем на самом деле, как там на уровне железа это устроено, но есть как минимум как бы причины, которые, ну, то есть, понимаете, на практике говорят, вот как

27:56

Speaker A

сказал Максим, датарейс, то есть на практике программисты не задумываются датарейс, всё, просто дали модель, сказали, доступаешься там к переменной с коммутирующими операциями без сихронизации, получаешь датарейс. Почему так? Опять же, обычно об этом не думают, либо какие-то себе абстракции

28:11

Speaker A

представляют, но на самом деле первая причина, которая могла быть - это банально вот, допустим, было два ядра, оба делали V+. Одно ядро могу прочитать из своего кэша, второе из своего кша, и они работали с разными версиями как раз-таки этой переменной. А потом

28:26

Speaker A

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

28:33

Speaker A

Оба сделали инкремент, получили шесть, записали шесть. То есть как бы казалось бы, два инкремента, на самом деле он был один, как бы, если смёржить его, да, то есть он превратился в один инкремент. А более того, в ядрах есть такой процесс,

28:45

Speaker A

опять же, вы интересно, можете прямо загуглить. Называется он execution. Что такое execution? Это когда вот в рамках микроконвейерной архитектуры ваше ядро может переставлять местами инструкции, чтобы банально быстрее работало. Ну, например, там мы знаем, что если чучуть переставить инструкции, то вот для

29:03

Speaker A

программиста ничего не поменяется, но при этом можно будет сделать парализм на уровне как раз-таки аппаратном, да, то есть исполнить чуть быстрее. Опять же, это вот отдельная тема про конвейер, про стадии. Вот я опять же скинул материалы тут в одном слайде, там большой

29:18

Speaker A

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

29:31

Speaker A

отдельный материал. У меня есть покрывает большую часть того, что нужно знать извма. Так вот, да и ядра локально как-то в своём кше взаимодействуют. При этом между собой они не общаются. То есть по умолчанию там одно ядро может читать из своего КШ что-то, второе ядро

29:47

Speaker A

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

29:58

Speaker A

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

30:11

Speaker A

такая неприятность. Вот что можно сделать. Можно сказать: "Ядра, начните разговаривать и договариваться между собой". Это реализовано на уровне так называемых протоколов когерентности Кэша. Смотрите, что такое когерентность КША. Значит, идея такая. У нас будет в Кыше некоторые пометочки. Эти пометочки

30:31

Speaker A

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

30:43

Speaker A

каком они находятся состоянии сейчас. Вот. И что получается теперь? Например, пример, да, у нас есть ядро один и у него есть меточка E exclusive. Это всё понятно. Эти все метки - это конкретно протокол какие дености. Например, есть протокол месси, там modified, exclusive,

30:58

Speaker A

shared, invalid. Есть всякие расширения месиов, там всякие форварды, овніды и так далее. Это вот тоже отдельная история с ВМ. Но важно, что эти меточки позволяют теперь ядрам договариваться. Как именно? Я ядро один и знаю, что у меня е, то есть я как

31:12

Speaker A

бы владею этими данными. Вот если ядро 2 попытается доступиться к этим данным, то оно увидит, что сейчас у меня меточка и инвалид. То есть кто-то другой сейчас данные, ну, условно поменял. Ну, у него есть валидная валидные данные. Поэтому

31:28

Speaker A

ядро 2 может что сделать? Оно может, ну, там, в каких-то протоколах зафортить, чтобы ядро один в память записало. В каких-то протоколах он может прямо через специальные сети, то есть там специально как бы внутри вот вашего компьютера ядры общаются между собой через как буквально

31:42

Speaker A

вот локальная сеть. То есть они могут друг дружке создать сигналы разные. Вот Ядро 2 может пойти и сказать: "Ядро 1, дай мне, пожалуйста, валидные данные, чтобы я как бы сделал операцию". Вот итого у нас эти ядра умеют договариваться между собой. Это всё

31:55

Speaker A

реализовано на уровне железа. Называется протокол когретности. Вот, как я сказал, самое известное - это вот Месси. Есть разные расширения. Она не очень важно, какие именно. Важно, что вот идея, что есть меточки и ядро умеют общаться на основе этих меток. Там, более того,

32:09

Speaker A

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

32:22

Speaker A

как-то сами по себе как-то что-то делают, да, и как бы ничего друг о друге не знают. Вот. А в этом случае они умеют договариваться и, соответственно, приходить к как раз-таки нужным им вариантам консистентности. Вот. Но как же заставить договариваться ядра между

32:37

Speaker A

собой? То есть у меня есть конкретная инструкция, как мы обсуждали, ассемлер у нас был с вами. Вот. И как бы, ну, мы делали какие-то инструкции, да, о'кей, как нам сказать, ядро, там, договорись, непонятно. Вот, на самом деле, это можно

32:49

Speaker A

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

33:04

Speaker A

инструкции, называются они многопоточные инструкции, для того, чтобы производить многопоточные операции. То есть мы смотрим, да, у нас есть инструкции, нам говорят, что это atomic AD onw all.

33:18

Speaker A

Ну, понятно, double Word у нас в арме - это 8 байт, Word - это 4 байта. Вот. И что нам говорят? Нам говорят, что вот у тебя есть сложение, которое может атомарно, ну, на самом деле, то есть гарантируется некоторый уровень

33:29

Speaker A

консистентности в на самом деле он задаётся через барьеры. Барьеры - это очень большая тема там про модели консистентности тоже. Мы об этом не будем говорить сейчас. То есть железка тоже может варьировать консистентность в зависимости от ваших целей. Это вот в

33:43

Speaker A

C++се, кто знает, Memory Order называется. Тоже мы это будем обсуждать. Называется это Memory Model. Тоже это большая тема. Мы сейчас об этом не думаем. Просто нам что важно? что конкретная железка даёт нам инструкции, говоря, что они делают, то есть вводят

33:58

Speaker A

для нас, как для программистов, некоторые слои абстракции и говорит: "А как бы мы под капотом договоримся, что всё будет о'кей, как бы ядра договорятся, всё будет хорошо". Просто как бы эта инструкция, она вот сделает то, что нужно вот с такими-то гарантиями

34:08

Speaker A

консистентности. То есть на самом деле атомиic имеется в виду, что у нас операция вот инкремента она, ну, на самом деле операция сложения она будет происходить атомарно, то есть у нас не будет вот чтения, инкремен записи, у нас будет всё

34:23

Speaker A

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

34:39

Speaker A

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

34:53

Speaker A

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

35:04

Speaker A

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

35:19

Speaker A

ассемблере такую функцию. Она будет делать атомарный вот. Ну, как она будет работать? она будет загружать адрес в R0, загружать дельту V1, потом вызывать вот один в один инструкцию, которую мы видели, только тут на конце ещё вот D, потому что го, понятно, в аслере

35:34

Speaker A

добавляет Double Word в конце, потом понятно, заиспользовали эту инструкцию, да, а получили результат, потом его добавили и вернули обратно. То есть, ну вот мы написали буквально свой многопоточный вот. Ну и теперь мы можем с чистой совестью его заиспользовать. То

35:49

Speaker A

есть опять же, давайте я всё вот это вот уберу. А, ну то есть понятно, пока можно думать про то, что это вот запускается.

35:55

Speaker A

Вот. Ну, пожалуйста, мы её что взяли? Мы взяли её объявили, как мы делали на Сенре. Вот. И её заиспользовали. То есть вместо обычной Wordп+са мы пишем теперь Scat. Вот. Давайте запустим, посмотрим, что будет. То есть мы прямо взяли

36:06

Speaker A

по-честному получили вот гарантию от нашей железки, что вот, да, всё будет хорошо, и её заиспользовали на гон.

36:12

Speaker A

Пожалуйста, 1.000, как мы ожидали, получилось всё корректно. То есть, ну, корректность опять же здесь задаётся нашими ожиданиями и гарантиями консистентности, потому что на самом деле консистенность бывает разная. Там в опять же в расплённых системах есть всякие консистентности, которые говорят

36:26

Speaker A

о том, что после какого-то периода времени, если вот не трогать систему, она придёт в констентное состояние. Вот там, ну, в общем, такие cуз consistcy и вот это всё. То есть там очень специфически какие есть модели. Вот. То есть важно, что консистентность тоже

36:39

Speaker A

задаётся некоторыми опять же ожиданиями и гарантиями. Вот. И, например, в многопоточном программировании будем использовать термин линеаризуемость. Но понятно, очно так не углубляясь, потому что всё-таки мы про говорим здесь, а не про теорию многопоточного программирования. Итого мы заиспользовали многопоточную инструкцию

36:57

Speaker A

и смогли написать корректный, с нашей точки зрения консистентности инкремент. Тут встаёт вопрос, как бы вопрос первый, давайте встаёт: а насколько это быстро?

37:07

Speaker A

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

37:21

Speaker A

пройти просто в одном потоке, заинкрементить и между тем, чтобы запустить 1.000 потоков и в них заинкрементить. Амиic in пока можно думать, что вот вотще думайте, что пока вот это вот это вот наш с вами SCAT. А вот разница между вот этим и вот этим,

37:35

Speaker A

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

37:49

Speaker A

ну, понятно, потому что ядр всё-таки договаривается не бесплатно. И понятное дело, что вот сейчас мы тоже это обсудим, но многопоточность стоит, к сожалению, не бесплатно. То есть там есть накладные расходы, поэтому не всегда распараллеливание даёт ээ как раз-таки вот такой то, что нам нужно. У

38:06

Speaker A

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

38:17

Speaker A

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

38:26

Speaker A

Вот всяких многоточих алгоритмов это решают всякими бэкофами, джитерами и так далее. То есть это тоже большая вот очень тема.

38:33

Speaker A

Вот. Ну пока просто важно понять такую вещь, в общем, мысль такую, что не всегда распараллеливание даёт ускорение.

38:39

Speaker A

То есть есть как бы это не серебряная пуля, надо понимать, когда это даёт какой-то прирост. В этом случае мы как бы, да, написали вроде бы корректно, но у нас по скорости это стало хуже, потому что понятно, наклоны на расходы на

38:51

Speaker A

создание потоков, накловные расходы на син синхронизацию, они выше, чем вот то, что мы хотели. Давайте обсудим, а почему нельзя сделать по умолчанию всё многопоточным? Почему нельзя просто сказать, что всё многопоточное? Я всегда использую многопоточные инструкции, всё хорошо, потому что, к сожалению, обычно,

39:08

Speaker A

то есть, смотрите, какой-нибудь атомарный инкремент и обычный инкремент, они на самом деле работают примерно, ну, то есть там не не очень большой оверхд будет. Проблемы начинаются, когда мы используем более дорогие инструкции многопоточные, а именно там используем блокировочки, которые, ну, в общем, они

39:22

Speaker A

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

39:37

Speaker A

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

39:50

Speaker A

Нет, не не зажили счастливо, потому что такие вот коллекции, они значит, понятно, в однопоточном режиме работали медленней на порядке. Вот. Понятно? То есть какие-нибудь атомарные инкременты всё ещё это не очень там дорого по сравнению с обычными инкрементами в

40:06

Speaker A

однопоточном режиме, но какие-то дорогие блокировки и более дорогие многопоточные инструкции, они будут бить существенно по производительности, даже в однопоточном режиме. Хорошо. Теперь такой вопрос. А неужели нам, как программистам, всё время надо думать о том, что у нас есть какие-то там

40:20

Speaker A

инструкции, что-то писать на ассемблере? Я лично не хочу каждый раз видеть ассемблер вообще вот в таких случаев.

40:25

Speaker A

Вот как бы нам от этого избавиться? Подумайте сами. У нас множество платформ разных. У нас разные инструкции. У нас разные количество байт, ну, в разных операциях там допустим 32 INC4 то есть в общем, очень такое пример странные многопоточные структуры данных

40:40

Speaker A

Synmap. В один из миллиона случаев он лучше, чем с мапой. Действительно, в сингмапе есть сценарии, когда она работает лучше. Ну, понятно, универсальный совет, который в кото нельзя проиграть, использовать этот совет - это бенчмаркет на своих данных, свои нагрузки, потому что всегда надо

40:59

Speaker A

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

41:10

Speaker A

того, мы сиingпам будем обсуждать и смотреть, как он написан. Но это чуть позже. Так вот, как повысить уровень абстракции? Смотрите, то есть мы, давайте, у нас была проблема изначально, что у нас уровень абстракции был вот такой. Нам наша железка сказала: "Не

41:20

Speaker A

парьтесь, вот тебе многоточная инструкция". Дальше у нас проблема следующая. Мы написали всё это на ассенре, но мы хотим больше. Мы не хотим постоянно думать про аснлер. Поэтому что мы сделаем? Мы введём ещё один слой абстракции и назовём всё это дело

41:31

Speaker A

атомиками. Что такое атомики? Атомики - это очень такая, на самом деле, банальная, но полезная вещь. Значит, давайте я покажу, как это работает.

41:39

Speaker A

Смотрите, что сделали. сказали: "Давайте мы возьмём и для каждой платформы напишем огромные астммерные файлы, в которых реализуем все полезные полезные, ну, базис некоторые многопоточных функций". Вот то же самое вот, допустим, для Arm сделаем, да? А то же самое

41:54

Speaker A

сделаем для там D64 такую же историю. Вот, то есть просто возьм, напишем для каждой платформы вот такую вот как раз-таки реализацию на СМИ. При этом важно, что мы от конечного программиста скроем всякие костыли. Ну, например, а если у нас нету вот такой прекрасной

42:09

Speaker A

инструкции, то есть у нас старый какой-то арм, вот у нас такой инструкции, если нету, то мы что сделаем? Мы через макросы будем просто в активном ожидании крутиться и пытаться сделать товарный инкремент. То есть мы накидываем ещё один слой абстракции, в

42:25

Speaker A

котором вскрываем всякие костыли. Ну, например, вот здесь, да, если у нас такая инструкция есть, то вот мы будем использовать, да, иначе мы будем что делать? Мы будем использовать лодлики, так называемые, и store conditional. То есть это когда там, в общем, большая

42:38

Speaker A

тема, но идея в том, что мы будем в активном ожидании, в цикле крутиться и пытаться там там, а вот сейчас получилось сделать инкремент, никто нам не помешал. Если помешали, тогда идём снова. И вот как бы просто в активном

42:49

Speaker A

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

43:03

Speaker A

красивым словом, пакетом атомик. Вот понятно, как нам с вами, ну, то есть понятное дело, что под каждую платформу мы будем иметь некоторые флажочки того, вот как здесь, правда ли, что эта платформа имеет многопоточные инструкции. Вот. Понятно. Если нет,

43:18

Speaker A

тогда там в крайнем случае, то есть если нету базиса, который нам нужен, мы можем некоторые функции реализовать руками там через какие-то костыли. То есть как бы для конечного программиста мы всё скрываем. Вот для конечного программиста у нас что есть? У нас есть, значит, low

43:32

Speaker A

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

43:46

Speaker A

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

43:58

Speaker A

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

44:15

Speaker A

всего они называются как-нибудь атомик что-то там. Вот. О'кей. Ну давайте немножко посмотрим, ка какой апии у этих пакетов. Ну, например, там банально вот, на самом деле, по жизни тоже встречал такой код. В есть какое-то приложение, у этого приложения есть конфиг. Понятно,

44:29

Speaker A

конфиг - это динамическая вещь. То есть не хочется редиплоить приложение, хочется как-то в конфиге какие-то параметры прописывать. Вот как происходит. Нам нужно взять и атомарно поменять один конфиг на другой. Вот. Ну как мы это делаем? Понятно. Мы берём

44:42

Speaker A

изначально делаем, то есть у нас есть некоторые atomic value. Atomic value - это под капотом просто any. Спасибо большое. Типизации как бы нету. Вот, ну, мы посмотрим чуть позже более продвинутую историю. Вот опять же токлею можно обернуть, как мы смотрели с вами

44:55

Speaker A

в, понятно, я рассказывал, можно обернуть всё это в generic обёртки и получить, ну, вот generic реализацию.

45:01

Speaker A

Это тоже есть предыдущее вот занятие проженерики. Вот. Ну и пример, да, у нас есть одна грутина, которая берёт и периодически загружает config. Вот. Ну и, соответственно, понятно, lo config - это вот какая-то функция, которая его загружает. Вот. И дальше что мы делаем?

45:15

Speaker A

Вот, ну, мы берём там, допустим, берё обрабатываем какие-нибудь запросы. Что такое чан? Пока тоже неважно, заметьте.

45:22

Speaker A

Вот. И берём, загружаем, когда нам нужно, загрузили config, его положили в переменную через store. Опять же, работа идёт сцене здесь. Вот. И, значит, э дальше мы взяли и вот когда мы его загрузили в другой уже, то есть в основном потоке вот не main, мы

45:43

Speaker A

обрабатываем запросы и как-нибудь загружаем этот конфиг, когда нам нужно. Вот опять же через кас, потому что вот нет типизации. То есть, ну, такой пример, опять же, есть тоже пример. Мы пишем какой-нибудь свой счётчик многопоточный. У нас есть set тоже, то

45:55

Speaker A

есть, пожалуйста, амик. Вот. И тут есть функция store 32. То есть там на самом деле для разных типов есть разные функции. То есть 32, intr. Вот там на самом деле ещё есть для А, да, ладно, видимо, это, да, это старая старый

46:09

Speaker A

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

46:24

Speaker A

многопоточные инструкции. Вот, например, мы делаем стор, например, делаем лот. То есть это то же самое, что наш с вами был от SC, только вот мы используем какое-то готовое решение коробочное. Значит, а как можно было бы переписать наш код?

46:36

Speaker A

Ну, понятно, мы используем Atomic N32, то есть берём, добавляем. Понятно, по какому-то адресу нашу даль. То есть при желании мы могли бы с вами написать код, который мы с вами писали. На самом деле, если быть совсем уж честным, то это не

46:54

Speaker A

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

47:08

Speaker A

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

47:12

Speaker A

То есть это не очень честно на самом деле. Вот по-честному было бы сделать вот так. Мы берём, как здесь, добавляем, а потом её вычитываем тоже многопоточно, потому что опять же есть некоторые некоторых платформах гарантикой системности, где вот такое простое

47:25

Speaker A

чтение нам выдаст всё ещё не тот результат. Ну, банально, потому что это ядро может там почитать из КША, например. Вот. Ну, на самом деле, по-простому, просто пакет, который абстрагирует то, что мы сделали руками сейчас. Вот. Понятно. Есть для

47:38

Speaker A

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

47:50

Speaker A

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

48:06

Speaker A

Тамарна. Вот как это работало. Ну, как бы понятно. Мы берём откуда-то, получаем новый конфиг. У нас есть ПТР на старый конфиг. Что такое Pointer? Пока тоже обсуждали. Можно думать, что это просто указатель какой-нибудь такой небезопасный. И мы через Atomic Pointer

48:21

Speaker A

берём и меняем местами атомарны два указателя. То есть, ну, такой вот атомарный своб. Более того, понятно, можно свопать и, допустим, числа какие-то. То есть, ну, просто вот свопать два числа. Вот, ну, понятно, если у вас какая-то структура, то обычно

48:34

Speaker A

вам надо свопать всё-таки указатель. Очень редко вы хотите свобо именно два числа, хочется своботь какие-то вот именно вещи, связанные с, ну, вот какими-то реальными веща жизненными ситуациями, а именно структурами. Вот. И операция, которая на самом деле лежит в

48:49

Speaker A

основе вообще всего многопоточного программирования, абсолютно всего, называется она компонен. Смотрите, чуть теории накину. У этой операции консенсусное число равно бесконечности.

48:59

Speaker A

Что такое консенсус? Смотрите, это тоже неочевидный вопрос. Консенсус бывают разные. Вот в многопоточном программировании консенсус - это такие три свойства. А что если наши потоки, то есть есть какая-то функция, какая-то функция, функция, допустим, а get, вот каждый поток, а предлагает какое-то

49:17

Speaker A

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

49:33

Speaker A

функции, если вызвать в n потоках, нам должно вернуться одно и то же значение. Вот valлидити - это про то, что здесь должно быть валидное значение. То есть нельзя написать просто а вот так, потому что понятное дело, что мы возвращаем

49:45

Speaker A

какое-то значение, но оно бредовое, типа, да, оно всё ещё одинаковое для всех. Мы как бы соблюдаем первый пункт, но у нас оно невалидное, ну, как бы из воздуха. Обычно в многоточном програмровании называют эти выражения там outin air, в общем, из воздуха, но

49:57

Speaker A

как бы можно думать, что оно должен быть валидным, то есть формально это значение должно находиться во множете предлагаемых значений. Вот термиation - это про то, что этот консенсуал должен отрабатывать за конечное число шагов. И, например, вот тут пример есть снизу, да?

50:12

Speaker A

Вот это у нас будет не агримент, то есть не будет выполняться первое свойство. Почему? Потому что у нас для разных потоков вернётся разные значения, и поэтому у нас первое свойство не выполняется. Вот это второе будет невалидной, потому что ему вернули

50:22

Speaker A

какую-то, ну, непонятную штуку. Вот третье свойство, но оно связано вот с теми, кто знает, что такое. Вот если даже вы каким-то образом возьмёте блокировочку на активном ожидании, то это будет пройф я не говорил ещё, прокф тоже, но в общем, это будет незаконечное

50:37

Speaker A

число шагов выполняться. Почему так? Тоже, ну, если говорить простым языком, то потому что никто вам не гарантирует, что ваш поток не будет обделён и ему не дадут ресурсов. его могут там обделить во время того, как он взял блокировку.

50:50

Speaker A

Вот, допустим, да, у меня есть, давайте, у меня вот здесь было, допустим, 100 потоков. Один из них взял блокировочку вот здесь и уснул. Его там всё, его решили, что называется, обделить, и все остальные 99 его ждут. Вот утверждается,

51:02

Speaker A

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

51:15

Speaker A

немножко вообще другое, типа там это про то, что у нас, ну, evвен будет корректное значение, вот, что оно будет тоже валидное, вот, и что, э, ну, то есть тоже есть некоторая корректность.

51:24

Speaker A

То есть идея в том, что как бы консенсус именно в многопоточном программировании определяется именно вот так. Если вы слышали где-то о другом консенсусе, это нормально. То есть есть разные определения для разных областей. Вот. И вот утверждается, что Parent SW - это

51:36

Speaker A

такой примитив, который способен привести к консенсусу бесконечное число потоков. И поэтому он очень очень мощный, очень сильный. На нём написано очень много разных логфри, то есть быстрых алгоритмов многоточных. Как он работает? Смотрите, он работает следующим образом. Вы передаёте ему

51:52

Speaker A

старое значение и новое значение, и он атомарно меняет старое на новое. 1236. Если старое было таким, то есть если старое всё ещё осталось такое, то он его поменяет, иначе поменять. Вот. То есть, например, вот здесь будет флоs почему?

52:07

Speaker A

Потому что у меня старое значение было, очевидно, не такое. Здесь будет true. Почему? Потому что у меня старое значение вот такое вот. 789. Вот оно. Я поменял его на новое значение. Будет true и успешное значение. То есть это

52:18

Speaker A

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

52:34

Speaker A

тоже важно понимать, что это всё примерно об одном и том же. То есть нужен некоторый базис, который позволяет привести к консенсусу много потоков. Вот этот базис является кпренспом. Например, операция вот такая. А она позволяет привести к консенсу всего два потока.

52:50

Speaker A

Вот такая вот. Ну понятно, как это сделать. Можно завести тупо массивчик на два элемента типа и вот сделать. Вот.

52:57

Speaker A

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

53:09

Speaker A

Смотри ещё раз. Вот лог мы пока не обсуждали, но это некоторая возможность взять потоку блокировку и сказать, что только я сейчас буду вот, то есть только один поток за раз может взять такую блокировку. И что может быть? Может быть

53:23

Speaker A

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

53:37

Speaker A

случае. Вот это называется ещёными словами W3. Как раз-таки гарантия, что мы как бы у нас нет гарантии, что у нас поток, то есть в гарантия, что у нас поток выполнит будет прогресс за конечное число шагов. А здесь как бы,

53:49

Speaker A

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

54:02

Speaker A

есть ни в коем случае консенсус. Вот понятно. Его можно написать на кассе через консенсус можно на кассе написать.

54:09

Speaker A

Это вот такой базовый примиссив. А знаете просто, что он довольно мощный. Как бы подробнее об этом как бы понятно.

54:14

Speaker A

Это большое вот поле проектирования фри алгоритмов, пока туда не будем залазить, но просто знаете, что вот такая операция есть. Она кажется бесполезной, но она очень, на самом деле, даёт большую базу для всего вообще многоточного программирования. О'кей. В GoОO 1.19

54:30

Speaker A

добавили всякие модные штуки. Они именно добавили буквально типы, которые под капотом, ну, вот, допустим, Atomic Bull, у него есть, понятно, р, который под капотом, буквально то же самое, что store. Понятно? То есть просто чисел, то есть как бы решили добавить немножко

54:44

Speaker A

сахара ещё сверху сделать вот такие вот обёрточки. То есть понятно, можно там atтоomic pool завести себе и им пользоваться, можно завести себе atomic in4. И вот то есть всякие для разных типов сделали обёрточки просто, ну просто чтобы не нужно было постоянно

54:56

Speaker A

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

55:03

Speaker A

И вот это всё сделали такие обёртки. Бул равно UN 32. Ну вот, ну если посмотреть, как он устроен, то там, да, под капотом есть НТ. Ну, потому что на самом деле, если углубляться в то, как это работает на уровне железа, то в процессора вообще

55:17

Speaker A

нет понятия, что такое бул. То есть процессор оперирует всегда понятием числа. Нет понятия булина вообще. Есть понятие битиков вот в разных регистров лагов, но это это не булин. Ну не ладно, это були, но как бы ладно, давайте. Есть

55:33

Speaker A

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

55:48

Speaker A

да? Ну потому что если бы это было бы не так, то приходилось бы во всех методах конвертить бул в ин. Это как бы, ну буквально примерно то же самое. Ну как бы тут особо нет разницы. То есть мы как

55:59

Speaker A

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

56:10

Speaker A

inпйс число и с ним работать. Не очень приятно. То есть как бы в процессоре нету инструкции для работы с булами.

56:16

Speaker A

Обычно я не гарантирую, что нет такого процессора, но обычно так. Вот. То же самое для интов. Дальше есть модная штука, она называется Tomic value. То есть это на самом деле под капотом всё ещё. А вот при желании можно написать

56:30

Speaker A

обёртку, как я рассказывал. То есть пишемк обёрточку себе спокойно и живём. Вот. Ну, опять же, есть более приятная вещь, называется она Atomic Pointer. Ну, понятно, Atomic Value тут тоже то же самое, что мы видели. То есть у этой

56:42

Speaker A

штуки просто вот есть методы. То есть понятно, своп под капотом - это вот буквально вызов, ну, ладно, с некоторыми костылями свопоинтера, дальше атомиic, понятно, понятно, но есть вот как воп тоже вот появился, кстати, в Go17 его добавили отдельно. Вот эту добавили

57:00

Speaker A

отдельно и Swap добавили отдельно. Вот такие штуки. Так, ну по факту это то же самое, что мы увидели. Просто там отдельный тип с такими методами, ничего больше, просто как сахар для гошников, чтобы не нужно было писать постоянно вот

57:10

Speaker A

так, потому что всем страшно от такого. Это бывает так в жизни. Вот. И получается понятно value с буквальными методами в виде как раз-таки вот того, что мы рассмотрели. Вот. Ну понятно по умолчанию нужно вот так кастить. А значит, ну понятно. Пример с конфигом я

57:26

Speaker A

уже озвучивал, то есть прямо по жизни видел код, где есть амиicy, вот как условно внутри лежит конфиг какой-то в приложении вашем, да, там какой-то Typeepe KFG. И когда приходит новая версия кофига из какой-то админки, её подгружают в приложение, используя

57:41

Speaker A

атомарный своп. О'кей, хорошо. Давайте видим ещё такую штуку. А, смотрите, наконец-то нам дали что-то типизированное. Есть аomic storeinter, он позволяет, э, ну, понятно, есть разные операции с поинтерами. Короче, в пакете атомиic вы видели, есть возможность сделать store pointer, load

58:00

Speaker A

pointer, compent swap pointer, а, то есть с поинтерами есть разные операции. Вот как раз-таки в Goлиную вот такую обёрточку типизированную, наконец-то. То есть эта обёрточка, она параметризована типом Т, и она хранит под капотом указатель на типт, то есть

58:16

Speaker A

звёздочку Т. Вот. И можно более удобно этим пользоваться, то есть писать спокойненько себе операции. Допустим, вот этот Pointer Store, value 1, value 2, где всё у нас типизировано, всё хорошо, нет никаких и никаких кастов.

58:27

Speaker A

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

58:42

Speaker A

там атомарно сделать своп вот структуры или там атомарно сделать какой-то коent swop. Второй случай - это проектирование fre алгоритмов. И третий случай - это когда просто есть какое-то место в коде типа там видавайте сделаем какую-то операцию там, допустим,

58:57

Speaker A

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

59:12

Speaker A

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

59:26

Speaker A

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

59:39

Speaker A

железа договариваться с различными протоколами как ревности. И в целом там, ну, не только это, на самом деле, там под капотом ещё и понятна вот эта история с out of order execution, да? То есть она про то, что у нас инструкции в

59:52

Speaker A

разном порядке могут, ну, исполняться. И, например, когда мы используем вот такие вот многоточные инструкции, то там, ну, вот идёт запрет на это, потому что, понятно, мы можем получить какой-то не ожидаемый результат, который противоречит консентности, которую нам дали. Вот поэтому тоже это отдельно

60:07

Speaker A

большая тема. Пока тут сложно просто за один раз всё рассказать. Мы идём так снизу вверх идём последовательно в этом плане. О'кей, давайте попробуем написать какое-нибудь ускорение. Возьмём что-нибудь ускорим. Давайте попробуем это сделать. То есть напишем какой-нибудь CPU boу распараллеливание.

60:24

Speaker A

А давайте у нас будут матрички. Матрички будут такие. У нас будет количество строк сов хранить одномерные матрицы. На самом деле так часто делают. Например, когда хранят тензоры, их обычно хранят именно в одном массиве, то есть не в двумерном, не трёхмерном, потому что это

60:39

Speaker A

для кэша чуть приятнее. Вот. Ну как у нас будет работать наш sequенal сложение матриц? Будем матрицы складывать, потому что умножать это сложно. Вот хочется что-то простое. Ну не сложное, но просто, короче, сложение более простой пример. Почему написано вот так? Пока не

60:54

Speaker A

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

61:05

Speaker A

Мы тоже будем это обсуждать, пока можно на это забить. Ну, вкратце компилятор вставляет проверки того, что правда ли, что это валидное обращение. И вот, чтобы такое те проверки убрать, может заранее обратиться к последнему элементу, и тогда компилятор поймёт, что ага, уже

61:20

Speaker A

эти элементы до этого элемента валидные, и тогда здесь можно проверки не вставлять. Ну, и просто складываем две матрички. Как работает параллельное сложение двух матриц? Вот. Ну, понятно, мы возьмём, получим количество, ну, мы будем там тоже понятно, можно параллелить именно не по строчкам, а

61:36

Speaker A

параллелить по кускам, потому что у нас всё лежит в одном массиве. Ну, давайте забьём, а будем параллелить по строчкам.

61:42

Speaker A

Вот у нас будет количество строчек на одного воркера. Ну и дальше что будем делать? Это пока не берём во внимание, пока вот это забьём. Мы бежим циклом, вычисляем промежутки для каждого воркера. То есть там, допустим, у нас понятно начало, начало какой строки

61:56

Speaker A

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

62:12

Speaker A

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

62:29

Speaker A

типа вот у нас например вот это для первого воркера, там это для второго, там это для третьего. И, допустим, у нас для крайнего воркера получилось вот столько задачек. Вот формально будет вот так, вот так - один. Вот. То есть

62:42

Speaker A

по-хорошему, конечно, раскидать вот эти задачки на всех воркеров, чтобы у нас выполнялось такое свойство, что у нас между ними различия не по модули не больше, чем на единичку, но мы тоже это бьём, чтобы код не усложнять. Вот просто

62:53

Speaker A

как бы потому что иначе это мы будем не туда смотреть. Нам это не нужно сейчас.

62:57

Speaker A

Вот. И мы что делаем? Мы запускаем дальше наши потоки. Вот я использую вот через специальную обёртку, чтобы потом дожидаться их. Пока мы не знаем, что это за обёртка, но вот под капотом это просто штука, которая позволяет запустить наши потоки грутины, то есть и

63:10

Speaker A

потом им дождаться их. Опять же, я повторюсь, мы пока думаем, что поток это рутина пока мы не различаем. Мы на таком уровне абстракции живём. Вот. И в каждой грутине что делаем? Берём стартend, вычисляем. Вот. И берём потом, соответственно буквально понятно

63:24

Speaker A

достаём наши промежуточки и делаем сложение. Понятно? Здесь при желании можно было по ещё раз гравлярность сделать поменьше на уровне интервалов один срок. То есть тут так тоже норм.

63:35

Speaker A

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

63:50

Speaker A

запустим тест, который проверит, что они дают одинаковое значение. Ну, правда, да, они не эквивалентны всей реализации.

63:55

Speaker A

Хорошо, теперь давайте понятно. Здесь какой бенчмарк, он создаёт просто две матрички. У нас столько-то строк и столько столбцов. Смотрите, сейчас тоже небольшой момент. Если я сейчас запущу такой бенчмарк, то давайте сперва, то есть давайте просто я хочу объяснить,

64:10

Speaker A

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

64:22

Speaker A

Более того, как бы почему так? Потому что компилятор умеет в разные оптимизации. Поэтому я буду специально запускать код без оптимизации. Вот так вот, чтобы мы именно смотрели на ускорение, которое мы получаем от нашего распаралливания, а не от того, как

64:34

Speaker A

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

64:50

Speaker A

совет. Будет ещё понятно отдельные рассказ про тестирование бечмаркифазиing, но это потом. Так вот, запускаем бачмарки. Смотрите, что мы видим. У нас есть бенчмарк первый, который буквально делает наш вызывает однопоточную реализацию и бенчмарк, который вызывает нашу многопоточную реализацию. При этом важно, что вызывает

65:09

Speaker A

сперва с одним потоком, с двумя потоками, с четырьмя потоками, с восьмью потоками, потом с количеством потоков, равное количество наших ядер. Вот логические ядра, физические ядра тоже я сейчас не буду вот тут углубляться, просто с количеством ядер. Дальше X3 -

65:22

Speaker A

от количества ядер и X10 - от количества ядер. Вот. Итого мы запуск просто пытаемся посмотреть на то, как как быстро мы сможем получить нужные нам результаты при таком количестве потоков. Вот, давайте на это дело всё посмотрим. Запустим чchмарк.

65:39

Speaker A

Ну, смотрите, как бы в целом в целом видно, что наша однопоточная реализация, вот эта вот, которая наша, подниму немножко. Наша однопоточная реализация, которую мы написали, она работает чуть-чуть быстрее, чем многопоточная реализация на одном потоке. То есть вот это V1, это один workкеer. Ну, понятно,

65:59

Speaker A

почему так. Потому что мы тут не используем никакую дорогую синхронизацию. На самом деле, да, есть оверхad на запуск гурутин. У нас не так их много, то есть всего там, понятно, одна. То есть, ну, тут как бы есть оверхad. То есть здесь давайте так.

66:11

Speaker A

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

66:30

Speaker A

как бы приятно, хорошо. В случае четырёх потоков у нас тоже чуть подросло, смотрите, уже, да, то есть уже разница в три раза изначально. Вот в случае восьми потоков уже как-то, ну, прирост есть, но не такой большой. Почему-то в случае с

66:43

Speaker A

двенадцати у нас стало даже хуже. Как так? Ну, и дальше в случае повышения у нас особо даже, то есть, ну, особо ничего не происходит. То есть мы как бы остановились на такой планке. Вот. И это, на самом деле, тоже большое

66:55

Speaker A

искусство. А какое количество потока выбрать для нашего алгоритма? Это тоже обычно бечмаркуют, строят графики, чтобы подобрать такое значение. Но тут сразу много вопросов на самом деле возникает, почему так сильно растут локация? А потому что мы вот здесь вот создаём

67:10

Speaker A

1.200 горутин, а это не бесплатно. Ну 1.200 потоков мы пока так вот думаем. Это вот. Но формально давайте, что мы посмотрим. Давайте вот я ещё раз на всякий случай запущу через кнопочку.

67:19

Speaker A

Формально, что мы сделали? Мы увидели следующее, что, значит, у нас при увеличении количества потоков мы стали работать быстрее. При этом почему-то на каком-то промежутке вот потоков мы упёрлись в какой-то лимит, а потом всё стало ещё немножко даже хуже. Вот сразу

67:35

Speaker A

сходу неочевидны какие-то вопросы. Вот, да, вот здесь на самом деле более вот пример показательный. Давайте его посмотрим, да, что у нас на вот, да, здесь получше стало, да, видимо, из-за того, что рутина - это не совсем потоки.

67:46

Speaker A

Вот тут бывает такая история. Смотрите, значит, у нас на двух стало всё там в два раза лучше, на четырёх там ещё получше, на восьми чуть ещё лучше, на двенадцати мы как бы уже начали откатываться, на тридцатишести мы ещё

67:58

Speaker A

хуже стали, потом вот в этом случае здесь скорее всего какой-нибуд какой- это выброс скорее, чем реальность. Вот на 1.200 мы стали вообще там работать ээ на уровне четырёх даже хуже. То есть с увеличением количества потоков мы в каком-то месте получили максимум, а

68:14

Speaker A

потом начали скатываться. Давайте ответим на несколько вопросов. Вопрос первый: почему с увеличением количества потоков у меня не стало работать всё быстрее? Что за бред? Я же, ну, у меня же всё хорошо было. То есть вообще, давайте так. Вопрос такой: почему у меня

68:28

Speaker A

один поток и, допустим, 12 потоков между ними разница, ну, типа три-четыре раза, а не там 10 раз? Непонятно. Давайте ответим на этот вопрос. Кстати, забыл сказать, исходники кода из этого видео и другие закрытые, полезные материалы ты сможешь найти в моём Telegram-канале.

68:45

Speaker A

Подписывайся и становись частью нашей большой и дружной семьи. Обсудим. А что так мало? Почему так мало? Типа, ну, тут я делал скриншот, когда мерил сам, а тут получилось примерно в четыре раза разница между одним и детью потока. Как

68:59

Speaker A

так вышло? Непонятно. Вот на самом деле, на самом деле, давайте распишем немножко формулу. Это называется законом Дала.

69:06

Speaker A

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

69:19

Speaker A

то есть условно мы знаем, сколько наш код работает на одном ядре, мы знаем, сколько наш код работает на nдрах. Можем посчитать ускорение. Логично. Но теперь давайте распишем чуть подробнее. Пусть единичка - это время исполнения нашего кода на одном ядре. Вот сверху вчителите

69:34

Speaker A

у нас единичка будет. А-а, значит, N же число потоков, а P пускай будет доля параллельного кода. Вот P - это доля кода, которую мы смогли распараллелить между нашими как раз-таки ядрами. Тогда что получается? Вот наша вот эта формула

69:47

Speaker A

переходит в такую штуку. Это 1 - p - это последовательная часть нашего кода. Ну, потому что p - это параллельная, значит, 1 - p - это, понятно, последовательная часть. И тогда реально параллельная часть - это доля параллельного кода,

70:02

Speaker A

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

70:17

Speaker A

примерно, какое мы получим ускорение при каком количестве ядер. На самом деле есть такая табличка. Смотрите, справа показано количество ядер, а здесь показано слева процент, важно последовательного кода, не параллельного, последовательного. Вот тут просто формула. Мы мы изначально взяли за пэшку долю параллельного.

70:37

Speaker A

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

70:51

Speaker A

же сверху у нас количество ядер, а снизу доля последовательного кода. И что у нас получается? Смотрите, если у нас есть 10% последовательного кода, то есть мы распределили 90% нашего кода, это очень много, если что, то мы получаем при

71:06

Speaker A

десяти ядрах ускорение всего в пять раз. И это как раз-таки примерно мачится с тем, что у нас получилось вот здесь на самом деле. То есть мы там как раз-таки у нас была примерно вот такая часть нашего после кода. Вот. То есть, что ещё

71:20

Speaker A

более ужасающие кадры, смотрите, при 40% посредоли больше половины, это много. Разница между там 1.000 и 100 ядрами, она, ну, почти что мизерная. Разница между 10 и 100 ядрами тоже она очень мизерная. Вот.

71:37

Speaker A

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

71:54

Speaker A

написать, допустим, там с квадрата до линии и будет лучше, чем городить многопоточность, потому что это, как мы видим, довольно сложно. Вот. Более того, опять же, понятное дело, что можно использовать если допустим какая-то криптография, то можно использовать прямо встроенные инструкции,

72:09

Speaker A

симструкции, которые мы обсуждали, да? То есть вот то, что я рассказывал на сенделе, что вот есть симнструкции, такие же инструкции есть для криптографии, например, да, чтобы не писать свою многопоточность, а использовать аппаратную как раз-таки поддержку. Вот. И то же самое можно было

72:20

Speaker A

бы сделать, допустим, с сложением матриц. Могли бы использовать бы син инструкции и тоже получить бы значительный прирост. То есть вот в этом плане иногда и то, и то как бы это многопоточность, то есть параллельность.

72:32

Speaker A

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

72:45

Speaker A

самом деле. Если мы посмотрим, то как бы если что 40% кода вот последного- это довольно много. Ну, в том плане, что если мы отнимем от 140, получится 60% кода мы распараллели. Это много. То есть как бы поэтому вот когда вы пытаетесь

73:00

Speaker A

распалелить какой-нибудь несчастный цикл, подумайте 20 раз, надо ли вам оно. Вот примерно в плане CPу задач такая история. Для баound задач будет совсем по-другому. Вот баoundс задачи есть смысл параллелить даже самые мелкие какие-то запросы. Вот мы это увидим, там

73:14

Speaker A

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

73:30

Speaker A

эффективно это распроливать. То есть такая CP баo задача. Ну и понятно, прикладные задачи, допустим, там DNS-сервера есть, друзья есть, которые работают в этой сфере. Там нужно вот уметь в криптографию на уровне железки, то есть использовать специальные инструкции, чтобы вот там, допустим, из

73:45

Speaker A

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

73:58

Speaker A

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

74:14

Speaker A

арифметические инструкции, то есть для пакета MS тоже реализованы в железе довольно эффективно. Понятно? Для некоторых платформ. Вот. И тут есть как бы проблема. Смотрите, мы сегодня прошли как бы такой путь снизу вверх. То есть мы начали от машинных инструкций, начали

74:29

Speaker A

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

74:43

Speaker A

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

74:57

Speaker A

момент, что как бы они прольются. Вот, допустим, такой примерчик тоже тут пытаюсь уложить, как бы лекции по Евму в один слайд.

75:06

Speaker A

Смотрите, у нас есть кэш. В Кэше есть различная структура. Там есть там условно уровни L1, L2, L3. Там есть разные политики замещения КШ, разные политики разложения. В КШ там есть тоже разная стативность, как мы доступаемся к Кэшу, там прямая, полная, групповая, то

75:22

Speaker A

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

75:36

Speaker A

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

75:50

Speaker A

по одному байтику, а он читает сразу кусок. Вот этот кусок обычно называется кэшлий. Обычно кэшления - это 64 байта.

75:55

Speaker A

Вот у меня, допустим, сейчас мы я покажу, это 128 байт. То есть память считается кусками. И в кШ.

76:03

Speaker A

То есть, когда мы хотим получить, проверить, есть ли какие-то данные в кше, мы берём адрес нашей памяти, и там по адресу можно вычислить условно бакет в кше и там резовывать коллизии через тегирование битов. Понятно, в самом адресе. То есть у нас есть какие

76:18

Speaker A

какие-то байтики, и мы берём, ну, условно адрес это 64 бита. Там у нас часть битов отвечает за то, какой это бакет в кШ. Часть битов отвечает за то, какая расположение внутри бакета в кше.

76:28

Speaker A

Часть битов отвечает за то, как разрешать коллизии, то есть как проверить, что у нас не случилось коллизии. Это реально данные, которые есть в КШЕ. Вот. И что нам здесь важно?

76:37

Speaker A

Важно, что у нас есть, если два ядра, то если одно ядро с читает, допустим, вот этот адрес, а второе ядро считает вот этот адрес, то им внезапно нужно договариваться, потому что они пересекаются. Вот. То есть это ядро прочитала вот этот вот этот адрес и

76:51

Speaker A

захватило вот кусочек. Это начало читать вот эту память. Пер вот этот нулевом ядру вообще не нужна была эта память. То есть она просто как почитала наперёд, но при этом им нужно договариваться. Вот это называется традиционно false sharриing. Ещё да в разных ситуациях это

77:05

Speaker A

называется casш conttion. То есть там когда у нас э ядра они вынуждены договариваться за память, которая на самом деле ними не нужна. Вот давайте посмотрим на такой вот примерчик. Явно увидим, что это всё можно потрогать вживую. Во-первых, давайте немножко про

77:22

Speaker A

кашлини. То есть кашлиние - это не что-то эфимерное. Вот, допустим, можно прямо посмотреть, что у меня на устройстве это 128 байт. Это для арма, значит, вот, да, CPU Arm 64. Для Арма это 128 байт. Вот. То есть, видите, шй.

77:36

Speaker A

И давайте такой пример посмотрим. Тут сейчас будет много незнакомых конструкций, но я проговорю словами, будет понятно. Смотрите, есть структурка, вот такая структурка. В ней хранится просто один атомик. Вот почему атомик? Потому что мы хотим, чтобы ядры договариваться начали. Потому что если

77:51

Speaker A

мы бы написали здесь просто бы int, то они бы не договаривались бы. Поэтому мы хотим, чтобы они начали договариваться.

77:56

Speaker A

И договариваться они начали как бы за данные, которые не нужны. Вот. Дальше что мы делаем? Мы запускаем наши рутины и каждая из них берёт и просто вот условно обращается к каким-то рандомным.

78:09

Speaker A

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

78:24

Speaker A

на самом деле запустили воркеры, там на само запускаем какое-то количество наших воркеров. Вот. Да, здесь, кстати, не очень корректный меня, если честно. For next запускается ещё одна русина, а это не очень хорошо. А, не, ладно, всё, ладно, они потом дожидаются здесь.

78:41

Speaker A

Ладно, а давайте этот бенчмарк, он не очень хороший. Вот я давно описал. Он примерно показывает картину, но его бы переписать, на самом деле, по-хорошему.

78:52

Speaker A

Давайте пока что важно понять. Важно понять следующее, что у нас воркеры просто берут и доступаются к разным индексам нашего слайса. Мы делаем ровно то же самое во втором случае, только добавляем некоторое смещение к нашей структуре. То есть не просто atтоomic

79:09

Speaker A

in, а ещё какой-то падинг, то есть заполняем данными. Вот, на самом деле, мы это делаем, чтобы ядра не конфликтовали между собой. То есть, понятно, мы заполнили вот таким падингом. Если мы сейчас запустим, то есть два этих кода, они идентичные, то

79:21

Speaker A

мы увидим следующее. Вот мы увидим, что версия вот с падингом работает, она гораздо быстрее работает. То есть версия с падингом работает, ну, тут как бы в два раза, но на самом деле просто плохой бенчфарк написан. На самом деле она

79:35

Speaker A

работает, может доходить и до четырёх-пяти раз. Вот у нас версия content, которая просто вот с такой структуркой, она работает практически в два раза хуже, чем такая версия. Вот с такой просто с добавлением какого-то падинга. В общем, вообще не очевидного

79:49

Speaker A

схода. Вот опять же, почему так происходит? Потому что у нас ядра, как я уже сказал, они что делают? Они доступаются к элементу вот эти вот слайса. Поскольку слайс - это обычно память линейная, которая построительная, то есть у нас адреса рядом лежат, то

80:05

Speaker A

получается такая ситуация, что у меня в слайсе есть, допустим, какой-то там D1, D2, D3, у меня один воркер доступается к D1 и задевает память следующего. И вот следующему нужно договариваться с предыдущим, потому что он задел его память. А вот здесь что получается? что

80:20

Speaker A

я как бы добавил падинг и у меня здесь, да, есть D1, D2 и вот с некоторым смещением, да, я вот я читаю D1 и у меня вот есть смещение, поэтому я не попадаю на следующую память, и у меня всё

80:29

Speaker A

хорошо. Вот это такое объяснение примерно для понимания. Вопрос: сколько воркеров? Это хороший вопрос. Здесь, короче, не очень корректный бенчмарк, если честно, написан. Вот я сейчас не хочу просто тратить время, чтобы его переписывать. Я потом перепишу в фоне изQю. Тут просто как бы, в общем-то, так

80:44

Speaker A

не очень корректно делается. То есть как бы запускается в параллельноммарке рутины, которые мы потом как бы дожидаемся.

80:53

Speaker A

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

81:07

Speaker A

есть. То, что вот с добавлением падинго мы получаем ускорение, да, за счёт того, что у нас то, что я показал, ядра а читают э память, да, бачами некоторыми, ну, то есть кашленями называется формально. Вот. Итого, а, значит, такая

81:21

Speaker A

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

81:28

Speaker A

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

81:46

Speaker A

работать медленнее, да, но вот гораздо медленнее, потому что вот, допустим, здесь, да, явно показал, что вот 120 и 1.200, да, что 1.200 200тин медленнее, чем 120. Ну, в частности, потому что наклонны расход на создание, но ещё и потому, что как раз-таки у нас

82:01

Speaker A

ээ потоки конкурируют за возможность что-то делать, то есть за время процессора и ещё конкурирует за память тоже. То есть нужно договариваться. То есть тут, в общем, идея в том, что иногда больше потоков не всегда лучше, поэтому нужно бечмаркать смотреть. Вот.

82:13

Speaker A

О'кей. Хорошо. Да, кто пишет в чат прочмарки, не переживайте. Будет отдельное занятие про то, как писать чchмарки. Не переживайте. С памятью всё ещё всё тоньше. Там типа начиная от того, что виртуальные адреса транслируются физически, там есть понятно специальная железка MU, которая

82:29

Speaker A

это делает, рядышком прикрученны лбек Иши, которые ускоряет всё это дело. На уровне оси есть структура данных, которая называется P table, в которой есть, понятно, разная иерархия, всякие оптимизации типа huge Page и вот это всё вот тоже я скину отдельный материал, где

82:43

Speaker A

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

82:57

Speaker A

что мы сегодня поняли? Мы поняли, что у нас как раз-таки вот основное свойство, то есть синхронизация, которая нам даёт возможность получать консистентность, нужную нам, обеспечивается за счёт гарантии той или иной железки, на которой мы программируем. Языки программирования так или иначе пытаются

83:12

Speaker A

от нас это скрыть всякими абстракциями, пакетами, чтобы мы об этом не думали. Вот, чтобы программировать было легче, понятно. Но иногда, как мы увидели, абстракции всё-таки проливаются не только вот в многопоточном программировании, а в целом, на самом деле, в любых областях, а где пытаются

83:26

Speaker A

какие-то абстракции навесить. Ну, то есть появляются эксперты того, как правильно использовать ту или иную обёртку, чтобы под капотом оно работало нормально. То есть люди, которые понимают, как работать под капотом, вот в сквозь абстракцию. И мы сегодня разобрали CPU bound задачи, а именно

83:40

Speaker A

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

83:56

Speaker A

том плане, что, ну, то есть если мы сделаем 1.000 потоков, а у нас всего 10 ядер, станет только хуже. То есть нет смысла делать 1.000 потоков, когда у нас 10 ядер, понятно, какие ядра там физические или логические, всякие SMT,

84:08

Speaker A

вот этотрейдинг от Интела, который тоже есть, часто встречается на продажных серверах. Тоже идеальная тема. Я скинул про неё терял. Называется SMT Hyperтрейдинг - это когда у вас одно ядро может обслуживать два потока. И вот часто пишут там на процессорах, что у

84:23

Speaker A

нас там 12 ядер физических и 24 логических. Почему 24? Потому что буквально одно ядро может обслуживать два потока, то есть даже ваша ось будет видеть как бы два ядра. На самом деле, физически оно одно. Вот. Спасибо большое за просмотр. Переходи в мой

84:39

Speaker A

Telegram-канал, чтобы оставаться на связи, и пиши в комментариях, какая часть из видео тебе понравилась больше всего.

Topics: многопоточность concurrency Go атомарные операции закон Мура многоядерные процессоры прерывания планировщик ассемблер синхронизация

Учить по этому видео

- [Карточки по этому видео](https://sozai.app/ru/tools/flashcard-maker/#from=transcript&id=96782)
- [Тест по этому видео](https://sozai.app/ru/tools/quiz-generator/#from=transcript&id=96782)
- [Кроссворд по этому видео](https://sozai.app/ru/tools/crossword-maker/#from=transcript&id=96782)
- [Филворд по этому видео](https://sozai.app/ru/tools/word-search-maker/#from=transcript&id=96782)
- [Шпаргалка по этому видео](https://sozai.app/ru/tools/study-guide-maker/#from=transcript&id=96782)

Бесплатно, составлено ИИ по этой расшифровке. Без регистрации.


---
This is the markdown twin of https://sozai.app/transcript/concurrency-secrets-go-processor-atomics-guide/ — the same content, without the markup.
Published by SozAI (https://sozai.app). Reuse and quotation are allowed with attribution and a link back.
Machine-readable index: https://sozai.app/llms.txt · data API: https://sozai.app/api/
