4

我在 Windows 10 中使用 Delphi 10.1 Berlin。

我有两条不同大小的记录。我编写了代码来循环遍历其中两个TList<T>记录以测试经过的时间。循环遍历较大记录的列表运行速度要慢得多。

谁能解释原因，并提供解决方案以使循环运行得更快？

type
  tTestRecord1 = record
    Field1: array[0..4] of Integer;
    Field2: array[0..4] of Extended;
    Field3: string;
  end;

  tTestRecord2 = record
    Field1: array[0..4999] of Integer;
    Field2: array[0..4999] of Extended;
    Field3: string;
  end;

procedure TForm1.Button1Click(Sender: TObject);
var
  _List: TList<tTestRecord1>;
  _Record: tTestRecord1;
  _Time: TTime;
  i: Integer;
begin
  _List := TList<tTestRecord1>.Create;

  for i := 0 to 4999 do
  begin
    _List.Add(_Record);
  end;

  _Time := Time;

  for i := 0 to 4999 do
  begin
    if _List[i].Field3 = 'abcde' then
    begin
      Break;
    end;
  end;

  Button1.Caption := FormatDateTime('s.zzz', Time - _Time); // 0.000

  _List.Free;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  _List: TList<tTestRecord2>;
  _Record: tTestRecord2;
  _Time: TTime;
  i: Integer;
begin
  _List := TList<tTestRecord2>.Create;

  for i := 0 to 4999 do
  begin
    _List.Add(_Record);
  end;

  _Time := Time;

  for i := 0 to 4999 do
  begin
    if _List[i].Field3 = 'abcde' then
    begin
      Break;
    end;
  end;

  Button2.Caption := FormatDateTime('s.zzz', Time - _Time); // 0.045

  _List.Free;
end;
4

1 回答 1

9

首先，我想考虑整个代码，甚至是填充列表的代码，我确实意识到你没有计时。因为第二条记录的大小更大，所以在分配该记录类型时需要复制更多的内存。此外，当您从列表中读取时，较大的记录对缓存的友好性低于影响性能的较小记录。后者的影响可能不如前者那么显着。

与此相关的是，当您添加项目时，列表的内部记录数组必须调整大小。有时，调整大小会导致无法就地执行的重新分配。当这种情况发生时，会分配一个新的内存块，并将以前的内容复制到这个新块中。对于较大的记录，该副本显然非常昂贵。如果您知道数组的长度，则可以通过预先分配数组来缓解这种情况。该列表Capacity是要使用的机制。当然，您并不总是会提前知道长度。

除了内存分配和内存访问之外，您的程序几乎没有做任何事情。因此，这些内存操作的性能占主导地位。

现在，您的时间只是从列表中读取的代码。因此，人口的内存复制性能差异不是您执行的基准测试的一部分。您的时间差异主要是由于阅读时内存复制过多，我将在下面解释。

考虑这段代码：

if _List[i].Field3 = 'abcde' then

因为_List[i]是一个记录，一个值类型，整个记录被复制到一个隐含的隐藏局部变量中。代码实际上等价于：

var
  tmp: tTestRecord2;
...
tmp := _List[i]; // copy of entire record
if tmp.Field3 = 'abcde' then

有几种方法可以避免这种复制：

  1. 将基础类型更改为引用类型。这改变了内存管理要求。您可能有充分的理由想要使用值类型。
  2. 使用可以返回项目地址而不是项目副本的容器类。
  3. 切换TList<T>到动态数组TArray<T>。这个简单的更改将允许编译器直接访问各个字段，而无需复制整个记录。
  4. 使用TList<T>.List获取对保存数据的列表对象的底层数组的访问。这将与前一项具有相同的效果。

上面的第 4 项是您可以做出的最简单的更改，以看到很大的不同。你会替换

if _List[i].Field3 = 'abcde' then

和

if _List.List[i].Field3 = 'abcde' then

这应该会产生非常显着的性能变化。

考虑这个程序：

{$APPTYPE CONSOLE}

uses
  System.Diagnostics,
  System.Generics.Collections;

type
  tTestRecord2 = record
    Field1: array[0..4999] of Integer;
    Field2: array[0..4999] of Extended;
    Field3: string;
  end;

procedure Main;
const
  N = 100000;
var
  i: Integer;
  Stopwatch: TStopwatch;
  List: TList<tTestRecord2>;
  Rec: tTestRecord2;
begin
  List := TList<tTestRecord2>.Create;
  List.Capacity := N;

  for i := 0 to N-1 do
  begin
    List.Add(Rec);
  end;

  Stopwatch := TStopwatch.StartNew;
  for i := 0 to N-1 do
  begin
    if List[i].Field3 = 'abcde' then
    begin
      Break;
    end;
  end;
  Writeln(Stopwatch.ElapsedMilliseconds);
end;

begin
  Main;
  Readln;
end.

我必须将它编译为 64 位以避免内存不足的情况。我机器上的输出是 700 左右。更改List[i].Field3为List.List[i].Field3，输出为单个数字。时机相当粗略，但我认为这证明了这一点。

大型记录不适合缓存的问题仍然存在。处理起来更加复杂，并且需要详细分析真实世界的代码如何对其数据进行操作。

顺便说一句，如果您关心性能，那么您将不会使用Extended. 因为它的大小是 10，而不是 2 的幂，所以内存访问经常错位。使用Doubleor Realwhich 是Double.

于 2016-08-17T07:42:18.460 回答