arrays - 为什么动态数组 "constructor"比 SetLength 和元素初始化慢得多？

Question

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

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;

我准备了一个测试，我注意到使用数组“构造函数”所需的时间是其他方法所需时间的两倍。

测试:

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));

在我的机器上进行测试，结果值始终接近以下值:

Constructor = 622

Other method = 288

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

Answer 1

让我们看一下生成的代码(针对 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

因此很明显，为“构造函数”调用生成的代码优化程度较低。

如您所见，“构造函数”代码首先清除、分配并填充匿名数组(位于 [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>类型兼容。