Пишем код на GO под Linux

Язык ядра Linux, его модулей и утилит написаны на языке C. Хоть он и является старым языком и прародителем многих других, но его до сих пор используют. В экосистему линукса постепенно проникают и более молодые языки — например, Rust. Но сегодня мы поговорим об детище Google — GoLang.

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

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

Go — это детище Google, они пытались создать язык программирования, в котором была и легкость изучения Python, и скорость работы C/C++. Они сделали его компилируемым, но у него есть редко используемый интерпретатор. Также разработчики избегали сделать Go тяжеловесным как C++. Также одна из целей была — отобразить в языке возможность параллельных вычислений в многопроцессорных (SMP, многоядерных) системах.

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

При упоминании Go, чаще всего всплывают следующие преимущества:

Хоть и Go относительно молодой язык программирования, он уже успел стать популярным инструментом для создания ПО. Например, тот же Docker, которым вы с 99% шансом пользовались, написан на Go. В 2009 стал языком года по версии TIOBE. В каждом дистрибутиве линукса есть огромное количество библиотек для Go.

Еще одной отличительной способностью Go является быстрота исполнения программы — чаще всего даже быстрее языка C.

Программы на Go могут непосредственно использовать C-код. Для этого существует CGO. Для его использования пишется обычный Go-код, но тот, который импортирует псевдо пакет "C". Go-код после этого может ссылаться к типам из языка C — C.size_t, переменным ( C.stdout ), или к функциям ( C.putchar() ). Это полезно для Linux, таким образом обеспечивается низкоуровневый API ко всем системным вызовам и библиотекам .so .

Пример кода:

Комментарии в синтаксисе Go является кодом на языке C, при подключении даного псевдопакета.

Флаги компилятора GCC могут быть переданы также через комментарии:

Также существуют несколько специальных функций для конвертации типов из C в Go и обратно:

Таким вот образом, код на Go может использовать богатство наработанных библиотек C/C++ и фрагментов кода на этих двух языках, и, самое главное, использовать все API библиотек POSIX и Linux!

Для начала, небольшое введение в сами процессы и процессор в Linux.

Основная информация о процессоре формируется ядром Linux в псевдофайловой системе procfs.

Вот пример файла cpuinfo (информация о процессоре) на процессоре AMD C50:

Каждое физическое ядро является относительно автономным независимым процессором.

Но иногда можно встретить, что вроде бы в 4-ядерном процессоре только два ядра на сокет. Но при внимательном изучении, можно понять что каждый из этих процессоров имеет два потока выполнение (hyperthreading, HT, гипертрединг). Это второе, логическое ядро, при некоторых условиях может выполнять поток команд параллельно основному физическому ядру. Главная особенность HT — более-менее повышение суммарной производительности пары физическое+логическое ядро наблюдается только при соблюдении условий — ядра в паре должны выполнять как можно более разнородные операции. Но даже в этом случае максимальный выигрыш производительности двух ядер оценивается максимум в 10-30%, и то в серьезных задачах.

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

Первые модели параллелизма были созданы на уровне процесса многозадачной ОС как единица параллельного выполнения.

Но настоящая популяризация параллельности в UNIX пришла с добавления системного вызова fork(). Концепция ветвления, то есть форк, была включена даже в стандарты POSIX.

Вызов fork() разветвляет текущий процесс на родительский (текущий) и дочерний (parent и child процесс). В системах с виртуальной памятью за счет механизма copy-on-write создание полной копии родительского процесса без копирования. И поэтому создание дочернего процесса очень быстрое.

Модель ветвления процессов дала жизнь парадигме построению параллельных клиент-серверных программ.

Единственная разница между родительским и дочерним процессом — то что вызов fork() возращает 0 в дочернем процессе и значение PID этого процесса в родительском, и N<0 — если при выполнении вызова произошла ошибка

Я надеюсь, вы знаете что такое закон Мура, и почему он перестал действовать примерно в 2000х годах. Согласно этому закону, кол-во транзисторов на кристалле интегральной схемы удваивается каждые 24 месяца (2 года). Также есть немного другая версия — каждые 18 месяцев (полтора года) производительность процессоров должна удваиваться из-за сочетания количества транзисторов и увеличения тактовых частот процессоров.

Но с 2003 года стало ясно — дальнейший рост производительности будет расти не за счёт увеличения частоты процессора, а за счет количества ядер процессора.

С 1995 года весь API pthread_t вошел в стандарты POSIX.

Поток — это "легкая" единица планирования ядра. Переключение потоков осуществляется относительно легко, оно требует переключения контекста.

Как минимум один поток существует в каждом процессе. Если внутри процесса создается несколько потоков ядра, то они все совместно используют выделенную процессору память.

Язык Go, как я уже сказал ранее, сочетает в себе лаконизм и ясность C с такими высокоуровневыми вещами, как множественные возвраты из функций, простота работ со строками и т.д.

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

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

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

Одна из целей создания Go, как я уже не раз повторял — это эффективное выполнение многих корутин. В Go встроен механизм планировщика параллельных горутин, который первоначально реализовал Дмитрий Вьюков. Этот планировщик по схеме M:N, где M — потоки ядра, а N — число сопрограмм.

Число M чаще всего равно числу процессоров.

A N параллельных корутин (N>M или N>>M) реализуются как легкие сопрограммы пространства пользователя, реализующих модель кооперативной многозадачности. Горутины прикреплены к потокам, но время от времени, при возникновении разбалансировки, могут перераспределяться между потоками ядра.

Go дает возможность создать новую ветвь (поток) выполнения программы (goroutine, go-процедуру) с помощью выражения go. Это выражение запускает функцию в другой заново созданной go-процедуре (сопрограмме). Все go-процедуры в одной программе используют одно и то же адресное пространство.

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

Go позволяет использовать ассемблерные вставки в коде. Написание функций на ассемблере прямо в Go не так уж сложно, как кажется. В качестве примера, рассмотрим функцию sum, которая складывает два int64:

Хотя это стандартная функция, в ней отсутствует тело. Поэтому компилятор выдаст ошибку при попытке сборки программы.

Для реализации функции на ассемблере добавим файл с расширением .s:

Теперь мы можем собрать, протестировать и использовать функцию sum как обычную. Этот подход широко применяется в различных пакетах, таких как runtime, math, bytealg, syscall, reflect, crypto, позволяя использовать аппаратные оптимизации процессора и команды, отсутствующие в самом языке. Во многом благодаря этому можно создать полноценное ядро операционной системы.

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

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

Встраиваемые функции представляют собой элегантное решение, предоставляющее доступ к низкоуровневым операциям без необходимости расширения спецификации языка. В случае отсутствия специфических примитивов sync/atomic (например, в некоторых вариантах arm), или операций из math/bits, компилятор будет вставлять полифил на обычном Go.

Go не был разработан для low-level кодинга, но при наличии желания вы можете даже разработать на нем ОС.

Я надеюсь, вам понравилась статья. Если у вас остались вопросы или есть комментарии — прошу оставить их, я обязательно отвечу и прочитаю. И не забывайте ставить плюсы!

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

#golang

#go

#программирвоание