动态数组的“构造函数”为什么比SetLength和元素初始化慢得多？

Question

动态数组的“构造函数”为什么比SetLength和元素初始化慢得多？

11

我正在比较初始化动态数组的这两种方法的性能：

Arr := TArray<integer>.Create(1, 2, 3, 4, 5);

并且

SetLength(Arr, 5);
Arr[0] := 1;
Arr[1] := 2;
Arr[2] := 3;
Arr[3] := 4;
Arr[4] := 5;

我准备了一个测试，发现使用数组 "constructor" 比其他方法需要的时间多两倍。

测试：

uses
  DateUtils;

function CreateUsingSetLength() : TArray<integer>;
begin
  SetLength(Result, 5);
  Result[0] := 1;
  Result[1] := 2;
  Result[2] := 3;
  Result[3] := 4;
  Result[4] := 5;
end;

...

const
  C_COUNT = 10000000;
var
  Start : TDateTime;
  i : integer;
  Arr : TArray<integer>;
  MS1 : integer;
  MS2 : integer;
begin
  Start := Now;
  i := 0;
  while(i < C_COUNT) do
  begin
    Arr := TArray<integer>.Create(1, 2, 3, 4, 5);
    Inc(i);
  end;
  MS1 := MillisecondsBetween(Now, Start);

  Start := Now;
  i := 0;
  while(i < C_COUNT) do
  begin
    Arr := CreateUsingSetLength();
    Inc(i);
  end;
  MS2 := MillisecondsBetween(Now, Start);

  ShowMessage('Constructor = ' + IntToStr(MS1) + sLineBreak + 'Other method = ' + IntToStr(MS2));

在我的计算机上测试，得到的值总是接近以下数值:

构造函数 = 622

其他方法 = 288

为什么数组“构造函数”很慢？

- Fabrizio

这很容易通过查看生成的代码来检查。我希望你已经进行了优化，没有区间检查等。 - David Heffernan

@Deltics 在您已删除的回答中评论道：有趣的是它既是“完全等效”的，但却更慢。即使它实际上并不是一个类，它显然也不完全等效。:耸肩: Rudy 正在说这些类型是完全等效的。他们是的。不同的是生成用于初始化同一类型变量的代码。你似乎仍然没有理解到被比较的两个操作都作用于相同类型的 TArray<Integer>。我想知道，您是否拥有支持泛型的 Delphi 版本？ - David Heffernan

你展示的代码肯定不是产生这些不同结果的那个。只有在循环体中直接修改Arr变量时才会发生这种情况。否则，通过使用函数，您将获得与使用数组构造函数的代码相同的效果（填充临时变量，分配）。即使将该函数内联也无济于事，因为Delphi不会对托管类型进行返回值优化。 - Stefan Glienke

@StefanGlienke：问题中的测试代码会产生不同的结果，请尝试一下（我使用的是Delphi XE7）。 - Fabrizio

好吧，没关系 - 我在dpr主函数中直接测试了代码，这产生了与Arr变量作为局部变量时不同的代码。是的，我现在看到了区别，因为CreateUsingSetLength的结果被优化了，因为编译器知道它可以直接写入Arr而没有其他人可能访问它。所以，如果您关心这个问题，请将其输入quality.embarcadero.com，编译器可以对局部变量上的TArray<T>.Create执行类似的优化，因为没有其他人可能同时写入它。 - Stefan Glienke

显示剩余2条评论

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Rudy Velthuis · Accepted Answer

我们来看一下生成的代码（开启优化，Win32目标，10.2 Tokyo）：

Project152.dpr.34: Arr := TArray<Integer>.Create(1, 2, 3, 4, 5);
004D0D22 8D45F8           lea eax,[ebp-$08]
004D0D25 8B15B84B4000     mov edx,[$00404bb8]
004D0D2B E858BFF3FF       call @DynArrayClear
004D0D30 6A05             push $05
004D0D32 8D45F8           lea eax,[ebp-$08]
004D0D35 B901000000       mov ecx,$00000001
004D0D3A 8B15B84B4000     mov edx,[$00404bb8]
004D0D40 E81FBEF3FF       call @DynArraySetLength
004D0D45 83C404           add esp,$04
004D0D48 8B45F8           mov eax,[ebp-$08]
004D0D4B C70001000000     mov [eax],$00000001
004D0D51 8B45F8           mov eax,[ebp-$08]
004D0D54 C7400402000000   mov [eax+$04],$00000002
004D0D5B 8B45F8           mov eax,[ebp-$08]
004D0D5E C7400803000000   mov [eax+$08],$00000003
004D0D65 8B45F8           mov eax,[ebp-$08]
004D0D68 C7400C04000000   mov [eax+$0c],$00000004
004D0D6F 8B45F8           mov eax,[ebp-$08]
004D0D72 C7401005000000   mov [eax+$10],$00000005
004D0D79 8B55F8           mov edx,[ebp-$08]
004D0D7C 8D45FC           lea eax,[ebp-$04]
004D0D7F 8B0DB84B4000     mov ecx,[$00404bb8]
004D0D85 E842BFF3FF       call @DynArrayAsg

而且：

Project152.dpr.12: SetLength(Result, 5);
004D0CB2 6A05             push $05
004D0CB4 8BC3             mov eax,ebx
004D0CB6 B901000000       mov ecx,$00000001
004D0CBB 8B15B84B4000     mov edx,[$00404bb8]
004D0CC1 E89EBEF3FF       call @DynArraySetLength
004D0CC6 83C404           add esp,$04
Project152.dpr.13: Result[0] := 1;
004D0CC9 8B03             mov eax,[ebx]
004D0CCB C70001000000     mov [eax],$00000001
Project152.dpr.14: Result[1] := 2;
004D0CD1 8B03             mov eax,[ebx]
004D0CD3 C7400402000000   mov [eax+$04],$00000002
Project152.dpr.15: Result[2] := 3;
004D0CDA 8B03             mov eax,[ebx]
004D0CDC C7400803000000   mov [eax+$08],$00000003
Project152.dpr.16: Result[3] := 4;
004D0CE3 8B03             mov eax,[ebx]
004D0CE5 C7400C04000000   mov [eax+$0c],$00000004
Project152.dpr.17: Result[4] := 5;
004D0CEC 8B03             mov eax,[ebx]
004D0CEE C7401005000000   mov [eax+$10],$00000005

很明显，“constructor”调用生成的代码被简单地优化得更少。

正如您所见，“constructor”代码首先清除、分配并填充一个匿名数组（在[ebp-$08]处），最后将其赋值给变量Arr（在[ebp-$04]处）。这就是它较慢的主要原因。

在更新的版本中，有第三种方式：

Arr := [1, 2, 3, 4, 5];

但这将生成与“构造函数”语法完全相同的代码。但是您可以通过以下方式加速：

const
  C_ARR = [1, 2, 3, 4, 5]; // yes, dynarray const!

并且

Arr := C_ARR;

这仅仅是一次生成动态数组，引用计数为-1，在循环中，仅执行一次赋值操作（实际上在_DynArrayAsg中执行复制操作 - 但这依然更快）：

Project152.dpr.63: Arr := C_ARR;
004D0E60 8D45FC           lea eax,[ebp-$04]
004D0E63 8B15C4864D00     mov edx,[$004d86c4]
004D0E69 8B0DB84B4000     mov ecx,[$00404bb8]
004D0E6F E858BEF3FF       call @DynArrayAsg

备注：

但是，正如@DavidHeffernan评论的那样，在实际编程中，这些性能差异几乎不会被注意到。通常情况下，您不会在紧密循环中初始化这些数组，在一次性的情况下，差异只有几个纳秒，在整个程序运行期间，您甚至都不会注意到。

备注2：

似乎存在一些混淆。类型TArray<Integer>与array of Integer完全相同。两者都不是类或某种动态数组的包装器。它们都是普通的动态数组而已。构造函数语法可以应用于两者。 唯一的区别在于类型兼容性。 TArray<Integer>可以用作临时类型声明，并且所有TArray<Integer>都是类型兼容的。