如何在Delphi中使用现代CPU指令？ （Java比Delphi快？）
一位朋友给我发了一个最近版本的Delphi和Java之间的比较（如果你需要，可以找到源代码）。信不信由你（更好地相信）Java现在比Delphi快得多，因为Delphi编译器不会利用现代CPU指令！ “慢”Java的重大突破。
我的问题是：如何在不使用ASM的情况下在Delphi中使用现代CPU指令？
FastCode项目是上述问题的部分答案，但现在已被放弃。还有其他类似FastCode的项目吗？
这是另一篇文章，显示 Java和C＃确实比Delphi快得多： http://webandlife.blogspot.com/2011/12/c-performance-vs-delphi-performance.html
JAVA
import java.util.Date;
public class j
{
public static void xxx(int n, int m)
{
double t;
int i, j;
double d, r;
t = 0.0;
for (j = 1; j <= n; j++)
{
t = t / 1000.0;
for (i = 1; i <= m; i++)
{
t = t + i / 999999.0;
d = t * t + i;
r = (t + d) / (200000.0 * (i + 1));
t = t - r;
}
}
System.out.println(t);
}
public static void main(String [] args)
{
Date t1, t2;
t1 = new Date();
xxx(1, 999999999);
t2 = new Date();
System.out.println((t2.getTime() - t1.getTime())/1000);
t1 = new Date();
xxx(1, 999999999);
t2 = new Date();
System.out.println((t2.getTime() - t1.getTime())/1000);
}
}
25秒
DELPHI
program d;
{$APPTYPE CONSOLE}
uses
System.SysUtils, System.DateUtils;
var
t1, t2: TDateTime;
procedure xxx (n: integer; m: integer);
var
t: double;
i, j: integer;
d, r: double;
begin
t:= 0.0;
for j:= 1 to n do
begin
t:= t / 1000.0;
for i:= 1 to m do
begin
t:= t + i / 999999.0;
d:= t * t + i;
r:= (t + d) / (200000.0 * (i + 1));
t:= t - r;
end;
end;
writeln(t);
end;
begin
t1:= Now;
xxx(1, 999999999);
t2:= Now;
writeln(SecondsBetween(t2,t1));
t1:= Now;
xxx(1, 999999999);
t2:= Now;
writeln(SecondsBetween(t2,t1));
end.
37秒
似乎Delphi仍处于链的最底层：http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
我想知道Lazarus从这个角度来看与Delphi的比较。
5 个答案:
答案 0 :(得分：12)
根据你的代码，32位Delphi编译器的优点是浮点运算支持，它远未优化，并且在FPU堆栈上复制了大量内容。
关于浮点运算，不仅Java JITted代码会更快。即使是现代的JavaScript JIT编译器也可以比Delphi好得多！
这个blog article is just a reference about this，并提供有关Delphi浮点缓慢的asm级解释：
但是如果你使用面向Win64平台的Delphi编译器，它将发出不是x87而不是SSE2操作码，并且会更快。我怀疑与Java JITted可执行文件相当。
而且，就Java而言，任何Delphi可执行文件都将比JVM使用更少的内存，所以在这里，Delphi可执行文件完全在轨道上！
如果您希望代码更快，请不要使用asm或低级优化技巧，而是更改算法。它可能比编译提示快一个数量级。使用内联的asm操作码可以实现专用的过程 - 请查看this great set of articles这样的低级别黑客攻击。但掌握并不容易，通常是proper software profiling and adding some cache is the best way to performance！
答案 1 :(得分：10)
从Arnaud的角度来看 - 我实际上是在delphi中为x86和x64编译的。
32位编译器：
Unit1.pas.36: t:= t / 1000.0;
0051274D DD45F0 fld qword ptr [ebp-$10]
00512750 D835E4275100 fdiv dword ptr [$005127e4]
00512756 DD5DF0 fstp qword ptr [ebp-$10]
00512759 9B wait
Unit1.pas.37: for i:= 1 to m do
0051275A 8B45F8 mov eax,[ebp-$08]
0051275D 85C0 test eax,eax
0051275F 7E57 jle $005127b8
00512761 8945D0 mov [ebp-$30],eax
00512764 C745EC01000000 mov [ebp-$14],$00000001
Unit1.pas.39: t:= t + i / 999999.0;
0051276B DB45EC fild dword ptr [ebp-$14]
0051276E D835E8275100 fdiv dword ptr [$005127e8]
00512774 DC45F0 fadd qword ptr [ebp-$10]
00512777 DD5DF0 fstp qword ptr [ebp-$10]
0051277A 9B wait
Unit1.pas.40: d:= t * t + i;
0051277B DD45F0 fld qword ptr [ebp-$10]
0051277E DC4DF0 fmul qword ptr [ebp-$10]
00512781 DB45EC fild dword ptr [ebp-$14]
00512784 DEC1 faddp st(1)
00512786 DD5DE0 fstp qword ptr [ebp-$20]
00512789 9B wait
Unit1.pas.41: r:= (t + d) / (200000.0 * (i + 1));
0051278A DD45F0 fld qword ptr [ebp-$10]
0051278D DC45E0 fadd qword ptr [ebp-$20]
00512790 8B45EC mov eax,[ebp-$14]
00512793 40 inc eax
00512794 8945CC mov [ebp-$34],eax
00512797 DB45CC fild dword ptr [ebp-$34]
0051279A D80DEC275100 fmul dword ptr [$005127ec]
005127A0 DEF9 fdivp st(1)
005127A2 DD5DD8 fstp qword ptr [ebp-$28]
005127A5 9B wait
Unit1.pas.42: t:= t - r;
005127A6 DD45F0 fld qword ptr [ebp-$10]
005127A9 DC65D8 fsub qword ptr [ebp-$28]
005127AC DD5DF0 fstp qword ptr [ebp-$10]
005127AF 9B wait
Unit1.pas.43: end;
005127B0 FF45EC inc dword ptr [ebp-$14]
Unit1.pas.37: for i:= 1 to m do
005127B3 FF4DD0 dec dword ptr [ebp-$30]
005127B6 75B3 jnz $0051276b
Unit1.pas.44: end;
005127B8 FF45E8 inc dword ptr [ebp-$18]
64位编译器
Unit1.pas.36: t:= t / 1000.0;
000000000059F94E F20F104548 movsd xmm0,qword ptr [rbp+$48]
000000000059F953 F20F5E05BD000000 divsd xmm0,qword ptr [rel $000000bd]
000000000059F95B F20F114548 movsd qword ptr [rbp+$48],xmm0
000000000059F960 C7C001000000 mov eax,$00000001
000000000059F966 8B5568 mov edx,[rbp+$68]
000000000059F969 894544 mov [rbp+$44],eax
000000000059F96C 395544 cmp [rbp+$44],edx
000000000059F96F 7F73 jnle xxx + $C4
000000000059F971 83C201 add edx,$01
Unit1.pas.39: t:= t + i / 999999.0;
000000000059F974 F20F2A4544 cvtsi2sd xmm0,dword ptr [rbp+$44]
000000000059F979 F20F5E059F000000 divsd xmm0,qword ptr [rel $0000009f]
000000000059F981 F20F104D48 movsd xmm1,qword ptr [rbp+$48]
000000000059F986 F20F58C8 addsd xmm1,xmm0
000000000059F98A F20F114D48 movsd qword ptr [rbp+$48],xmm1
Unit1.pas.40: d:= t * t + i;
000000000059F98F F20F104548 movsd xmm0,qword ptr [rbp+$48]
000000000059F994 F20F594548 mulsd xmm0,qword ptr [rbp+$48]
000000000059F999 F20F2A4D44 cvtsi2sd xmm1,dword ptr [rbp+$44]
000000000059F99E F20F58C1 addsd xmm0,xmm1
000000000059F9A2 F20F114538 movsd qword ptr [rbp+$38],xmm0
Unit1.pas.41: r:= (t + d) / (200000.0 * (i + 1));
000000000059F9A7 F20F104548 movsd xmm0,qword ptr [rbp+$48]
000000000059F9AC F20F584538 addsd xmm0,qword ptr [rbp+$38]
000000000059F9B1 8B4544 mov eax,[rbp+$44]
000000000059F9B4 83C001 add eax,$01
000000000059F9B7 F20F2AC8 cvtsi2sd xmm1,eax
000000000059F9BB F20F590D65000000 mulsd xmm1,qword ptr [rel $00000065]
000000000059F9C3 F20F5EC1 divsd xmm0,xmm1
000000000059F9C7 F20F114530 movsd qword ptr [rbp+$30],xmm0
Unit1.pas.42: t:= t - r;
000000000059F9CC F20F104548 movsd xmm0,qword ptr [rbp+$48]
000000000059F9D1 F20F5C4530 subsd xmm0,qword ptr [rbp+$30]
000000000059F9D6 F20F114548 movsd qword ptr [rbp+$48],xmm0
Unit1.pas.43: end;
000000000059F9DB 83454401 add dword ptr [rbp+$44],$01
000000000059F9DF 395544 cmp [rbp+$44],edx
000000000059F9E2 7590 jnz xxx + $54
000000000059F9E4 90 nop
Unit1.pas.44: end;
000000000059F9E5 83454001 add dword ptr [rbp+$40],$01
000000000059F9E9 394D40 cmp [rbp+$40],ecx
000000000059F9EC 0F855CFFFFFF jnz xxx + $2E
000000000059F9F2 90 nop
Unit1.pas.45: writeln(t);
000000000059F9F3 488B0D9E150300 mov rcx,[rel $0003159e]
奇怪的是，在这种情况下，x87 fpu代码实际上大约快了约5％。结论可能只是Delphi的32位/ x87编译器非常成熟并且相当好地优化的事实，64位编译器可能有一些空间来改进性能。我可以很容易地看到一些可以在这里优化SSE代码的地方;例如，i可以存储在XMM寄存器中并重新使用，而不是每次使用cvtsi2sd时重新转换，d可以保存在XMM寄存器中以供下一个使用计算而不是存储和重新加载等。
进出XMM寄存器的未对齐MOV实际上可能非常昂贵。实际的SSE计算速度更快，但过多的数据移动可能会使分数缩小。也许Java强制堆栈上的16字节对齐？我知道MacOS就是这样做的，SSE使用对齐而不是不对齐的移动有明显的好处（当然，代价是消耗更多的堆栈空间）。
例如
-
fild：1 op，9 latency（x87） -
cvtsi2sd：2操作，12延迟（SSE）
或
-
fld：1 op，4 latency（x87） -
movsd[r，m]：2op，4等待时间（SSE）
Delphi的编译器在发出SSE指令的同时，似乎仍然以类似于x87单元的方式来处理工作流，这不一定是最好的方法。在任何一种情况下，David都是正确的 - 编译器就是这样。你无法做任何改变它。
在我需要快速数学例程的地方，我仍然自己在ASM中编写代码 - 这通常优于任何编译器都可以执行的操作，因为您可以根据您正在进行的精确计算自定义行为。我有旧的传统32位应用程序，带有手动调整的SSE3 ASM算法，用于复数运算和矩阵运算。关键是你没有需要来优化所有事情 - 你只需要优化瓶颈。这是一个值得注意的重要一点。
答案 2 :(得分：8)
我将在这里回答元问题：“为什么Delphi编译器不能使用更现代的CPU指令，为什么Java可以使用？”
基本上，有两种编译代码的方法：
- 在开发者机器上预编译
- 在目标机器上进行了后编译（包括JITed）
1的例子包括Delphi，C / C ++等 2.的示例包括Java，.NET，JavaScript等。
预编译环境
预编译环境允许您编译一次代码，并在目标计算机上运行它。编译的程序无法在使用旧指令集的计算机上运行，而不是编译程序使用。最低要求是编译器可以做到的最低要求，也是所有目标计算机的最低架构。如果您不了解目标计算机，则受编译器的限制。
后编译环境
在目标计算机上编译后编译环境。您不必知道它运行的体系结构：在其上运行的编译器需要知道它支持什么才能获得最大的好处。最低要求是编译器可以做到的最低要求，以及目标机器的体系结构。
原因是在后编译，JIT或解释语言环境中，编译器实际上在目标机器上运行。这意味着编译器可以使用该目标体系结构的所有功能。它甚至可以考虑物理内存，缓存大小或磁盘速度等方面，并测量当前运行时性能，以便对运行代码进行编译后优化。
Delphi和其他工具
对于Windows 32位Delphi编译器，我认为minimum requirement is 486仍然是Pentium（给定Pentium-Safe FDIV option）。因此，它使用x87作为CPU代码 它用于FPU代码的Windows 64-bit Delphi compiler has a minimum requirement of SSE instructions 我还没有检查其他编译器平台的最低要求。
Delphi的最低要求与强调向后兼容性有关。
其他一些环境（大多数C / ++编译器，也可能是其他环境）允许您指定最小指令集。德尔福没有。我认为主要原因是开发和测试的复杂性。可能性的矩阵（如果它确实是一个二维问题）变得非常快。
JIT编译器通常不全面支持最新的硬件架构优势，因为这样做非常昂贵。
JIT编译器通常支持某些处理器系列的优化（例如复制内存区域时）。
我知道Java和.NET在过去十年中在这方面取得了一些进展。关于.NET JIT usage of CPU features，有一篇非常好的2005年文章。
答案 3 :(得分：3)
<强>背景
问题是如何优化Delphi代码以使其与Java相媲美。并且不使用asm编码就这样做了。
<强>分析。
在给定的示例中，算法使用浮点计算。在其他答案中已经研究了编译器中的性能和弱点。从理论上讲，x64位编译器可以表现更好，因为SSE2操作码和寄存器可以提供更好的优化。所以编译器会成为这里的瓶颈。
还有人建议，更好的算法可以提高性能。 让我们再看一下这个。
改进算法。
在算法循环中，循环索引i在计算中使用三次作为变量。由于这会强制每次都进行整数浮点转换（加载到fpu或SSE2寄存器中时），因此会对性能产生很大影响。让我们来研究一下我们是否可以帮助编译器优化那些转换。
procedure xxx (n: integer; m: integer);
var
t,ii: double;
i, j: integer;
d, r: double;
begin
t:= 0.0;
for j:= 1 to n do
begin
t:= t / 1000.0;
ii:= 1.0;
for i:= 1 to m do
begin
t:= t + ii / 999999.0;
d:= t * t + ii;
ii:= ii + 1.0;
r:= (t + d) / (200000.0 * ii);
t:= t - r;
end;
end;
writeln(t);
end;
现在我们有一个只使用浮点值的干净算法。这里参考的是java代码：
public static void xxy(int n, int m)
{
double t;
int i, j;
double d, r, ii;
t = 0.0;
for (j = 1; j <= n; j++)
{
t = t / 1000.0;
ii = 1.0;
for (i = 1; i <= m; i++)
{
t = t + ii / 999999.0;
d = t * t + ii;
ii = ii + 1.0;
r = (t + d) / (200000.0 * ii);
t = t - r;
}
}
System.out.println(t);
}
<强>基准。
使用XE2编译器。
x32 x64 Java(x64)
--------------------------
Original algorithm 23417ms 22293ms 22045ms
Updated algorithm 22362ms 14059ms 15507ms
x64代码的反汇编如下所示：
Project19.dpr.11: begin
000000000046ABC0 55 push rbp
000000000046ABC1 4883EC20 sub rsp,$20
000000000046ABC5 488BEC mov rbp,rsp
Project19.dpr.12: t:= 0.0;
000000000046ABC8 F20F1005B0000000 movsd xmm0,qword ptr [rel $000000b0]
000000000046ABD0 C7C001000000 mov eax,$00000001
000000000046ABD6 4189C8 mov r8d,ecx
000000000046ABD9 89C1 mov ecx,eax
000000000046ABDB 413BC8 cmp ecx,r8d
000000000046ABDE 7F7B jnle xxx + $9B
000000000046ABE0 4183C001 add r8d,$01
Project19.dpr.15: t:= t / 1000.0;
000000000046ABE4 F20F5E059C000000 divsd xmm0,qword ptr [rel $0000009c]
Project19.dpr.16: ii := 1.0;
000000000046ABEC F20F100D9C000000 movsd xmm1,qword ptr [rel $0000009c]
000000000046ABF4 C7C001000000 mov eax,$00000001
000000000046ABFA 4189D1 mov r9d,edx
000000000046ABFD 413BC1 cmp eax,r9d
000000000046AC00 7F50 jnle xxx + $92
000000000046AC02 4183C101 add r9d,$01
Project19.dpr.19: t:= t + ii / 999999.0;
000000000046AC06 660F28D1 movapd xmm2,xmm1
000000000046AC0A F20F5E1586000000 divsd xmm2,qword ptr [rel $00000086]
000000000046AC12 F20F58C2 addsd xmm0,xmm2
Project19.dpr.20: d:= t * t + ii;
000000000046AC16 660F28D0 movapd xmm2,xmm0
000000000046AC1A F20F59D0 mulsd xmm2,xmm0
000000000046AC1E F20F58D1 addsd xmm2,xmm1
Project19.dpr.21: ii := ii + 1.0;
000000000046AC22 F20F580D66000000 addsd xmm1,qword ptr [rel $00000066]
Project19.dpr.22: r:= (t + d) / (200000.0 * ii);
000000000046AC2A 660F28D8 movapd xmm3,xmm0
000000000046AC2E F20F58DA addsd xmm3,xmm2
000000000046AC32 660F28D1 movapd xmm2,xmm1
000000000046AC36 F20F591562000000 mulsd xmm2,qword ptr [rel $00000062]
000000000046AC3E F20F5EDA divsd xmm3,xmm2
000000000046AC42 660F29DA movapd xmm2,xmm3
Project19.dpr.23: t:= t - r;
000000000046AC46 F20F5CC2 subsd xmm0,xmm2
Project19.dpr.24: end;
000000000046AC4A 83C001 add eax,$01
000000000046AC4D 413BC1 cmp eax,r9d
000000000046AC50 75B4 jnz xxx + $46
000000000046AC52 90 nop
Project19.dpr.25: end;
000000000046AC53 83C101 add ecx,$01
000000000046AC56 413BC8 cmp ecx,r8d
000000000046AC59 7589 jnz xxx + $24
000000000046AC5B 90 nop
Project19.dpr.26: WriteLn(t);
000000000046AC5C 488B0DC5100100 mov rcx,[rel $000110c5]
000000000046AC63 660F29C1 movapd xmm1,xmm0
000000000046AC67 E874D7F9FF call @Write0Ext
000000000046AC6C 4889C1 mov rcx,rax
000000000046AC6F E88CD7F9FF call @WriteLn
000000000046AC74 E877AFF9FF call @_IOTest
Project19.dpr.27: end;
000000000046AC79 488D6520 lea rsp,[rbp+$20]
浮点转换的额外整数消失了，寄存器也得到了更好的使用。
额外优化
对于x32位编译器，用倒数常量替换999999.0;和200000.0（const cA：Double = 1.0 / 999999.0; cB：Double = 1.0 / 200000.0;）并使用乘法代替也将改进性能
答案 4 :(得分：2)
我们如何在Delphi中使用现代CPU指令（不使用ASM）？
如果编译器不会发出您希望使用的CPU指令，那么除了自己生成所需的指令之外别无选择，例如使用内联汇编程序。
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？