docs: маленькое пояснение к README

Вроде там еще надо будет что-то сравнить по быстродействию, это добавлю в будущих коммитах

01-asm-basics/README.md

@@ -2,119 +2,3 @@
 
 ## Введение в низкоуровневое программирование. Встроенный отладчик. Встроенный Ассемблер
 
-## Переписываем шаблон
-
-Поскольку весь шаблонный текст написан под MS-DOS, мы очевидным образом не можем его использовать для решения задачи под linux. 
-
-Замены требуют следующие функции:
-
-- getch
-- delay
-- inp
-- bioskey
-
-### getch
-
-Наиболее простая замена будет для `getch()`, поскольку единственное ее назначение - ожидать нажатия клавиши. В этом контексте у линукса есть полноценная замена в виде `system("pause")`
-
-### delay
-
-Здесь уже несколько посложнее, потому что DOS'овский `delay` использует задержку в миллисекундах, а линуксовый `sleep` - в секундах. Поэтому используем функцию `usleep`. Она принимает время задержки в микросекундах, поэтому для получения миллисекунда нужно просто умножить на 1000. То есть код:
-
-```C
-void delay(unsigned ms)
-{
-    usleep(ms * 1000);
-}
-```
-
-### bioskey
-
-Из всех пока что самая сложная замена. Если вызвать `bioskey(1)`, то она вытаст 1 если какая либо клавиша была нажата и 0 если не была. при этом проверка происходит в моменте и не блокирует выполнение программы.
-
-Для иммитации этого на линуксе нам потребуется неканонический режим ввода в терминал, а также сделать так, чтобы все печатаемое не выводилось в курсор. Этого можно добиться 2 способами: 
-
-1. Покурить гигагалактический томик по ассемблеру и узнать про системный вызов ioctl, после чего руками разметить область оперативной памяти, провести все системные вызовы, потом при помощи poll проверять наличие символов в буфере, обрабатывать ошибки и интегрировать функции через прототипы в наш код на C
-2. Сдаться и выбрать путь языка C
-
-Я уже сказал, что я из слабых, поэтому писать кусок на ассемблере как-то не горю желанием (хотя может когда-нибудь в будущем по просьбам напишу)
-
-#### Зависимости
-
-Язык программирования C имеет определенный уровень абстракции от конкретных системных вызовов и предоставляет нам несколько вещей:
-
-- `<termios.h>` - структура данных, хранящая информацию о текущем состоянии терминала, а также удобные методы `tcgetattr` и `tcsetattr`
-- `<unistd.h>` - Библиотека, используемая для унификации дескрипторов, битов и прочих унификаций
-- `<stdlib.h>` - много чего, но нам для безопасности потребуется `atexit`, чтобы если что-то пошло не так, у нас не наебнулся терминал
-
-Опционально берется `<stdio.h>` для целей адекватного вывода ошибок. Не обязательно, но предпочтительно
-
-#### Реализация
-
-Для начала нам необходимо сохранить свой текущий терминал, чтобы без проблем его восстановить в будущем, для этого заводим в памяти переменную (придется сделать ее глобальной, потому что на инкапсуляцию и защиту нет времени, нервов и желания)
-
-```C
-struct termios saved_attributes;
-```
-
-Далее сразу напишем функцию для восстановления
-
-```C
-void reset_input_mode()
-{
-  tcsetattr (STDIN_FILENO, TCSANOW, &saved_attributes);
-}
-```
-
-Здесь `STDIN_FILENO` - это дескриптор потока стандартного ввода (ввод с консоли по простяге). Вообще это число, но в `<unistd.h>` он вынесен в макрос для хоть какой-то унификации, `TCSANOW` - тоже число. В контексте функции `tcsetattr` оно заставляет изменениям в формате терминала вступить в силу немедленно, вне зависимости от того, есть ли еще в буфере текст на вывод. Другими вариантами могут стать:
-
-- `TCSANOW` - применить изменения сразу при сигнале и продолжать предыдущий вывод с того же места, где он кончился
-- `TCSADRAIN` - заставит сначала очистить текущий буфер вывода до дна, а только потом сменит режим. То есть сначала все, что было на момент запроса в буфере, будет выведено, а только потом сменится режим терминала
-- `TCSAFLUSH` - то же, что и `TCSADRAIN`, только еще и сносит весь буффер ввода
-
-```C
-void set_input_mode()
-{
-  struct termios tattr;
-  char *name;
-
-  // Убеждаемся, что STDIN - это терминал
-  if (!isatty (STDIN_FILENO))
-    {
-      fprintf (stderr, "Not a terminal.\n");
-      exit (EXIT_FAILURE);
-    }
-
-  // Сохраняем параметры текущего терминала 
-  //для последующего восстановления
-  tcgetattr (STDIN_FILENO, &saved_attributes);
-  atexit (reset_input_mode);
-
-  // Устанавливаем все режимы, которые
-  // нас в общем-то интересуют
-  tcgetattr (STDIN_FILENO, &tattr);
-  tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
-  tattr.c_cc[VMIN] = 0;
-  tattr.c_cc[VTIME] = 0;
-  tcsetattr (STDIN_FILENO, TCSAFLUSH, &tattr);
-}
-```
-
-## Исправление ассемблерных вставок
-
-Должен сказать, что я не большой поклонник "inline assembly". На мой субъективный взгляд намного лучше, читаемее и стабильнее добавлять ассемблер на этапе линковки. Это дает несколько приятных бонусов:
-
-1. Код можно поддерживать на любимом ассемблере
-2. Код ассемблера можно компилить отдельно
-3. Код программы на C становится ощутимо чище (*лично на мой взгляд ассемблерные вставки плохо смотрятся в коде*), а также все макросы ассемблера не касаются кода на C
-4. Меньше потенциальных ошибок из-за того, что вы что-то не так поняли и откомпилировалось все неправильно
-
-Помимо прочего очень важный момент: я использую gcc для компиляции, а в отличие от clang, он довольно ленивый и наши строки для ассемблера в нетронутом виде отправятся прямо в текст программы, которая затем будет скормлена ассемблеру. Отсюда следует несколько нюансов:
-
-- Стандартный ассемблер, используемый `gcc` - `as` и по умолчанию он использует синтаксис AT&T. Однако я не очень люблю этот синтаксис, предпочитаю работать с синтаксисом intel. Выхода тут 2:
-    - Дать компилятору флаг -masm=intel, после чего уже собственный ассемблер переключится на intel синтаксис
-    - В начале каждой ассемблерной вставки ставить ".intel_syntax noprefix", а после вставки но перед параметрами ставить ".att_syntax prefix". Это может периодически плохо работать
-- При написании ассемблера необходимо соблюдать все переносы строк и при этом указывать это явно (поэтому в конце строк у меня и появляются `\n\t` - это поддержание табуляции и переноса строки
-- Компилятору надо понимать, что будет происходить с переменными и регистрами во время ассемблерной вставки, поэтому и это тоже придется указать отдельно
-
-Собственно видно, что есть ньансы, которые и заставляют меня сделать выбор в пользу обычного ассемблера и линковки, но раз лаба хочет, чтобы использовался именно inline, то будем использовать inline

01-asm-basics/main.c

@@ -1,114 +0,0 @@
-#include <stdio.h>
-#include <sys/io.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "substitutions.h"
-
-#define PortCan0 0x40
-
-void beep(unsigned iTone, unsigned iDlit);
-
-void delay(unsigned int ms)
-{
-  usleep(ms * 1000);
-}
-
-int main(void) {
-
-  long int lCnt = 0;
-  int iA = 0x1234;
-
-  char *pT = (char *)0x46C;
-  printf("\nПечатаем 10 раз значение байта с известным адресом\n");
-  for (int i = 0; i < 10; i++)
-  {
-    printf(" \n  %d ", *pT);
-  }
-  printf("\n Для продолжения нажмите любую клавишу \n");
-  system("pause"); // Ждем нажатия клавиши
-
-  printf("\n Читаем содержимое порта с адресом 40 с помощью функции Си \n");
-  printf("\n Для выхода из цикла - нажмите любую клавишу \n");
-
-  // Линуксу не сильно нравится, что ты насилуешь порты ввода и вывода процессора, поэтому нужно выдать ему на это дело разрешение
-
-  ioperm(PortCan0, 1, 3); // Что означает тройка напишу позже
-  set_input_mode();
-  while (isKeyPressed() == 0) {
-    printf("\n Порт40 = %d", inb(PortCan0));
-    delay(500);
-  }
-  reset_input_mode();
-
-  system("pause");
-  printf("\n Читаем содержимое порта с адресом 40 ассемблером \n");
-
-  set_input_mode();
-  while (isKeyPressed() == 0) {
-    asm { 
-     push ax    
-     in al,0x40
-    }
-    unsigned char Tmm = _AL;
-    asm pop ax
-    delay(500);
-    printf("\n Порт40 = %d", Tmm);
-  }
-  reset_input_mode();
-  system("pause");
-  printf("\n Для продолжения - нажмите любую клавишу \n");
-  system("pause");
-
-  long *pTime = (long *)0x46C;
-  set_input_mode();
-  while (isKeyPressed() == 0) {
-    printf("\n %ld", *pTime);
-    delay(1000);
-  }
-  reset_input_mode();
-  system("pause");
-
-  int Time;
-  set_input_mode();
-  while (isKeyPressed() == 0) {
-    asm push ds
-    asm push si
-    asm mov ax, 40h
-    asm mov ds, ax
-    asm mov si, 0x6C
-    asm mov ax, [ds : si]
-    asm mov Time, ax
-    asm pop si
-    asm pop ds
-
-    printf("\n %d", Time);
-    delay(300);
-  }
-  reset_input_mode();
-
-  beep(400, 200);
-  for (lCnt = 0; lCnt < 1000000; lCnt++) {
-  a1:
-    asm { 
-      mov ax,iA
-      mov ax,iA
-      mov ax,iA
-      mov ax,iA
-      mov ax,iA
-      mov ax,iA
-      mov ax,iA
-      mov ax,iA
-      mov ax,iA
-    a2:
-      mov ax,iA
-      }
-  }
-  beep(400, 200);
-}
-
-//void beep(unsigned iTone, unsigned iDlit) {
-//  sound(iTone);
-//  delay(iDlit);
-//  nosound();
-//}

01-asm-basics/substitutions.c

@@ -1,61 +0,0 @@
-#include "substitutions.h"
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <termios.h>
-
-/* Use this variable to remember original terminal attributes. */
-
-struct termios saved_attributes;
-
-void reset_input_mode()
-{
-  tcsetattr (STDIN_FILENO, TCSANOW, &saved_attributes);
-}
-
-void set_input_mode()
-{
-  struct termios tattr;
-  char *name;
-
-  /* Make sure stdin is a terminal. */
-  if (!isatty (STDIN_FILENO))
-    {
-      fprintf (stderr, "Not a terminal.\n");
-      exit (EXIT_FAILURE);
-    }
-
-  /* Save the terminal attributes so we can restore them later. */
-  tcgetattr (STDIN_FILENO, &saved_attributes);
-  atexit (reset_input_mode);
-
-  /* Set the funny terminal modes. */
-  tcgetattr (STDIN_FILENO, &tattr);
-  tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
-  tattr.c_cc[VMIN] = 1;
-  tcsetattr (STDIN_FILENO, TCSAFLUSH, &tattr);
-}
-
-void delay(unsigned int ms)
-{
-  usleep(ms * 1000);
-}
-
-char isKeyPressed()
-{
-  char key_handler = 0;
-  read(STDIN_FILENO, &key_handler, 1);
-  if (key_handler > 0)
-  {
-    return 1;
-  }
-  return 0;
-}
-
-//int main()
-//{
-//  set_input_mode();
-//  while (isKeyPressed() == 0) {}
-//  printf("ok");
-//  reset_input_mode();
-//}

01-asm-basics/substitutions.h

@@ -1,9 +0,0 @@
-#ifndef SUBSTITUTIONS_H
-#define SUBSTITUTIONS_H
-
-void reset_input_mode();
-void set_input_mode();
-void delay(unsigned int ms);
-char isKeyPressed();
-
-#endif

01-asm-basics/time.asm

@@ -0,0 +1,67 @@
+global main
+
+extern printf
+
+%define CLOCK_REALTIME 0
+
+; struct timespec { time_t tv_sec; long tv_nsec; }
+struc timespec
+  .tv_sec: resq 1
+  .tv_nsec: resq 1
+endstruc
+
+section .note.GNU-stack ; чтобы не жаловался линкер
+
+section .bss
+
+start: ; uses timespec model
+  times 2 resq 1
+
+finish:
+  times 2 resq 1
+
+section .data
+
+  fstring db "Operations took %ul seconds and %ul milliseconds", 10, 0
+  flen equ $-fstring
+
+section .text
+
+main: ; лично в моей системе time_t представляет из себя long int
+  mov rax, 228 ; Системный вызов получения времени
+  mov rdi, CLOCK_REALTIME
+  mov rsi, start
+  syscall
+
+  ; insert your code here
+  mov rcx, 20000
+
+  looper:
+  mov rax, start
+  loop looper
+
+  mov rax, 228
+  mov rdi, CLOCK_REALTIME
+  mov rsi, finish
+  syscall
+
+  ; считаем время для секунда и миллисекунд
+  ; секунды
+  mov rsi, [finish + timespec.tv_sec]
+  sub rsi, [start + timespec.tv_sec]
+
+  ; миллисекунды
+  mov rdx, [finish + timespec.tv_nsec]
+  sub rdx, [start + timespec.tv_nsec]
+
+  mov rdi, fstring
+  mov rax, 0
+  sub rsp, 8
+  call printf
+  add rsp, 8
+
+exit:
+  mov rax, 60
+  mov rdi, 0
+  syscall
+

03-asm-bios/Makefile

@@ -0,0 +1,13 @@
+ASM = nasm
+ASM_FLAGS = -felf64 -g
+LINK = ld
+
+%: %.o
+	$(LINK) -o $@ $^
+
+%.o: %.asm
+	$(ASM) $(ASM_FLAGS) $^ -o $@
+
+clean:
+	rm -f *.o
+	rm -f $(subst .asm, $(empty), $(wildcard *.asm))

04-addr-methods/Makefile

@@ -0,0 +1,24 @@
+ASM = nasm
+CXX = gcc
+CXX_FLAGS = -Og -static
+ASM_FLAGS = -felf64 -g
+LINK = ld
+
+task3: task3_c.o task3.o
+	$(CXX) -Og $^ -o $@ -g
+
+task3_c.o: task3.c
+	$(CXX) -Og -c $^ -o $@ -g
+
+task2: task2.o
+	$(CXX) $(CXX_FLAGS) $^ -o $@
+
+%: %.o
+	$(LINK) -o $@ $^
+
+%.o: %.asm
+	$(ASM) $(ASM_FLAGS) $^ -o $@
+
+clean:
+	rm -f *.o
+	rm -f $(subst .asm, $(empty), $(wildcard *.asm))

04-addr-methods/README.md

@@ -1,4 +1,4 @@
 # Лабораторная работа 4
 
-## Способы адресации и сегментная организация памяти
+На данный момент нормального README не будет, потому что у меня немного нет времени его офомить. Как только сдам лабу - напишу тут немного больше
 

04-addr-methods/task1.asm

@@ -0,0 +1,33 @@
+ global _start
+
+ section .data
+
+  %macro FILL_ASC 1
+  %assign NUM 0
+  %rep %1
+  db NUM
+  %assign NUM NUM + 1
+  %endrep
+  %endmacro
+
+  example: FILL_ASC 256
+
+ section .text
+
+ _start:
+  ; В качестве базы возьму inc
+  ; регистровая
+  inc ecx
+  mov rax, example
+  ; косвенно-регистровая
+  inc byte [rax]
+  ; "Индексно-базовая", хотя у меня почти все может быть базой
+  inc byte [rax + rbx]
+  ; "Индексно-базовая" со смещением
+  inc byte [rax + rbx + 122]
+
+  ; Ну в целом... все
+  mov rax, 60
+  mov rdi, 0
+  syscall
+  

04-addr-methods/task2.asm

@@ -0,0 +1,139 @@
+global main
+
+extern printf
+
+struc timespec ; структура, в которой линукс хранит время. Тут нужна для удобства в будущем
+  .tv_sec: resq 1
+  .tv_nsec: resq 1
+endstruc
+
+%include "timer.inc"
+
+section .note.GNU-stack
+
+section .data
+  example: times 128 db 127
+
+section .bss
+  ; uses timespec model 
+  start:      resq 2
+  finish:     resq 2
+  deltatime:  resq 2
+
+section .text
+
+%macro PUSH_M 1-*
+  %rep %0
+  push %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro RPOP_M 1-*
+  %rotate -1
+  %rep %0
+  pop %1
+  %rotate -1
+  %endrep
+%endmacro
+
+%define CLOCK_REALTIME 0
+%macro TIME_1_000_000 0-1+ ; принимает команду, которую будет пытаться обмерить по времени
+  PUSH_M rax, rdi, rsi, rcx
+  mov rax, 228 ; Время начала
+  mov rdi, CLOCK_REALTIME
+  mov rsi, start
+  syscall
+  RPOP_M rax, rdi, rsi, rcx
+
+  mov rcx, 10000000000; выполняем миллион раз
+  %%loop:
+  %1
+  loop %%loop
+
+  PUSH_M rax, rdi, rsi, rcx
+  mov rax, 228 ; Время конца
+  mov rdi, CLOCK_REALTIME
+  mov rsi, finish
+  syscall
+  RPOP_M rax, rdi, rsi, rcx
+  
+  ; считаем секунды
+  push rax ; можно было бы оптимизировать, но мне лень макросы переписывать
+  mov rax, [finish + timespec.tv_sec]
+  sub rax, [start + timespec.tv_sec]
+  mov [deltatime + timespec.tv_sec], rax
+
+  ; считаем наносекунды
+  mov rax, [finish + timespec.tv_nsec]
+  sub rax, [start + timespec.tv_nsec]
+  jns %%save_result
+  dec qword [deltatime + timespec.tv_sec] ; занимаем миллиард наносекунд
+  add rax, 1000000000 ; прибавляем занятый разряд
+  %%save_result:
+  mov [deltatime + timespec.tv_nsec], rax
+  pop rax
+%endmacro
+
+%macro PRINT_DELTATIME 1
+  ;sub rsp, 8
+  mov rdi, str_template
+  mov rsi, %1
+  mov rdx, [deltatime + timespec.tv_sec]
+  mov rcx, [deltatime + timespec.tv_nsec]
+  call printf
+  ;add rsp, 8
+%endmacro
+
+main:
+  push rbp
+  mov rbp, rsp
+  sub rsp, 16
+  xor rax, rax ; поскольку приходим сюда из компилятора, лучше обнулить
+  TIME_1_000_000 
+  PRINT_DELTATIME nop_command
+
+  TIME_1_000_000 inc rax
+  PRINT_DELTATIME reg_command
+
+  mov rax, example
+  TIME_1_000_000 inc byte [rax]
+  PRINT_DELTATIME rel_reg
+
+  mov rax, example
+  xor rbx, rbx
+  TIME_1_000_000 inc byte [rax + rbx]
+  PRINT_DELTATIME ind_base
+
+  mov rax, example
+  xor rbx, rbx
+  TIME_1_000_000 inc byte [rax + rbx + 122]
+  PRINT_DELTATIME ind_base_disp
+
+  ; Под конец давайте посчитаем тактовую частоту на примере той же самой команды
+  rdtsc
+  mov [rbp - 4], edx
+  mov [rbp - 8], eax
+  mov rcx, 10000000000
+  mov rax, example
+  xor rbx, rbx
+  .loop:
+  inc byte [rax + rbx + 122]
+  loop .loop
+  rdtsc
+  sub eax, [rbp - 8]
+  sbb edx, [rbp - 4]
+  mov [rbp - 8], eax
+  mov [rbp - 4], edx
+  
+  mov [rbp - 16], rsp
+  and rsp, -16
+  mov rdi, tick_count
+  mov rsi, [rbp - 8]
+  call printf
+
+  mov rsp, rbp
+  pop rbp
+  xor rax, rax ; сообщаем gcc, что все закончилось успешно
+  ret
+

04-addr-methods/task3.asm

@@ -0,0 +1,96 @@
+global fill_arr1
+global fill_arr2
+
+section .note.GNU-stack
+
+section .text
+
+%macro PUSH_M 1-*
+  %rep %0
+  push %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro RPOP_M 1-*
+  %rotate -1
+  %rep %0
+  pop %1
+  %rotate -1
+  %endrep
+%endmacro
+
+fill_arr1:
+  push rbp
+  mov rbp, rsp
+  PUSH_M rdi, rsi, rdx
+  ; Вычисляем сколько числе в строке
+  mov rax, [rbp - 16]
+  xor rdx, rdx
+  div qword [rbp - 24]
+  push rax ; сохраняем в локальные переменные. rbp - 32
+  ; Вычисляем сколько проходов цикла необходимо
+  mov rax, [rbp - 24]
+  xor rdx, rdx
+  mov rcx, 2
+  div rcx
+  push rax ; rbp-40
+
+  ; Надеюсь rdi не успел поменяться
+  ; заполняем память
+  push rbx
+  mov rbx, [rbp - 32]
+  mov rcx, [rbp - 40]
+  mov rax, 777 ; специально такое число, чтобы выделялось
+  .next_row:
+  push rcx
+  mov rcx, [rbp - 32]
+  rep stosd
+  lea rdi, [rdi + 4 * rbx] ; пропускаем строку
+  pop rcx
+  loop .next_row
+  pop rbx
+
+  add rsp, 16 ; чистим 2 доп переменные, образовавшиеся в процессе вычислений
+  RPOP_M rdi, rsi, rdx
+  pop rbp
+  ret
+
+fill_arr2:
+  push rbp
+  mov rbp, rsp
+  PUSH_M rdi, rsi, rdx
+  ; Вычисляем сколько числе в строке
+  mov rax, [rbp - 16]
+  xor rdx, rdx
+  div qword [rbp - 24]
+  push rax ; сохраняем в локальные переменные. rbp - 32
+  ; Вычисляем сколько проходов цикла необходимо
+  mov rax, [rbp - 24]
+  xor rdx, rdx
+  mov rcx, 2
+  div rcx
+  push rax ; rbp-40
+
+  ; Надеюсь rdi не успел поменяться
+  ; заполняем память
+  push rbx
+  mov rbx, [rbp - 32]
+  mov rcx, [rbp - 40]
+  mov rax, 777 ; специально такое число, чтобы выделялось
+  .next_row:
+  push rcx
+  mov rcx, [rbp - 32]
+  .fill:
+  mov [rdi], rax
+  lea rdi, [rdi + 4]
+  loop .fill
+  lea rdi, [rdi + 4 * rbx] ; пропускаем строку
+  pop rcx
+  loop .next_row
+  pop rbx
+
+  add rsp, 16 ; чистим 2 доп переменные, образовавшиеся в процессе вычислений
+  RPOP_M rdi, rsi, rdx
+  pop rbp
+  ret

04-addr-methods/task3.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <time.h>
+
+extern void fill_arr1(int* arr, size_t size, size_t row_count);
+extern void fill_arr2(int* arr, size_t size, size_t row_count);
+
+double measure_fill_time(void(*function)(int*, size_t, size_t), int* arr, size_t size, size_t row_count)
+{
+  const size_t times = 10000000;
+  clock_t begin = clock();
+  for (size_t i = 0; i < times; i++)
+  {
+    function(arr, size, row_count);
+  }
+  clock_t end = clock();
+  return (double)(end - begin)/(CLOCKS_PER_SEC);
+}
+
+int main()
+{
+  const int arr_size = 256;
+  int array1[arr_size];
+
+  printf("String methods took %fs to loop 10,000,000 times\n", measure_fill_time(fill_arr1, array1, arr_size, 16));
+
+  for (size_t i = 0; i < arr_size; i++)
+  {
+    printf("%d ", array1[i]);
+  }
+  printf("\b \n");
+
+  int array2[arr_size];
+
+  printf("Lea methods took %fs on to loop 10,000,000 times\n", measure_fill_time(fill_arr2, array2, arr_size, 16));
+  for (size_t i = 0; i < arr_size; i++)
+  {
+    printf("%d ", array2[i]);
+  }
+  printf("\b \n");
+  
+  return 0;
+}
+

04-addr-methods/timer.inc

@@ -0,0 +1,13 @@
+
+section .data
+  str_template: db "Command %s took %lld seconds and %lld nanoseconds to execute 1 000 000 000 times", 10, 0
+  template_len equ $-str_template
+
+  nop_command:        db '`empty loop`', 0
+  reg_command:        db '`inc ebx`', 0
+  rel_reg:            db '`inc byte [rax]`', 0
+  ind_base:           db '`inc byte [rax + rbx]`', 0
+  ind_base_disp:      db '`inc byte [rax + rbx + 122]`', 0
+
+  tick_count:         db 'Last command also took %lli ticks to complete', 10, 0
+