Измеряем тики под MSDOS в 64/32 bit mode.

max7C4
Так и здесь сам Бог велит написать - test al,1; jnz protect - фрагмент исполнится один раз. Быстродействие на втором плане, на первом - длина кода.

 

Memphis

Код (Text):

1. test al, 1;2 bytes (0xA8 0x01)
2. jnz protect;2 bytes/4 bytes (0x72 byte(protect-$+2)/0x820F word(protect-$+4))
3. or al, 1;2 bytes (0x0C 0x01)

итого от 6 до 8 байт в зависимости от положения метки protect

Код (Text):

1. bts ax, 0;4 bytes (0xBA0F 0xE8 0x00)
2. jc protect;2 bytes/4 bytes (0x72 byte(protect-$+2)/0x820F word(protect-$+4))

итого от 6 до 8 байт в зависимости от положения метки protect, а писать короче

 

max7C4
Опять неправильно. В мой код or al,1 приписали, а в ваш забыли. Мой код на 2+2 байта короче.
итого от 6 до 8 байт в зависимости от положения метки protect, а писать короче - и писать короче не получается.

В любом случае под досом остается - во вы уже и ошибки плодите в вашем коде:

Код (Text):

1. mov eax, cr0
2. bts eax, 0
3. jc already_in_PM
4. mov cr0, eax

Правильно так

Код (Text):

1. mov eax, cr0
2. bts eax, 0
3. jc already_in_PM
4. inc ax
5. mov cr0, eax

 

учите матчасть. bts проверяет и одновременно устанавливает бит
те

Код (Text):

1.                                        1
2.                                        v
3. eax:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
4.                                        v
5.                                        cf

 

max7C4
Неа, не буду. Я все равно напишу код короче вашего

Код (Text):

1. mov eax,cr0
2. test al,1
3. jnz protect
4. inc ax
5. mov cr0,eax

 

max7C4 и Memphis
Коллеги, очень приятно, что вы радеете о краткости и быстроте кода. А не хотите ли попробовать оптимизировать функцию memcpy из ядра Linux? IMHO, она не слишком оптимальна. Сможем коллективный патч сообразить? Вот ее 64-бит код:

Код (Text):

1. align 128
2. memcpy:
3.         mov rax,rdi
4.         mov ecx,edx
5.         shr ecx,6
6.         jz .Lhandle_tail
7.  
8. align 16
9. .Lloop_64:
10.         dec ecx
11.  
12.         mov r11,[rsi]
13.         mov r8,[rsi+8]
14.  
15.         mov [rdi],r11
16.         mov [rdi+1*8],r8
17.  
18.         mov r9,[rsi+2*8]
19.         mov r10,[rsi+3*8]
20.  
21.         mov [rdi+2*8],r9
22.         mov [rdi+3*8],r10
23.  
24.         mov r11,[rsi+4*8]
25.         mov r8,[rsi+5*8]
26.  
27.         mov [rdi+4*8],r11
28.         mov [rdi+5*8],r8
29.  
30.         mov r9,[rsi+6*8]
31.         mov r10,[rsi+7*8]
32.  
33.         mov [rdi+6*8],r9
34.         mov [rdi+7*8],r10
35.  
36.         lea rsi,[rsi+64]
37.         lea rdi,[rdi+64]
38.         jnz  .Lloop_64
39.  
40. .Lhandle_tail:
41.         mov ecx,edx
42.         and ecx,63
43.         shr ecx,3
44.         jz   .Lhandle_7
45. align 16
46. .Lloop_8:
47.         dec ecx
48.         mov r8,[rsi]
49.         mov [rdi],r8
50.         lea rdi,[rdi+8]
51.         lea rsi,[rsi+8]
52.         jnz  .Lloop_8
53.  
54. .Lhandle_7:
55.         mov ecx,edx
56.         and ecx,7
57.         jz .Lende
58. align 16
59. .Lloop_1:
60.         mov r8b,[rsi]
61.         mov [rdi],r8b
62.         inc rdi
63.         inc rsi
64.         dec ecx
65.         jnz .Lloop_1
66.  
67. .Lende:
68.         ret

Функция копирует EDX байт. RSI - source address. RDI -destination address. Функция возвращает в RAX исходный destination.
В исходниках ядра функция встречается 3700 раз. При загрузке ядра memcpy вызывается более миллиона раз.
Причем, в основном это пересылки небольших блоков. Максимальное число вызовов с RDX=7 - 380 тысяч.
Более подробную статистику закину сюда позже.

PS. Исходники можно взять на www.kernel.org Сама функция в файле memcpy_64.S