【问题标题】:Why is dynamic array "constructor" much slower than SetLength and elements initialization?为什么动态数组“构造函数”比 SetLength 和元素初始化慢得多?
【发布时间】:2017-08-20 19:13:15
【问题描述】:

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

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

在我的机器上测试,结果值总是接近以下:

构造函数 = 622

其他方法 = 288

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

【问题讨论】:

  • 这很容易通过查看生成的代码来检查。我希望你有优化,没有范围检查等。
  • @Deltics 在您删除的答案中,您评论道:有趣的是,它既“完全等效”又慢。即使它实际上不是一个类,它显然也不完全等价。 :shrug: Rudy 说这些类型是完全等价的。他们是。不同的是为初始化相同类型的变量而生成的代码。您似乎仍然没有理解被比较的两个事物在同一类型TArray&lt;Integer&gt; 上运行。我想知道,你有支持泛型的 Delphi 版本吗?
  • 您显示的代码肯定不是产生这些不同结果的代码。这只发生在直接在循环体中修改 Arr 变量时。否则,通过使用该函数,您可以获得与使用数组构造函数的代码相同的效果(填充临时变量,分配)。甚至使该函数内联也无济于事,因为 Delphi 不对托管类型进行返回值优化。
  • @StefanGlienke:问题中的测试代码会产生这些不同的结果,试试吧(我使用的是 Delphi XE7)。
  • 我做了,由于我解释的原因,它产生了类似的结果。

标签: arrays delphi dynamic-arrays delphi-xe7


【解决方案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&lt;Integer&gt; 类型与 array of Integer 完全相同。 classes 或其他类型的 wrappers 都不是用于动态数组。它们是普通的动态数组,仅此而已。构造函数语法可以应用于两者。 唯一的区别在于类型兼容性。 TArray&lt;Integer&gt; 可以用作 ad-hoc 类型声明,所有TArray&lt;Integer&gt; 都是类型兼容的。

【讨论】:

  • 在现实世界的程序中,这些性能差异都不重要,fwiw
  • @David:我完全同意。尤其是 dynarray 常量不太可能经常被分配(当然不是在一个紧密的循环中)。并且“构造函数”语法(或更新的“dynarray 文字”)语法通常非常方便初始化这样的数组。
  • FWIW 带有数组构造函数的代码具有不同的语义,因为它确保您永远不会有一些半填充的数组位于赋值的左侧。这就是为什么它适用于临时变量并最终执行DynArrayAsg 的原因。当然,在这种情况下,某些整数分配失败的可能性很小,但是您可以调用函数,而这可能会在某些时候引发异常。我想这属于“如果他们真的关心的话,可以进行许多优化”的类别。
  • 顺便说一句 DynArrayAsg 源是 const (refcount
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2014-09-07
相关资源
最近更新 更多