HamsterGamer

Квант времени - это время в течение которого ОС позволяет работать потоку (процессу) непрерывно. По истечении времени, поток вытесняется другим. Когда настанет очередь опять выполняться этому потоку (процессу) ему снова будет предоставлен 1 квант времени. Так что переживать о том, что не хватит времени - не стоит - время всегда будет дано, пока процесс работает.
Квант времени в разных ОС разный, обычно это что-то в диапазоне 1-10 мс. В Линуксе квант динамический, вычисляется на основе приоритета процесса - чем выше приоритет процесса, тем больше ядро дает ему работать.

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

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

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

Из-за того, что вы в конце не вызвали системный вызов exit. Системный вызов write ожидает строку, а не число, так что перед выводом суммы нужно выполнить преобразование. Кстати, в 32-х битных линуксах системные вызовы принято делать через комманду sysenter, т.к это быстрее, а не через int 0x80.

Попробуйте extern "C" int _sub(int, int);

В UTF-8, UTF-16LE и UTF-16BE символ кириллицы занимает два байта.
Но в каждом из этих случаев это будут два РАЗНЫЕ байта.
Соответственно, алгоритм, работающий с байтами, выдаст РАЗНЫЙ хэш.
Вам, если вы не хотите разложить себе на дороге грабель, лучше приводить свою информацию к байтам самостоятельно, а не полагаться на какие бы то ни было "волшебные" библиотеки.

async_read не перекрывает async_write потому, что под капотом происходит не совсем то, что вы видите в исходных кодах. Блоки кода вроде boost::asio::async_read и boost::asio::async_write (я их далее буду называть задачами) во время компиляции разбиваются на более мелкие инструкции. В фоне система может приостанавливать исполнение одной задачи, запоминая все её данные, переключаться на другую задачу и какое-то время исполнять её, потом приостанавливать её исполнение и переключаться на третью задачу, потом снова на первую и так далее по кругу. За счёт этого можно в рамках одного потока выполнять сразу несколько задач. Сама эта система конфигурируется таким образом, чтобы переключаться по очереди этих задач один раз, например, в микросекунду. И таким образом она кусками их выполняет, а у вас складывается впечатление, что они работают параллельно, потому что переключения по очереди происходят очень быстро и зависят не от объёма кода, который нужно выполнить, а от фиксированного времени, которое система готова потратить на работу с одной задачей.

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

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

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

(Раз в микросекунду — это не точное значение, и я его привёл только для примера, чтобы было понятно, что переключение по очереди задач происходит очень часто.)

Термин для гугления: дедупликация.