我正在学习汇编程序很长一段时间，我正在尝试重写一些简单的程序\函数来查看性能优势（如果有的话）。我的主要开发工具是 Delphi 2007，第一个示例将使用该语言，但它们也可以轻松翻译成其他语言。
问题陈述为：
我们给出了一个无符号字节值，其中八位中的每一位代表屏幕一行中的一个像素。每个单个像素可以是实心 (1) 或透明 (0)。换句话说，我们将 8 个像素打包在一个字节值中。我想以最年轻的像素（位）将落在数组的最低索引下的方式将这些像素解压缩到一个八字节数组中，依此类推。这是一个例子：
One byte value -----------> eight byte array
10011011 -----------------> [1][1][0][1][1][0][0][1]
Array index number -------> 0 1 2 3 4 5 6 7
下面我介绍五种解决问题的方法。接下来我将展示他们的时间比较以及我是如何测量这些时间的。
我的问题包括两部分：
1.
我要求您详细回答有关方法DecodePixels4a和DecodePixels4b. 为什么方法4b比4a?
例如，如果由于我的代码未正确对齐而导致速度较慢，那么请告诉我给定方法中的哪些指令可以更好地对齐，以及如何做到这一点以不破坏该方法。
我想看看理论背后的真实例子。请记住，我正在学习汇编，我想从您的答案中获得知识，这使我将来能够编写更好的优化代码。
2.
你能写出比 更快的例程DecodePixels4a吗？如果是这样，请展示它并描述您已采取的优化步骤。更快的例程是指在此处介绍的所有例程中在您的测试环境中运行时间最短的例程。
允许使用所有英特尔系列处理器以及与之兼容的处理器。
下面你会发现我写的例程：
procedure DecodePixels1(EncPixels: Byte; var DecPixels: TDecodedPixels);
var
i3: Integer;
begin
DecPixels[0] := EncPixels and $01;
for i3 := 1 to 7 do
begin
EncPixels := EncPixels shr 1;
DecPixels[i3] := EncPixels and $01;
//DecPixels[i3] := (EncPixels shr i3) and $01; //this is even slower if you replace above 2 lines with it
end;
end;
//Lets unroll the loop and see if it will be faster.
procedure DecodePixels2(EncPixels: Byte; var DecPixels: TDecodedPixels);
begin
DecPixels[0] := EncPixels and $01;
EncPixels := EncPixels shr 1;
DecPixels[1] := EncPixels and $01;
EncPixels := EncPixels shr 1;
DecPixels[2] := EncPixels and $01;
EncPixels := EncPixels shr 1;
DecPixels[3] := EncPixels and $01;
EncPixels := EncPixels shr 1;
DecPixels[4] := EncPixels and $01;
EncPixels := EncPixels shr 1;
DecPixels[5] := EncPixels and $01;
EncPixels := EncPixels shr 1;
DecPixels[6] := EncPixels and $01;
EncPixels := EncPixels shr 1;
DecPixels[7] := EncPixels and $01;
end;
procedure DecodePixels3(EncPixels: Byte; var DecPixels: TDecodedPixels);
begin
asm
push eax;
push ebx;
push ecx;
mov bl, al;
and bl, $01;
mov [edx], bl;
mov ecx, $00;
@@Decode:
inc ecx;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + ecx], bl;
cmp ecx, $07;
jnz @@Decode;
pop ecx;
pop ebx;
pop eax;
end;
end;
//Unrolled assembly loop
procedure DecodePixels4a(EncPixels: Byte; var DecPixels: TDecodedPixels);
begin
asm
push eax;
push ebx;
mov bl, al;
and bl, $01;
mov [edx], bl;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + $01], bl;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + $02], bl;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + $03], bl;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + $04], bl;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + $05], bl;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + $06], bl;
shr al, $01;
mov bl, al;
and bl, $01;
mov [edx + $07], bl;
pop ebx;
pop eax;
end;
end;
// it differs compared to 4a only in switching two instructions (but seven times)
procedure DecodePixels4b(EncPixels: Byte; var DecPixels: TDecodedPixels);
begin
asm
push eax;
push ebx;
mov bl, al;
and bl, $01;
shr al, $01; //
mov [edx], bl; //
mov bl, al;
and bl, $01;
shr al, $01; //
mov [edx + $01], bl; //
mov bl, al;
and bl, $01;
shr al, $01; //
mov [edx + $02], bl; //
mov bl, al;
and bl, $01;
shr al, $01; //
mov [edx + $03], bl; //
mov bl, al;
and bl, $01;
shr al, $01; //
mov [edx + $04], bl; //
mov bl, al;
and bl, $01;
shr al, $01; //
mov [edx + $05], bl; //
mov bl, al;
and bl, $01;
shr al, $01; //
mov [edx + $06], bl; //
mov bl, al;
and bl, $01;
mov [edx + $07], bl;
pop ebx;
pop eax;
end;
end;
这是我如何测试它们：
program Test;
{$APPTYPE CONSOLE}
uses
SysUtils, Windows;
type
TDecodedPixels = array[0..7] of Byte;
var
Pixels: TDecodedPixels;
Freq, TimeStart, TimeEnd :Int64;
Time1, Time2, Time3, Time4a, Time4b: Extended;
i, i2: Integer;
begin
if QueryPerformanceFrequency(Freq) then
begin
for i2 := 1 to 100 do
begin
QueryPerformanceCounter(TimeStart);
for i := 1 to 100000 do
DecodePixels1(155, Pixels);
QueryPerformanceCounter(TimeEnd);
Time1 := Time1 + ((TimeEnd - TimeStart) / Freq * 1000);
QueryPerformanceCounter(TimeStart);
for i := 1 to 100000 do
DecodePixels2(155, Pixels);
QueryPerformanceCounter(TimeEnd);
Time2 := Time2 + ((TimeEnd - TimeStart) / Freq * 1000);
QueryPerformanceCounter(TimeStart);
for i := 1 to 100000 do
DecodePixels3(155, Pixels);
QueryPerformanceCounter(TimeEnd);
Time3 := Time3 + ((TimeEnd - TimeStart) / Freq * 1000);
QueryPerformanceCounter(TimeStart);
for i := 1 to 100000 do
DecodePixels4a(155, Pixels);
QueryPerformanceCounter(TimeEnd);
Time4a := Time4a + ((TimeEnd - TimeStart) / Freq * 1000);
QueryPerformanceCounter(TimeStart);
for i := 1 to 100000 do
DecodePixels4b(155, Pixels);
QueryPerformanceCounter(TimeEnd);
Time4b := Time4b + ((TimeEnd - TimeStart) / Freq * 1000);
end;
Writeln('Time1 : ' + FloatToStr(Time1 / 100) + ' ms. <- Delphi loop.');
Writeln('Time2 : ' + FloatToStr(Time2 / 100) + ' ms. <- Delphi unrolled loop.');
Writeln('Time3 : ' + FloatToStr(Time3/ 100) + ' ms. <- BASM loop.');
Writeln('Time4a : ' + FloatToStr(Time4a / 100) + ' ms. <- BASM unrolled loop.');
Writeln('Time4b : ' + FloatToStr(Time4b / 100) + ' ms. <- BASM unrolled loop instruction switch.');
end;
Readln;
end.
以下是我的机器（Win32 XP 上的 Intel® Pentium® E2180）的结果：
Time1 : 1,68443549919493 ms. <- Delphi loop.
Time2 : 1,33773024572211 ms. <- Delphi unrolled loop.
Time3 : 1,37015271374424 ms. <- BASM loop.
Time4a : 0,822916962526627 ms. <- BASM unrolled loop.
Time4b : 0,862914462301607 ms. <- BASM unrolled loop instruction switch.
结果非常稳定 - 我所做的每次测试之间的时间变化只有几个百分点。这总是正确的：Time1 > Time3 > Time 2 > Time4b > Time4a
所以我认为 Time4a 和 Time4b 之间的差异取决于方法中的指令切换DecodePixels4b。有时是 4%，有时是 10%，但4b总是慢于4a.
我正在考虑另一种使用 MMX 指令一次将八个字节写入内存的方法，但我无法找到将字节解压到 64 位寄存器中的快速方法。
感谢您的时间。
谢谢你们的宝贵意见。虽然我可以同时回答你们所有人，但不幸的是，与现代 CPU 相比，我只有一个“管道”并且当时只能执行一条指令“回复”;-) 所以，我会尝试总结一些事情在这里并在你的答案下写下额外的评论。
首先，我想说的是，在发布我的问题之前，我想出了 Wouter van Nifterick 提出的解决方案，它实际上比我的汇编代码慢得多。所以我决定不在这里发布该例程，但您可能会看到我在我的循环 Delphi 版本的例程中也采用了相同的方法。它在那里被评论是因为它给了我更糟糕的结果。
这对我来说是个谜。我用 Wouter 和 PhilS 的例程再次运行了我的代码，结果如下：
Time1 : 1,66535493194387 ms. <- Delphi loop.
Time2 : 1,29115785420688 ms. <- Delphi unrolled loop.
Time3 : 1,33716934524107 ms. <- BASM loop.
Time4a : 0,795041753757838 ms. <- BASM unrolled loop.
Time4b : 0,843520166815013 ms. <- BASM unrolled loop instruction switch.
Time5 : 1,49457681191307 ms. <- Wouter van Nifterick, Delphi unrolled
Time6 : 0,400587402866258 ms. <- PhiS, table lookup Delphi
Time7 : 0,325472442519827 ms. <- PhiS, table lookup Delphi inline
Time8 : 0,37350491544239 ms. <- PhiS, table lookup BASM
看看Time5的结果，是不是很奇怪？我想我有不同的 Delphi 版本，因为我生成的汇编代码与 Wouter 提供的不同。
第二次重大修改：
我知道为什么5我的机器上的例行程序变慢了。我在编译器选项中检查了“范围检查”和“溢出检查”。我已经assembler在例程9中添加了指令，看看它是否有帮助。使用这个指令汇编程序似乎与 Delphi 内联变体一样好，甚至稍微好一点。
以下是最终结果：
Time1 : 1,22508325749317 ms. <- Delphi loop.
Time2 : 1,33004145373084 ms. <- Delphi unrolled loop.
Time3 : 1,1473583622526 ms. <- BASM loop.
Time4a : 0,77322594033463 ms. <- BASM unrolled loop.
Time4b : 0,846033593023372 ms. <- BASM unrolled loop instruction switch.
Time5 : 0,688689382044384 ms. <- Wouter van Nifterick, Delphi unrolled
Time6 : 0,503233741036693 ms. <- PhiS, table lookup Delphi
Time7 : 0,385254722925063 ms. <- PhiS, table lookup Delphi inline
Time8 : 0,432993919452751 ms. <- PhiS, table lookup BASM
Time9 : 0,362680491244212 ms. <- PhiS, table lookup BASM with assembler directive
第三次重大修改：
在@Pascal Cuoq和@j_random_hacker 看来，例程4a之间执行时间的差异是由数据依赖性引起的。但是，基于我所做的进一步测试，我不得不不同意这种观点。4b5
我还发明了4c基于4a. 这里是：
procedure DecodePixels4c(EncPixels: Byte; var DecPixels: TDecodedPixels);
begin
asm
push ebx;
mov bl, al;
and bl, 1;
mov [edx], bl;
mov bl, al;
shr bl, 1;
and bl, 1;
mov [edx + $01], bl;
mov bl, al;
shr bl, 2;
and bl, 1;
mov [edx + $02], bl;
mov bl, al;
shr bl, 3;
and bl, 1;
mov [edx + $03], bl;
mov bl, al;
shr bl, 4;
and bl, 1;
mov [edx + $04], bl;
mov bl, al;
shr bl, 5;
and bl, 1;
mov [edx + $05], bl;
mov bl, al;
shr bl, 6;
and bl, 1;
mov [edx + $06], bl;
shr al, 7;
and al, 1;
mov [edx + $07], al;
pop ebx;
end;
end;
我会说它非常依赖数据。
这是测试和结果。我做了四次测试以确保没有意外。我还为 GJ (Time10a, Time10b) 提出的例程添加了新的时间。
Test1 Test2 Test3 Test4
Time1 : 1,211 1,210 1,220 1,213
Time2 : 1,280 1,258 1,253 1,332
Time3 : 1,129 1,138 1,130 1,160
Time4a : 0,690 0,682 0,617 0,635
Time4b : 0,707 0,698 0,706 0,659
Time4c : 0,679 0,685 0,626 0,625
Time5 : 0,715 0,682 0,686 0,679
Time6 : 0,490 0,485 0,522 0,514
Time7 : 0,323 0,333 0,336 0,318
Time8 : 0,407 0,403 0,373 0,354
Time9 : 0,352 0,378 0,355 0,355
Time10a : 1,823 1,812 1,807 1,813
Time10b : 1,113 1,120 1,115 1,118
Time10c : 0,652 0,630 0,653 0,633
Time10d : 0,156 0,155 0,172 0,160 <-- current winner!
如您所见4a，4b、4c和的结果5非常接近。这是为什么？因为我已经从 4a、4b 中删除了（4c 已经没有了）两条指令：push eax和pop eax. 因为我知道我不会在代码中的其他任何地方使用 eax 下的值，所以我不必保留它。现在我的代码只有一对推送/弹出，所以例程 5. 例程 5 保留 eax 的值，因为它首先在 ecx 下复制它，但它不保留 ecx。
所以我的结论是： 5 和 4a 和 4b 的时间执行差异（在第三次编辑之前）与数据相关性无关，而是由额外的一对推送/弹出指令引起的。
我对你的评论很感兴趣。
几天后，GJ 发明了比 PhiS 更快的程序（时间 10d）。干得好GJ！