【发布时间】：2023-03-11 00:22:01
【问题描述】：
我学习汇编程序已经有一段时间了，我正在尝试重写一些简单的程序\函数来查看性能优势（如果有的话）。我的主要开发工具是 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 指令一次写入内存 8 个字节的方法，但我无法找到将字节解压到 64 位寄存器的快速方法。
感谢您的宝贵时间。
感谢你们的宝贵意见。虽然我可以同时回答你们所有人，但不幸的是，与现代 CPU 相比，我只有一个“管道”并且当时只能执行一条指令“回复”；-) 所以，我会尝试在这里总结一些东西，并在你的答案下写额外的 cmets。
首先，我想说的是，在发布我的问题之前，我想出了 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、4b 和5 之间的执行时间差异是由数据依赖性引起的。但是，基于我所做的进一步测试，我不得不不同意这个观点。
我还在4a 的基础上发明了新的例程4c。这里是：
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 的执行时间差异（在第三次编辑之前）不涉及数据依赖性，而是由额外的一对推送/弹出指令引起的 .
我对你的 cmets 很感兴趣。
几天后，GJ 发明了比 PhiS 更快的例程（时间 10d）。干得好 GJ！
【问题讨论】：
-
Nitpick：我认为您的意思是“实心或透明”。 “不透明”的意思是“看不透”。
-
@j_random_hacker：谢谢，会改正的。
-
通常，Delphi“汇编程序”指令不做任何事情（只是为了与 Turbo Pascal 向后兼容），所以我有点惊讶。您使用的是哪个 Delphi 版本？您是否打开了任何编译器选项以始终生成堆栈帧或类似的东西？
-
我刚刚检查过，用“assembler”标记 BASM 版本在 Delphi 2009 中对我没有影响。
-
@Wodzu：EBX、ESI、EDI、ESP、EBP 需要保留在 Delphi 汇编函数中。原因很简单，这是他们选择的调用约定。此外，方向标志应始终恢复，如果您使用 MMX（但不是 XMM）寄存器，则必须在例程结束时恢复到 FPU 模式（即，使用 EMMS 指令）。数据（通常）通过 EAX、EDX 和 ECX 传递给函数，然后是堆栈。如果你的函数返回一些东西，它会在 AL/AX/EAX/EDX:EAX([u]int64) 或 ST(0) （浮点值）中返回，或者在 @Result 中返回一些其他东西（作为隐藏传递给 proc参数）
标签： delphi optimization assembly x86 basm