EuroAssembler ― Кроссплатформенный ассемблер с открытым исходным кодом

Автор ― программист Pavel Šrubař из небольшого чешского городка Vítkov (город в Опавском районе Моравскосилезского края Чехии. Население около 5500 человек). Трудился в IT отделе Чешской Почты города Vítkov. Сейчас живет в Праге.
Электронная почта pavel.srubar@post.cz,
твиттер http://twitter.com/vitsoft
Сайт
Форум посвященный EuroAsm

Домашняя страница euroassembler.eu. Скачать EuroAssembler можно отсюда, прямая ссылка на актуальную версию . Ассемблер написан на себе самом, это даёт компактность и портабельность, но на него нервно реагируют эвристики некоторых антивирусов. После распаковки у вас в руках будет euroasm.exe размером в четыреста килобайт. Исходный код ассемблера открыт и доступен, его несложно пересобрать в случае необходимости.

 

Это переделанная и урезанная статья Об ассемблере EuroAssembler, о котором вы, возможно, не слышали Андрея Дмитриева (@AndreyDmitriev) с хабра.
Если ограничить кругозор ОС Windows, тогда обнаружим, что под эту ОС существует несколько макро-ассемблеров, которых не так уж много. Если основным инструментом является Visual Studio, то будет логичен выбор ассемблера MASM. Он достаточно популярен и бесплатен. Из альтернатив можно упомянуть FASM (Flat Assembler) и NASM (Netwide Assembler). У каждого диалекта ассемблера (MASM, TASM, FASM, NASM, A386) есть свои плюсы и минусы. Есть и малоизвестные, например входящий в состав Pelles C. Эти ассемблеры могут отличаться синтаксисом и идеологией (кто-то может ассемблировать в объектный файл, а другие имеют встроенный линковщик) но речь не о них. Важно понимать, что на "чистом" ассемблере далеко не уехать, поэтому у них есть приставка "макро", когда можно упростить программирование при помощи макросов.

Первая программа

Как говорили великие — единственный способ научиться программировать — это начать писать программы, давайте для начала просто сложим два числа и выведем результат в консоль (чистый "Hello, World!" будет состоять из одного макроса и вообще не будет содержать ни строчки на ассемблере, так что разбавим пример хотя бы mov и add).
Всё, что вам надо знать, это то, что у процессора есть Регистры (коих шестнадцать штук общего назначения) и Инструкции, которыми он оперирует.
Структура минимальной программы на этом ассемблере очень проста, вот она полностью:

Код (ASM):

1. EUROASM
2. AddWorld PROGRAM Format=PE, Entry=Start
3. INCLUDE winapi.htm, cpuext32.htm
4. Result D 8*B
5. Start: nop
6. mov eax, 17
7. add eax, 29
8. StoD Result
9. StdOutput =B"17+29=", Result
10. TerminateProgram
11. ENDPROGRAM

Давайте разберём все строчки, их тут десяток всего-то. Ссылки на документацию приводятся.
Программа начинается с ключевого слова EUROASM, за которым вообще говоря могут идти опции, но в этой минимальной программе они не нужны (потому что выставлены по умолчанию).
Следом идёт имя программы и ключевое слово (псевдоинструкция) PROGRAM, перед которой находится имя программы, за которым две опции — формат PE, что означает Portable Executable (если бы мы писали DLL, то было бы очевидно DLL), и точка входа (может быть любая строка — Start, Begin или main — всё, что хотите, вы видите эту метку чуть ниже). Кстати, в одном файле может быть несколько секций PROGRAM, тогда у них должны быть разные имена, и в этом случае компиляцией одного файла можно сразу получить несколько исполняемых файлов или библиотек.
Затем следует INCLUDE — здесь мы включаем две библиотеки макросов, из одной мы возьмём макрос перевода числа в строку, а из второй — вывод в консоль. И расширение .htm — это не ошибка — да, вы можете хранить код в HTML. Включать можно не только библиотеки, но вообще любые файлы, обычно им даётся расширение *.inc.
Result D 8*B резервирует восемь байт для результата (для короткого числа в этом примере нам больше и не надо).
Следом идёт метка Start: , это входная точка программы, куда будет передано выполнение после загрузки в память, и инструкция nop. Наличие оператора nop помогает евроассемблеру отделить мух от котлет код от данных — так работает автосегментация. Это позволяет избавиться от явного указания секций [.text] и [.data]. Также в отладчике этот NOP удобно видеть как "метку" начала программы и начала отладки.
mov eax, 17 заносит значение 17 в регистр EAX, а add eax, 29 добавляет туда 29. Числа 17 и 29 я взял не случайно — 1729 это симпатичное число Рамануджана-Харди. Регистр не важен — можете писать MOV EAX,17, так предпочитает автор, но в основном нынче используются строчные буквы, время семибитных кодировок кануло в лету.
StoD Result берёт значение RAX (там 46) и переводит его в ASCII строку "46", копируя в буфер, на который указывает Result. Как бы аналог itoa(). На самом деле перевод числа в строку на чистом ассемблере — не такая уж тривиальная задача, загляните в исходник по ссылке выше, там больше полусотни инструкций.
Ну а StdOutput =B"17+29=", Result выводит на экран 17+29=46. =B — это "синтаксический сахар", позволяющий "заинлайнить" строковую константу-литерал, кроме того макрос StdOutput может принимать переменное число аргументов. Здесь также надо понимать, что для вывода в консоль надо ведь вначале получить хендл через GetStdHandle(), затем писать через WriteConsole(), при этом строка может содержать Юникод, вот от всего этого нас и избавляет данный макрос.
Затем программа завершается через TerminateProgram (это тоже макрос, который вызывает ExitProcess() из kernel32.dll) и ключевое слово ENDPROGRAM (если у вас несколько программ в одном файле, то там понадобится имя программы). TerminateProgram не есть обязательная вещь — программа завершится и так, но формально пусть будет — ей можно передать код возврата ошибки.
Создайте файл AddWorld.asm, да хоть в блокноте Windows и скопируйте туда код, что был выше, сохраните этот файл там же, где находится euroasm.exe (либо скопируйте весь евроассемблер в %APPDATA%\eurotool и добавьте путь в PATH). Сборка программы осуществляется при помощи команды euroasm.exe AddWorld.asm. Всё.
Если вы скопировали всё без ошибок, то после компиляции появится файл AddWorld.exe, который и выведет это сообщение 17+29=46.
Маленький лайфхак — если вам лень ставить редактор с поддержкой ассемблер-синтаксиса, равно как и возиться с командным промптом, просто поставьте Far Manager, встроенный редактор (новый файл Shift+F4, редактирование F4) понимает ассемблер и раскрашивает код, а компиляцию можно упростить через пользовательское меню, всё вместе это будет выглядеть как-то так (как видите, все папки дистрибутива не нужны, достаточно maclib и objlib):

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

Код (ASM):

1. EUROASM CPU=x64
2. %^SourceName PROGRAM Format=PE, Width=64, Entry=Start
3. Buffer1   D 32*B
4. Buffer2   D 32*B
5. Result    D 32*B
6. INCLUDE winabi.htm, cpuext64.htm
7. Start: nop
8. StdOutput =B"Enter 1st Operand ]"
9. StdInput Buffer1
10.          StdOutput =B"Enter 2nd Operand ]"
11. StdInput Buffer2
12. LodD Buffer1
13. mov rbx, rax
14. LodD Buffer2
15. add rax, rbx
16. StoD Result
17. StdOutput =B"Result:", Result
18.         TerminateProgram
19. ENDPROGRAM

Здесь несколько небольших изменений.
Во-первых, имя программы заменено на переменную %^SourceName. Так удобнее работать в сценарии "один файл—одна программа", потому что имя будет браться из имени файла (и именно под этим именем будет создаваться исполняемый файл или библиотека DLL). Переменных там много — €ASM system %variables.
Кроме того, мы переехали на 64 бита добавлением CPU=x64 и Width=64 и соответственно поправили INCLUDE, также вместо 32-битных регистров типа EAX используется 64-бит RAX.
Затем добавлены два буфера для входных строк.
StdOutput вы уже знаете, этот макрос выведет приглашающий промпт, а вот StdInput получит данные, введённые пользователем и запишет введённое значение в буфер, на который указывает Buffer1 (как ASCII символы, включая перевод строки). Затем всё повторяется для второго операнда. Таким образом, если мы введём "42", то в буфере будут 0x34, 0x32, 0x0D, 0x0A.
Теперь нам надо конвертировать ASCII строку в значение, что-то типа atoi(), это делает макрос LodD, который возвращает значение в регистр RAX (теперь у нас 64 бит). Мы сохраним это значение в RBX, и повторим LodD для второго буфера. Теперь в RBX у нас первый операнд, а в RAX второй. Команда add RAX, RBX их складывает, и дальше всё как и выше. Важный момент — при таком использовании вы должны быть абсолютно уверены, что LodD Buffer2 не изменит значение RBX! (чтобы в этом убедиться, достаточно заглянуть в исходник макроса).
Предположим, в качестве следующего упражнения мы хотим использовать стек для хранения первого введённого операнда, затолкаем RAX в стек и вытащим его в RBX:

Код (ASM):

1.  LodD Buffer1
2. push rax
3. LodD Buffer2
4. pop rbx
5. add rax, rbx
6. StoD Result

Кстати, в этом ассемблере поддерживаются множественные переменные при работе со стеком, то есть не надо писать отдельно push rax, push ebx, а можно одной командой push rax, rbx — это удобно.
Либо можно завести временную переменную, зарезервировав восемь байт памяти:

Код (ASM):

1. TempVar   D Q      ; Reserve one qword.
2. ; ...
3. LodD Buffer1
4. mov [TempVar], rax
5. LodD Buffer2
6. add rax, [TempVar]
7. StoD Result

Можно получить значения из аргументов командной строки, для этого есть макросы GetArgCount и GetArg. В общем не бойтесь экспериментировать. Ассемблер снабжён неплохой инструкцией, кроме того довольно большим количеством примеров и проектов, в конце есть несколько для Windows, от простого консольного приложения, поддерживающего юникод до заготовки оконного приложения.
Как справедливо заметили в комментариях, этот ассемблер может "собрать" файл для Линукса в том числе, всё что нужно для этого — заменить формат PE на ELFX и включить linapi.htm вместо winapi.htm, вот минимальный код:

Код (ASM):

1. EUROASM
2. HelloWorld PROGRAM Format=ELFX, Entry=Start
3. INCLUDE linapi.htm
4. Start: nop
5. StdOutput =B"Hello, World!", Eol=yes
6. TerminateProgram
7. ENDPROGRAM

после сборки которого вы получите файл HelloWorld.x, который можно тут же запустить под WSL:

$ ./HelloWorld.x
Hello, World!
$ file HelloWorld.x
HelloWorld.x: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, not stripped

Более того, вы можете собирать исполняемые файлы одновременно для Windows и Linux (равно как и 32- и 64-бит версии) сложив общий код во включаемый файл и пользуясь тем фактом, что в одном файле можно иметь множественные секции PROGRAM, единственная хитрость — нужно сбросить макросы между программами:

Код (ASM):

1. EUROASM AutoSegment=Yes, CPU=X64, SIMD=AVX2
2. HelloLinux PROGRAM Format=ELFX, Width=64, Entry=Start:
3. INCLUDE linabi.htm, cpuext64.htm
4. INCLUDE Code.asm ; < Your code
5. ENDPROGRAM HelloLinux
6. %DROPMACRO *  ; Forget macros defined in "linabi.htm".
7. HelloWindows PROGRAM Format=PE, Width=64, Entry=Start:
8. INCLUDE winabi.htm, cpuext64.htm
9. INCLUDE Code.asm
10. ENDPROGRAM HelloWindows

Кстати, этот метод работает "в обе стороны", в том смысле, что вы можете не только собирать программы для Линукса из под Windows, но и наоборот из под Линукса под Windows, запуская euroasm.x.

Отладчик

Очень рекомендуется овладеть отладчиком. Можно использовать WinDbg, но многие предпочитают x64dbg, хотя он не без проблем (в смысле общей стабильности), но во многом удобнее.
Как им пользоваться? Допустим, вы не очень уверенно понимаете, как работает стек. Пишете небольшое приложение, которое заносит значения в два регистра, заталкивает их в стек, обнуляет (xor rax, rax — стандартный способ, привыкайте) и вытаскивает обратно:

Код (ASM):

1. EUROASM CPU=x64
2. %^SourceName PROGRAM Format=PE, Width=64, Entry=Start
3. Start: nop
4. mov rax, 0x17
5. mov rbx, 0x29
6. push rax, rbx
7. xor rax, rax
8. xor rbx, rbx
9. pop rbx, rax
10. jmp Start
11. ENDPROGRAM

Запустите отладчик x64dbg (для отладки 32 бит приложения надо будет запускать 32-бит отладчик, у нас же 64 бита), затем откройте файл приложения (F3), после чего однократно нажмите F9 для загрузки и перемещения на точку входа, вы должны остановиться на NOP, затем пройдите пошагово, нажимая F7. Вот что вы увидите:

Хорошо видно, как уменьшается значение регистра RSP (указатель стека) на 8 байт при каждой инструкции push и как данные записываются в область памяти, на которую указывает указатель стека. Заметьте также, что ассемблер заменил инструкции mov rax, .. на mov eax, .., сэкономив вам несколько байт.
Ещё полезная вещь — листинг компиляции, который для примера выше выглядит вот так:

Код (Text):

1. |                              |EUROASM CPU=x64
2. |                              |%^SourceName PROGRAM Format=PE, Width=64,...
3. |[.text]                       ::::Section changed.
4. |00000000:                     |
5. |00000000:90                   |Start: nop
6. |00000001:B817000000           | mov rax, 0x17
7. |00000006:48BB2900000000000000 | mov rbx, 0x29, IMM=Q
8. |00000010:5053                 | push rax, rbx
9. |00000012:4831C0               | xor rax, rax
10. |00000015:4831DB               | xor rbx, rbx
11. |00000018:5B58                 | pop rbx, rax
12. |0000001A:EBE4                 | jmp Start
13. |                              |ENDPROGRAM
14. |   **** ListMap "StackTest.exe",model=FLAT,groups=0,segments=2,entry=Start
15. | [.text],FA=0200h,VA=00401000h,size=28,width=64,align=0010h,purpose=CODE
16. | [.rsrc],FA=0400h,VA=00402000h,size=13660,width=32,align=0010h,purpose=RES

Тут в левой колонке показаны машинные коды, в которые будут преобразованы инструкции. NOP — это машинный код 0х90 (который знает наизусть каждый реверс-инженер). Эти же машинные коды вы видите и в отладчике выше. Для примера я указал, что хочу получить именно 64-бит код для второго mov, добавив модификатор IMM=Q, и вы видите появившийся префикс 48 и 64 бит константу в восьми байтах. Вся архитектура фон Неймана раскрывается во всей красе.
Внизу вы видите виртуальный базовый адрес 00401000h (он складывается из стандартной базы 0х400000 и смещения), его же вы видите и в отладчике и секции файла, они выровнены на границу четырёх килобайт (0х1000), что составляет стандартный размер страницы памяти Windows. Всё просто.

Эксперимент — WinAPI

Вам никто не запрещает напрямую вызывать функции WinAPI прямо из Ассемблера, в 64-бит программе это делается следующим образом, для совсем тривиального примера два последовательных вызова GetTickCount64(), разделённых Sleep(1000):

Код (ASM):

1. EUROASM CPU=x64, SIMD=AVX2
2. %^SourceName PROGRAM Format=PE, Width=64, Entry=Start
3. Elapsed D 32*B
4. INCLUDE winabi.htm, cpuext64.htm
5. Start: nop
6. WinABI GetTickCount64
7. push rax
8. WinABI Sleep, 1000
9. WinABI GetTickCount64
10. pop rbx
11. sub rax, rbx
12. StoD Elapsed
13. StdOutput =B"Sleep(1000) - ", Elapsed, =B" ms", Eol=yes
14. jmp Start
15. ENDPROGRAM

Макрос WinABI следует соглашениям о вызове 64-бит функций — результат GetTickCount64() возвращается в RAX, параметр 1000 передаётся в Sleep() через RCX. Как результат вы будете видеть разницу в диапазоне 1000...1016 миллисекунд — так работает таймер низкого разрешения. В принципе ИИ способен достаточно внятно объяснить этот код выше.
Само собой, вы можете вызывать не только WinAPI, но и любые экспортированные функции из любой DLL, вот, к примеру, если рудиментарный вывод в консоль вас не устраивает, вы вполне можете воспользоваться стандартной printf(...) из msvcrt.dll:

Код (ASM):

1. EUROASM CPU=X64, SIMD=AVX2
2. printf1 PROGRAM Format=PE, Width=64, Model=Flat, Entry=main:
3. INCLUDE winabi.htm
4. LINK msvcrt.lib ; for printf(...)
5.  
6. main: nop
7. mov rax, 42
8. WinABI printf, =B"printf: The Answer is %%d", rax
9. ENDPROGRAM

При этом поддерживается и динамический вызов при отсутствии *.lib файла, так тоже можно:

Код (ASM):

1. EUROASM CPU=X64, SIMD=AVX2
2. printf2 PROGRAM Format=PE, Width=64, Model=Flat, Entry=main:
3. INCLUDE winabi.htm
4.  
5. main: nop
6. mov rax, 42
7. WinABI printf, =B"printf: The Answer is %%d", rax, Lib=msvcrt.dll
8. ENDPROGRAM

И поскольку евроассемблер — это и ассемблер и линковщик "в одном флаконе", то существует удобный скрипт, генерирующий библиотеку импорта lib из динамической библиотеки — dll2lib.htm.
Вообще использовать ассемблер для микробенчмаркинга очень хорошо, поскольку всё находится в ваших руках, позволяя спуститься на уровень машинного кода, но, конечно же не при помощи GetTickCount. Ниже ещё пара примеров. Обычно в этом месте дотошные читатели резонно замечают, мол всё тоже самое можно получить на Си/С++ заметно меньшими усилиями, и это в общем так, но в данном случае мы не зависим от компилятора, его версии и опций оптимизатора, и всё под контролем. Ниже ещё несколько примеров на ассемблере, они не настолько велики, чтобы ради них писать отдельные статьи, но в контексте изложения — вполне уместны.

Эксперимент — работа предсказателя переходов

Не так давно на хабре была статья Ловушка профилирования, где были получены довольно любопытные результаты. Суть там была в том, что используя google benchmark производились замеры времени исполнения кода с переходами и эквивалентного кода без них, и внезапно выяснилось, что результат зависим не только от кода, но и от данных, которые используются — при проходе по одному и тому же массиву результаты улучшались, а при изменении данных от прогона к прогону — ухудшались. Вот как можно провести поверку результатов на ассемблере.
Для начала нам понадобится пара нехитрых макросов, которыми мы будем обкладывать наш код, время выполнения которого мы хотим измерить и макрос, который выведет результат. Предполагается, что мы вызовем код много раз в цикле и возьмём минимальное время прохода — это стандартный способ для синтетического бенчмаркинга:

Код (ASM):

1. Buffer  DB 80 * B
2. StartBench %MACRO
3. CPUID
4. RDTSC
5. shl rdx, 32
6. or rax, rdx
7. mov r8, rax
8. %ENDMACRO
9. EndBench %MACRO Min
10. RDTSCP
11. shl rdx, 32
12. or rax, rdx
13. sub rax, r8
14. mov rbx, [%Min]
15. cmp rax, rbx
16. cmova rax, rbx
17. mov [%Min], rax
18. %ENDMACRO
19. PrintBench %MACRO Message, Min
20. mov rax, [%Min]
21.     StoD Buffer
22.     StdOutput =B%Message, Buffer, =B" Ticks", Eol=Yes, Console=Yes
23. Clear Buffer, Size=80
24. mov [%Min], -1, DATA=Q
25. %ENDMACRO

Здесь используется инструкция RDTSC для получения тиков тактового генератора, работающего на базовой частоте процессора. Пара CPUID/RDTSC...RDTSCP — это классический подход для того чтобы свести к минимум влияние конвейеризации на результаты. Значение при старте сохраняется в R8. Затем в конце сравнивается с минимальным значением, которое обновляется. Обратите внимание на инструкцию cmova — это стандартный способ избавиться от явного перехода if (value<min) min = value; а сравниваем мы беззнаковые числа.
Ещё нам понадобится генератор случайных чисел, который заполнит массив Array размером %SIZE случайными байтами 0 или 1. Этот код, кстати, генерированный ИИ копилотом чуть более чем полностью и в общем живой и рабочий, при этом количество вызовов rdrand минимально — мы берём оттуда одиночные биты, так что один вызов поставляет нам 64 случайных числа, я оставлю оригинальные комментарии как есть:

Код (ASM):

1. random PROC
2. mov rdi, Array
3. mov rcx, %SIZE
4. xor rdx, rdx
5. .next_byte:
6.     test    rcx, rcx
7.     jz      .done             ; finished
8.     ; if no bits left in rbx, get a new 64-bit random value
9.     test    rdx, rdx
10.     jnz     .have_bits
11. .get_rdrand:
12.     rdrand  rbx               ; random 64-bit value in rbx
13.     jnc     .get_rdrand       ; retry if CF=0 (no random value)
14.     mov     rdx, 64           ; 64 bits available
15. .have_bits:
16.     ; take lowest bit of rbx, store it as a byte 0 or 1
17.     mov     al, bl            ; copy low byte
18.     and     al, 1             ; keep only lowest bit (0 or 1)
19.     mov     [rdi], al         ; store into buffer
20.     shr     rbx, 1            ; drop used bit
21.     dec     rdx               ; one less available bit
22.     inc     rdi               ; advance buffer pointer
23.     dec     rcx               ; one less byte to fill
24.     jmp     .next_byte
25. .done:
26.     ret
27. ENDPROC random

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

Код (ASM):

1. EUROASM CPU=X64, SIMD=AVX2, SPEC=Enabled
2. %^SourceName PROGRAM Format=PE, Width=64, Model=Flat, Entry=main
3. %SIZE %SET 4096
4. %ITER %SET 10000
5. INCLUDE winscon.htm, winabi.htm, cpuext64.htm
6. INCLUDE Benchmark.inc, Random.inc
7. Array:  DB %SIZE * BYTE ; 4 KiB Buffer
8. RCycl DB Q -1
9. NCycl DB Q -1
10. main:nop
11. StdOutput =B"Branch prediction benchmark", Eol=yes
12. ;-----------------------------------------------------------------------------
13. ; First Test - random array every time
14. mov  r10, %ITER             ; number of timing iterations
15. loop:
16. call random
17. StartBench
18.     mov  r11, %SIZE             ; loop counter N
19.     lea  r12, [Array]           ; r12 = address of byte array
20.     xor  r13, r13               ; r13 = taken-branch counter (per timing run)
21. loop_start:
22.     mov  bl, [r12]              ; load current value (0 or 1)
23.     test bl, bl
24.     jz   branch ; branch-taken path
25.     inc  r13                     ; do some harmless work
26. branch: ; no work for 0, but still advance
27.     inc  r12                     ; next byte
28.     dec  r11
29.     jne  loop_start
30. EndBench RCycl
31.     dec  r10
32.     jnz  loop
33. PrintBench "Rand Array: ", RCycl

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

Код (ASM):

1. ; Second Test - same array every time
2. mov  r10, %ITER
3. loop2:
4. StartBench
5.     mov  r11, %SIZE
6.     lea  r12, [Array]
7.     xor  r13, r13
8. loop_start2:
9.     mov  bl, [r12]
10.     test bl, bl
11.     jz   branch2
12.     inc  r13
13. branch2:
14.     inc  r12
15.     dec  r11
16.     jne  loop_start2
17. EndBench NCycl
18.     dec  r10
19.     jnz  loop2
20. PrintBench "Same Array: ", NCycl
21. TerminateProgram
22. ENDPROGRAM

И вот результат на процессоре Хасвелл:

Код (Text):

1. Branch prediction benchmark
2. Rand Array: 51960 Ticks
3. Same Array: 36524 Ticks
4.  

Как видите, в первом случае процессору потребовалось в полтора раза больше времени, так работает постоянно ошибающийся предсказатель переходов. Он на самом деле многоуровневый и может "удержать" в памяти до 4К последних переходов. Я изначально полагал, что основное влияние оказывает кэш, но нет, это именно эффект предсказателя. Можно воспользоваться профилировщиком VTune либо Intel PCM и убедиться, что количество промахов предсказателя значительно выше в первом случае. Это на самом деле неплохой результат для цикла, в котором семь инструкций, отрабатывающего 4 тысячи итераций. В качестве самостоятельного упражнения попробуйте оставить массив, забитый нулями (да просто закомментируйте вызов call random добавив перед этой строкой ";") и вы увидите, как количество тиков упадёт где-то до восьми тысяч — это всего два такта на итерацию. Так работает конвейер вкупе с предсказателем, всегда верно угадывающим переход — ведь современный процессор может выполнять несколько инструкций, таких как комбинации dec/jne и dec/jnz при верно предсказанном переходе за один такт.

Эксперимент — сравнение INC и ADD

Ещё один эксперимент, основанный на статье Может ли устареть инкремент....
Значение регистра процессора можно инкрементировать двумя способами — либо как inc rax, либо add rax,1. Есть ли разница между этими командами? Небольшой эксперимент на ассемблере поможет ответить и на этот вопрос. Кроме того в рамках этого эксперимента мы может воочию увидеть латентность и пропускную способность инструкций. Замеры мы будем проводить двумя способами — в одном случае мы будем просить выполнить инкремент одного и того же регистра, это даст нам зависимость по данным, а во втором случае — независимых регистров, и в этом случае процессор может начать их параллельное выполнение соответственно пропускной способности. Значения латентности и пропускной способности можно проверить в таблицах uops.info.
Чтобы выдать последовательность одних и тех же команд без утомительного копипастинга , мы воспользуемся макро языком ассемблера. Основная управляющая конструкция выглядит вот так:

Код (ASM):

1. i  %FOR  0..10000
2. inc eax
3. %ENDFOR i

Здесь будет выдано десять тысяч последовательных команд inc eax, одна за одной. Если бы мы использовали нативный цикл ассемблера, то счётчик цикла "сбил" бы нам результат измерений, его пришлось бы учитывать, а в данном случае у нас именно непрерывная последовательность. Она не должна быть очень большой, желательно, чтобы мы полностью поместились в кэш инструкций, но и не маленькой, чтобы эффект был хорошо заметен.
Теперь важно понять следующее. Когда мы выдаём команды inc eax, inc eax, ... одну за одной — они зависимы по данным, это значит, что процессор должен формально дождаться выполнения предыдущей инструкции, чтобы начать следующую (хотя и не всегда — это зависит от архитектуры). Количество тактов, затрачиваемое на одну такую инструкцию — это латентность. Однако если наши инструкции будут независимы, то процессор может начать выполнение следующей, не дожидаясь предыдущую, и количество таких инструкций, выполняемых за один такт — это пропускная способность. Последовательность из десяти тысяч независимых инструкций создаётся вот так:

Код (ASM):

1. i  %FOR  0..2500
2. inc rax
3. inc rbx
4. inc rcx
5. inc rdx
6. %ENDFOR i

Здесь у нас 2500 раз повторённая последовательность из четырёх команд, всё вместе — 10000.
Кстати, в этом ассемблере вы можете комбинировать множественные инкременты, то есть код "inc rax, rbx, rcx, rdx" - это ровно тоже самое, что и четыре отдельных инкремента выше.

Код (ASM):

1. EUROASM AutoSegment=Yes, CPU=X64, SIMD=AVX2
2. %^SourceName PROGRAM Format=PE, Width=64, Model=Flat, IconFile=, Entry=main:
3.  
4. %ITER %SET 250_000
5.  
6. INCLUDE winscon.htm, winabi.htm, cpuext64.htm
7. INCLUDE benchmark.inc
8.  
9. Cycles DB Q -1
10.  
11. main: nop
12.     mov r9, %ITER
13. L1: ; --- Latency for ADD Instruction
14.     StartBench
15. i  %FOR  0..10000
16.     add eax, 1
17. %ENDFOR i
18.     EndBench Cycles
19.     dec r9
20.     jnz L1
21.     PrintBench "ADD cycles (Latency) = ", Cycles
22.  
23.     mov r9, %ITER
24. L2: ; --- Latency for INC Instruction
25.     StartBench
26. i  %FOR  0..10000
27.     inc eax
28. %ENDFOR
29.     EndBench Cycles
30.     dec r9
31.     jnz L2
32.     PrintBench "INC cycles (Latency) = ", Cycles
33.  
34.     mov r9, %ITER
35. L3: ; --- Throughput for ADD Instruction
36.     StartBench
37. i  %FOR  0..2500
38.     add rax, 1
39.     add rbx, 1
40.     add rcx, 1
41.     add rdx, 1
42. %ENDFOR i
43.     EndBench Cycles
44.     dec r9
45.     jnz L3
46.     PrintBench "ADD cycles (Throughput) = ", Cycles
47.  
48.     mov r9, %ITER
49. L4: ; --- Throughput for INC Instruction
50.     StartBench
51. i  %FOR  0..2500
52.     inc rax, rbx, rcx, rdx
53. %ENDFOR i
54.     EndBench Cycles
55.     dec r9
56.     jnz L4
57.     PrintBench "INC cycles (Throughput) = ", Cycles
58.  
59.     TerminateProgram
60. ENDPROGRAM

И вот результат для процессора Xeon E5-1620 v3 (Haswell):

>AddInc.exe
ADD cycles (Latency) = 10028 Ticks
INC cycles (Latency) = 10028 Ticks
ADD cycles (Throughput) = 3376 Ticks
INC cycles (Throughput) = 3364 Ticks

Всё красиво — для 10000 зависимых инструкций процессору надо примерно 10000 тиков, это ровно одна инструкция на такт, а вот для независимых инструкций — втрое меньше, потому что он начинает выполнять три инструкции за каждый такт. И нет, разницы между INC и ADD ровно никакой. Единственное отличие в длине машинного кода, ведь add eax, 1 это три байта 83C001, а вот inc eax — только два FFC0. Более компактный код занимает меньше места в кэше инструкций и в общем предпочтительнее.
Ситуация, кстати, поменяется, если погонять этот код на P и E ядрах гибридного процессора, например на Core i7-13850HX, вот там ADD инструкция окажется предпочтительнее на Е ядрах, но это уже совсем другая история. RDTSC на самом деле показывает количество тиков на базовой частоте процессора, а он как правило работает на повышенной частоте и в реальности количество тактов на данном процессоре окажется заметно выше, кроме того придётся делать поправку на разную частоту ядер и лучше использовать RDPMC, но там есть свои тонкости, о которых написано в статье Достучаться до RDPMC, но вот про исключение, которое можно спровоцировать этой инструкцией, хотелось бы написать особо.

 

Эксперимент — обработка исключений

При программировании на Ассемблере не бойтесь обрабатывать исключения. Вы с процессором "один на один" и можете легко повесить операционную систему. На выброшенные исключения натыкался каждый программист, и каждый, работающий с С++ в курсе про __try... __except, но не каждый программист точно знает, как именно исключение обрабатывается, и ассемблер может помочь разобраться в пречине возникновения исключения.
Запись по нулевому указателю, равно как и деление на нуль — это слишком уж просто, там можно избежать исключения банальной проверкой. Возьмём пример посложнее, когда шансов нет — попросим процессор выполнить привилегированную инструкцию не имея на это соответствующего разрешения. Вызовем RDPMC, OUT или IN.
Простейшая программа на ассемблере:

Код (ASM):

1. EUROASM CPU=x64
2. %^SourceName PROGRAM Format=PE, Width=64, Entry=Start
3. INCLUDE winabi.htm
4. Start:     nop
5.     StdOutput =B"Before RDPMC Call", Eol=yes
6.     xor ecx, ecx
7.     RDPMC ; Exception!
8.     StdOutput =B"After RDPMC Call", Eol=yes
9.     TerminateProgram
10. ENDPROGRAM

При запуске вы увидите первое сообщение, но не увидите второго, потому что в просмотрщике событий вы увидите ошибку с кодом 0хс0000096:

Это документированная ошибка STATUS_PRIVILEGED_INSTRUCTION.
Ровно того же эффекта вы добьётесь если попробуете на С++ __readpmc():

Код (C++):

1. #include <iostream>
2. #include <windows.h>
3. int main()
4. {
5.     // This will fault unless RDPMC is enabled for user mode
6.     std::cout << "Before RDPMC call" << std::endl;
7.     uint64_t value = __readpmc(0);
8.     std::cout << "RDPMC value: " << value << std::endl;
9.     return 0;
10. }

Однако не всё так плохо, ведь вы можете сделать вот так:

Код (C++):

1. #include <iostream>
2. #include <windows.h>
3. int main()
4. {
5.     std::cout << "Before RDPMC call" << std::endl;
6.     __try {
7.         // This will fault unless RDPMC is enabled for user mode
8.         uint64_t value = __readpmc(0);
9.         std::cout << "RDPMC value: " << value << std::endl;
10.     }
11.     __except (EXCEPTION_EXECUTE_HANDLER) {
12.         std::cout << "SEH caught RDPMC exception!" << std::endl;
13.     }
14.     return 0;
15. }

И в этом случае программа не упадёт, она честно выдаст SEH caught RDPMC exception!
И вот тут если вы попросите объяснить, как именно производится структурированная обработка исключений, то многие затруднятся ответить, а на самом деле там всё относительно несложно.
Вот эквивалентный код на ассемблере, заодно и протестируем адекватность кнопки "объяснить код":

Код (ASM):

1. EUROASM CPU=X64, SIMD=AVX2
2. %^SourceName PROGRAM Format=PE, Width=64, Model=Flat, IconFile=, Entry=Start
3. INCLUDE winscon.htm, winabi.htm, cpuext64.htm
4. [.text]
5. Start: nop
6.        StdOutput =B"Hello, SEH", Eol=yes
7. try:   MOV ECX,0 ; Instructions Retired
8.        RDPMC ; EXCEPTION_PRIV_INSTRUCTION (0xC0000096)
9. safe_place:
10.        StdOutput =B"Sucessfully finished", Eol=yes
11.        TerminateProgram
12. handler:
13.        SUB RSP,8*(4+1) ; 0x0F8 is offset to CONTEXT64.Rip:
14.        mov [R8+0x0F8], safe_place, DATA=Q
15.        StdOutput =B"Instruction caused exception", Eol=yes
16.        XOR EAX,EAX
17.        ADD RSP,8*(4+1)
18.        retn
19. [.data]
20.        align 4 ; alignment is required
21. UNWIND DB 0x19,0,0,0 ; Hard coded for the moment
22.        DD RVA# handler
23.        DD 0
24. [.pdata] SEGMENT PURPOSE=EXCEPTION
25.        DD RVA# try
26.        DD RVA# safe_place
27.        DD RVA# UNWIND
28. ENDPROGRAM

Здесь есть три важных адреса: try — это то место, где может поплохеть, затем safe_place: — это там, где снова станет хорошо, и handler:, которое суть обработчик.
Чтобы сообщить операционной системе о том, как мы собираемся обрабатывать ошибку, служит секция [.pdata], туда занесены три адреса (по сути это RUNTIME_FUNCTION структура) — собственно критическое место и безопасное продолжение, а также адрес UNWIND_INFO структуры. Магическое число 0х19 образуется из трёх битов, где один отвечает за версию, а другие два говорят о том, что у нас есть есть SEH‑обработчик UNW_FLAG_EHANDLER с пользовательским обработчиком UNW_FLAG_UHANDLER. Следом идёт относительный адрес обработчика (тут все адреса относительные, поэтому RVA, это как раз добавилось в свежей версии этого ассемблера). Теперь, когда мы налетаем на грабли инструкцией RDPMC, ядро операционной системы первым делом просматривает таблицу обработчиков, если её нет, то программа аварийно завершается, а вот если есть, управление передаётся нашему обработчику handler:. Но это не просто передача управления, по сути под капотом идёт вызов функции с четырьмя параметрами, которые передаются согласно соглашению о вызовах Win64 ABI. Вот почему нам первой же командой нужно выравнивание стека на 4 параметра плюс один — это адрес возврата (можно и SUB RSP, 48 сделать, хуже не будет). Четыре параметра, которые нам передаются, берутся из вот такого прототипа

Код (C++):

1. typedef EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE) (
2.     IN PEXCEPTION_RECORD ExceptionRecord,
3.     IN ULONG64 EstablisherFrame,
4.     IN OUT PCONTEXT ContextRecord,
5.     IN OUT PDISPATCHER_CONTEXT DispatcherContext
6. );

Соответственно они передаются через регистры RCX, RDX, R8 и R9. Из всего этого нас интересует лишь структура PCONTEXT ContextRecord, адрес который лежит в R8, так как это третий параметр. Смещение 248 байт 0x0F8 — это поле RIP. А RIP это указатель адреса текущей инструкции. Именно сюда мы записываем адрес безопасного продолжения safe_place. Больше от нас ничего не требуется, мы выводим сообщение, что нас настигло исключение, сбрасываем код ошибки и восстанавливаем стек обратно. По выходу из процедуры обработчика исключения ядро выставит наш желаемый "безопасный" RIP, и мы выведем последнее сообщение. Вот и всё. На самом деле можно усложнить — например получить код исключения, и т.д.
Это как раз тот пример, когда ассемблер помогает понять механизм работы.
На этом можно было бы остановиться, но хотелось бы добавить, что код на ассемблере можно собрать и в DLL, которую вызвать из любого языка, который это допускает, начиная от Си и Питона и заканчивая Растом и LabVIEW, что открывает возможности для практического применения ассемблерного кода и интегрирования его в сторонние приложения.

DLL на ассемблере

Чтобы не усложнять, давайте просто сложим пару байтовых массивов, но используя SIMD.
Чтобы не усложнять, давайте просто сложим пару байтовых массивов, но используя SIMD инструкции, и вызовем полученную библиотеку, скажем из LabVIEW. Помимо очевидной замены РЕ на DLL нам потребуется занести нашу функцию в таблицу экспорта

Код (ASM):

1. EUROASM CPU=X64, SIMD=AVX2, AMD=ENABLED
2. AsmDLL64 PROGRAM FORMAT=DLL, MODEL=FLAT, WIDTH=64
3. EXPORT add_bytes_avx2
4. ; void add_bytes_avx2(const uint8_t* a,
5. ;                     const uint8_t* b,
6. ;                     uint8_t* c,
7. ;                     size_t n);
8. add_bytes_avx2 PROC
9.     test    r9, r9
10.     jz      done
11.     ; number of full 32-byte blocks
12.     mov     r10, r9
13.     shr     r10, 5            ; r10 = n / 32
14.     jz      tail
15. avx_loop:
16.     vmovdqu ymm0, [rcx]
17.     vmovdqu ymm1, [rdx]
18.     vpaddb  ymm0, ymm0, ymm1
19.     vmovdqu [r8], ymm0
20.     add     rcx, 32
21.     add     rdx, 32
22.     add     r8,  32
23.     dec     r10
24.     jnz     avx_loop
25. tail:
26.     ; remaining bytes
27.     and     r9, 31
28.     jz      done
29. tail_loop:
30.     mov     al, [rcx]
31.     add     al, [rdx]
32.     mov     [r8], al
33.     inc     rcx, rdx, r8
34.     dec     r9
35.     jnz     tail_loop
36. done:
37.     vzeroupper ; important for ABI
38.     ret
39. ENDP add_bytes_avx2
40. ENDPROGRAM AsmDLL64

И результат:

 

Вывод информации в консоль

Код (ASM):

1. EUROASM AutoSegment=Yes, CPU=X64, SIMD=AVX2
2. cvidemo PROGRAM Format=PE, Width=64, Model=Flat, IconFile=, Entry=main:
3. INCLUDE winscon.htm, winabi.htm, cpuext64.htm
4. WelcomeMsg D "Hello, CVI and EuroAssembler!",0
5. Buffer DB 80 * B
6. AnswerMsg D "EuroAsm: The Answer is ",0
7. main: nop
8.     StdOutput WelcomeMsg, Eol=Yes, Console=Yes ; standard EuroAsm Macro
9.     mov rax, 42
10.     StoD Buffer ; https://euroassembler.eu/maclib/cpuext64.htm#StoD
11.     StdOutput AnswerMsg, Buffer, Eol=Yes, Console=Yes
12. ; ...

используя Fmt и FmtOut функции из NI LabWindows / CVI. Все, что вам нужно, это создать ссылку против cvirt.lib, которая вызывает cvirte.dll во время выполнения:

Код (ASM):

1. EUROASM AutoSegment=Yes, CPU=X64, SIMD=AVX2
2. cvidemo PROGRAM Format=PE, Width=64, Model=Flat, IconFile=, Entry=main:
3. INCLUDE winscon.htm, winabi.htm, cpuext64.htm
4. FmtBuf DB 80 * B
5. FmtMsg D "CVI The Answer is %%d",13,10,0
6. FortyTwo DB D 42
7. LINK cvirt.lib ; For Fmt and FmtOut  
8. main: nop
9.     StdOutput WelcomeMsg, Eol=Yes, Console=Yes ; standard EuroAsm Macro  
10.     mov rax, 42
11.     WinABI FmtOut, FmtMsg, rax ; Direct Output to the Console
12.      WinABI FmtOut, FmtMsg, 42  ; From Constant
13.      WinABI FmtOut, FmtMsg, [FortyTwo] ; From Memory
14. ;...

это работает и с переменными с плавающей запятой:

Код (ASM):

1. FmtMsgF D "Float variable: %%f[p2] (Answer)",13,10,0
2. Numerator DO Q 42.0
3. Denominator DO Q 13.0
4. ;...
5.     mov rbx, 42
6.     mov rdx, 13
7.     movq xmm0, rbx ; movq xmm0, [numerator]
8.     movq xmm1, rdx ; movq xmm1, [denominator]
9.     divsd xmm0, xmm1
10.     WinABI FmtOut, FmtMsgF, xmm0 ; Float Point
11. ;...

Полный пример кода:

Код (ASM):

1. ;/==============================================================================
2. ;/
3. ;/ Title:        CVI Demo for Fmt and FmtOut Formatting Functions
4. ;/ Purpose:        How to call these from Assembly
5. ;/
6. ;/ Created on:    06.10.2025 at 11:32:43 by AD.
7. ;/
8. ;/==============================================================================
9. EUROASM AutoSegment=Yes, CPU=X64, SIMD=AVX2
10. cvidemo PROGRAM Format=PE, Width=64, Model=Flat, IconFile=, Entry=Start:
11. INCLUDE winscon.htm, winabi.htm, cpuext64.htm
12. WelcomeMsg D "Hello, CVI and EuroAssembler!",0
13. Buffer DB 80 * B
14. AnswerMsg D "EuroAsm: The Answer is ",0
15. FmtBuf DB 80 * B
16. FmtMsg D "CVI The Answer is %%d",13,10,0
17. FortyTwo DB D 42
18. FmtMsgF D "Float variable: %%f[p2] (Answer)",13,10,0
19. FmtMsgFO D "%%s<%%f[p1] Divided by %%f[p1] is %%f[p2]",13,10,0
20. Numerator DO Q 42.0
21. Denominator DO Q 13.0
22. InputNumerator D "Input Numerator (Float) :",0
23. InputDenominator D "Input Denominator (Float) :",0
24. BufferNumerator DB 80 * B
25. BufferDenominator DB 80 * B
26. ScanFmt D "%%s>%%f",0
27. ScanInFmt D "%%l>%%f",0
28. LINK cvirt.lib  
29. Start: nop
30. ;/==============================================================================
31. ;/ Standard EuroAssembler
32. ;/
33.     StdOutput WelcomeMsg, Eol=Yes, Console=Yes ; standard EuroAsm Macro
34.     mov rax, 42
35.     StoD Buffer ; https://euroassembler.eu/maclib/cpuext64.htm#StoD
36.     StdOutput AnswerMsg, Buffer, Eol=Yes, Console=Yes
37. ;/==============================================================================
38. ;/ CVI:
39. ;/
40.     WinABI Fmt, FmtBuf, FmtMsg, rax ; Fmt to Buffer
41.     StdOutput FmtBuf,  Console=Yes  ; Buffer Output
42.     mov rax, 42
43.     WinABI FmtOut, FmtMsg, rax ; Direct Output to the Console
44.      WinABI FmtOut, FmtMsg, 42  ; From Constant
45.      WinABI FmtOut, FmtMsg, [FortyTwo] ; From Memory
46. ;/==============================================================================
47. ;/ Float Point:
48. ;/
49.     mov rbx, 42
50.     mov rdx, 13
51.     movq xmm0, rbx ; movq xmm0, [numerator]
52.     movq xmm1, rdx ; movq xmm1, [denominator]
53.     divsd xmm0, xmm1
54.     WinABI FmtOut, FmtMsgF, xmm0 ; Float Point
55.     movq xmm0, [Numerator]
56.     movq xmm1, [Denominator]
57.     divsd xmm0, xmm1
58.     WinABI FmtOut, FmtMsgFO, [Numerator], [Denominator], xmm0
59.    
60. ;/==============================================================================
61. ;/ With Input from EuroAssembler:
62. ;/
63.     StdOutput InputNumerator, Console=Yes ; standard EuroAsm Macro
64.     StdInput BufferNumerator, Console=Yes
65.     WinABI Scan, BufferNumerator, ScanFmt, Numerator
66.     StdOutput InputDenominator, Console=Yes ; standard EuroAsm Macro
67.     StdInput BufferDenominator, Console=Yes
68.     WinABI Scan, BufferDenominator, ScanFmt, Denominator
69.     movq xmm0, [Numerator]
70.     movq xmm1, [Denominator]
71.     divsd xmm0, xmm1
72.     WinABI FmtOut, FmtMsgFO, [Numerator], [Denominator], xmm0
73. ;/==============================================================================
74. ;/ With Input from NI CVI:
75. ;/
76.     WinABI FmtOut, InputNumerator
77.     WinABI ScanIn, ScanInFmt, Numerator
78.     WinABI FmtOut, InputDenominator
79.     WinABI ScanIn, ScanInFmt, Denominator
80.     movq xmm0, [Numerator]
81.     movq xmm1, [Denominator]
82.     divsd xmm0, xmm1
83.     WinABI FmtOut, FmtMsgFO, [Numerator], [Denominator], xmm0
84.     TerminateProgram
85. ENDPROGRAM

Выход

>cvidemo.exe
Hello, CVI and EuroAssembler!
EuroAsm: The Answer is 42
CVI The Answer is 42
CVI The Answer is 42
CVI The Answer is 42
CVI The Answer is 42
Float variable: 3.23 (Answer)
42.0 Divided by 13.0 is 3.23
Input Numerator (Float) :1
Input Denominator (Float) :2
1.0 Divided by 2.0 is 0.50
Input Numerator (Float) :3
Input Denominator (Float) :4
3.0 Divided by 4.0 is 0.75