如何有效地处理多个插入数组？

Question

我有一个动态分配的整数数组，我想在任意位置插入整数。 超过250万的许多整数。

我的代码目前看起来像这样：

type
  TIntegerArr = array of Integer;

var
  FCount: Integer;
  FSortedList: TIntegerArr;

procedure Insert(_Value: Integer; _InsertPos: integer);
var
  OldList: TIntegerArr;
begin
  OldList := FSortedList;
  if Length(FSortedList) < FCount + 1 then begin
    OldList := FSortedList;
    FSortedList := nil;
    SetLength(FSortedList, FCount + 100);
    CopyMemory(@FSortedList[0], @OldList[0], SizeOf(Integer) * _InsertPos);
  end;
  MoveMemory(@FSortedList[_InsertPos + 1], @OldList[_InsertPos], SizeOf(Integer) * (FCount - _InsertPos));
  FSortedList[_InsertPos] := _Value;
  Inc(FCount);
end;

（真正的代码是一个将FSortedList和FCount作为字段的类的方法。）

使用临时列表并使用Move而不是for循环来移动数据可以提高性能，因为它可以防止数组在必须增长时被复制两次（一次在现有阵列上的SetLength中，另一次在Move中） ）。

但最坏的情况是Insert（SomeValue，0）仍然会移动所有现有值。

到目前为止，我一直在考虑在数组的开头引入一个偏移量，而不是每次在前面插入一个新值时都必须移动所有现有的值，我只能在偏移量达到0时才这样做。 ：

// simple case: inserting at Position 0:
if FOffset = 0 then begin
  // [...] reallocate a new array as above
  Move(@FSortedList[100], @OldList, SizeOf(Integer) * _InsertPos);
  FOffset := 100;
end;
Dec(FOffset);
FSortedList[FOffset] := _NewValue;

（此代码未经测试且可能有错误）这当然可以扩展以检查插入点是否更接近开始或结束，并且取决于将第一个或最后一个值移动一个位置，以便平均只有1个/ 4个条目必须移动而不是目前的1/2。

另一种选择是实现稀疏数组。 我记得在20世纪90年代在某些商业图书馆看过这样的实现，但是不记得它是什么（TurboPower？）。

这个过程是一些排序和索引代码的核心，它可以处理不同大小的数组，从几十个条目到上面提到的数百万个条目。

目前该程序运行大约2个小时（在我的优化之前它接近5个小时）并且我已经知道阵列中的条目数量将至少增加一倍。 随着插入性能越来越差，阵列已经越大，我怀疑如果条目数增加一倍，则运行时间将至少翻两番。

我想就如何调整性能提出一些建议。 内存消耗目前不是问题，但运行时肯定是。

（这是Delphi 2007，但除非新的Delphi版本已经有一个用于执行上述操作的优化库，否则不应该有太大差别.Classes.TList未经过优化。）

Edit1：刚刚找到我上面提到的稀疏数组实现：它是来自TurboPower SysTools的StColl。

Edit2：好的，有些背景：我的程序读取一个DBase表，当前有240万个条目，并从这些条目中生成几个新表。 新表是规范化的，并在创建后编制索引（出于性能原因，我在插入数据之前不生成索引，请相信我，我先尝试过它。）。 该数组是代码的核心部分，为生成的表提供内部排序。 新记录仅附加到表中，但它们的RecNo按排序顺序插入到数组中。

Answer 1

看了你的手术后，我立即发现了一些瑕疵。 为了看到进展，我首先在最坏的情况下测量现有程序的速度（在0位置总是添加数字）。

n:=500000;
for i:=0 to n-1
 do Insert(i, 0);

测量：n = 500000 47.6 ms

A）简单

我从你的程序中删除了一些不必要的行（OldList完全没必要，SetLength保留了内存）。

改进A：

procedure Insert(_Value: Integer; _InsertPos: integer);
begin
 if Length(FSortedList) < FCount + 1
    then SetLength(FSortedList, FCount + 100);
  Move(FSortedList[_InsertPos], FSortedList[_InsertPos+1], SizeOf(Integer) * (FCount - _InsertPos));
  FSortedList[_InsertPos] := _Value;
  Inc(FCount);
end;

速度增益6％（44.8 ms）

B）一切都很重要

if Length(FSortedList) < FCount + 1 
   then SetLength(FSortedList, FCount + 100);

• 提示1：每次插入时都会调用函数Length
• 提示2：每次计算FCount + 1
• 提示3：过程参数为const（通过引用）
• 提示4：引入FCapacity变量
• 提示5：将长度增加100只会导致大量重新分配（2.5万个阵列上的25.000）。 正如你所说，内存不是问题所在，为什么不预先分配全部或至少大？

改进B：

procedure Insert(const _Value, _InsertPos: integer);
begin
 if FCount = FCapacity
    then begin
     Inc(FCapacity, 100000);
     SetLength(FSortedList, FCapacity);
    end;
 Move(FSortedList[_InsertPos], FSortedList[_InsertPos+1], SizeOf(Integer) * (FCount - _InsertPos));
 FSortedList[_InsertPos] := _Value;
 Inc(FCount);
end;

速度增益1％（44.3 ms）。

提示：您可以实现一些渐进算法，而不是Inc 100000。

C）瓶颈

如果我们现在看一下这个程序，就没有什么了，只需要大量的内存移动。 如果我们不能改变算法，就必须改进内存移动。

实际上有快速移动挑战（fastcode.sourceforge.net）

我准备了一个zip，只有你需要的文件（3个文件，源代码）。 链接>>> http://www.dakte.org/_stackoverflow/files/delphi-fastcode.zip

• 将fastcodeCPUID.pas和fastmove.pas添加到您的项目中！
• 插入使用fastmove.pas;
• 瞧！ 没有什么可以改变的！

我的机器上的速度增益几乎达到50％ （取决于您使用的CPU）。

原始程序

n         ms graph
---------------------------------
100000   1.8 *
200000   7.6 ***
300000  17.0 *******
400000  30.1 *************
500000  47.6 ********************

改进，无快速移动（-7％）

n         ms graph
---------------------------------
100000   1.6 *
200000   6.9 ***
300000  15.7 ******
400000  28.2 ***********
500000  44.3 ******************

改进，快速移动（-46％）

n         ms graph
---------------------------------
100000   0.8 *
200000   3.8 **
300000   9.0 ****
400000  16.3 *******
500000  25.7 ***********

最后评论：

 if FCount = FCapacity
    then begin
     if FCapacity<100000
        then FCapacity:=100000  
        else FCapacity:=FCapacity*2;
     SetLength(FSortedList, FCapacity);
    end;

正如我所说，你可以增加一些渐进的FCapacity增加。 这是一些经典的Grow实现（如果需要，只需添加更多，或者将100000更改为更合适的值）。

D）更新2：数组为^ TArray

type
  PIntegerArr3 = ^TIntegerArr3y;
  TIntegerArr3y = array[0..1] of Integer;

var
 FCapacity3,
 FCount3: Integer;
 FSortedList3: PIntegerArr3;

procedure ResizeArr3(var aCurrentArr: PIntegerArr3; const aNewCapacity: Integer);
var lNewArr: PIntegerArr3;

begin
 GetMem(lNewArr, aNewCapacity*SizeOf(Integer));

 if FCount3>0 // copy data too
  then begin
    if aNewCapacity<FCount3
       then FCount3:=aNewCapacity; // shrink
    Move(aCurrentArr^[0], lNewArr^[0], FCount3*SizeOf(Integer));
  end;

 FreeMem(aCurrentArr, FCapacity3*SizeOf(Integer));
 FCapacity3:=aNewCapacity;
 aCurrentArr:=lNewArr;
end;

procedure FreeArr3;
begin
 if FCapacity3>0
  then begin
    FreeMem(FSortedList3, FCapacity3*SizeOf(Integer));
    FSortedList3:=nil;
  end;
end;

procedure Insert3(const _Value, _InsertPos: integer);
begin
 if FCount3 = FCapacity3
    then ResizeArr3(FSortedList3, FCapacity3 + 100000);
 Move(FSortedList3^[_InsertPos], FSortedList3^[_InsertPos+1], SizeOf(Integer) * (FCount3 - _InsertPos));
 FSortedList3^[_InsertPos] := _Value;
 Inc(FCount3);
end;

步骤C）的速度增益无！

结论： FastMove或算法更改，达到内存移动速度的“物理”限制！

我正在使用Delphi XE3和System.pas，第5307行：

(* ***** BEGIN LICENSE BLOCK *****
 *
 * The assembly function Move is licensed under the CodeGear license terms.
 *
 * The initial developer of the original code is Fastcode
 *
 * Portions created by the initial developer are Copyright (C) 2002-2004
 * the initial developer. All Rights Reserved.
 *
 * Contributor(s): John O'Harrow
 *
 * ***** END LICENSE BLOCK ***** *)

procedure Move(const Source; var Dest; Count: NativeInt);

所以在Delphi中实际上已经有了一些Fastcode例程，但包括那些直接从他们的站点（或上面包含的链接）下载的那些例程造成了最大的差异，差不多50％（奇怪）。

Answer 2

不是一个破坏运动，但解决方案已经在编辑我的问题：

从阵列切换到TurboPower的StColl后 ，性能不再因大型阵列而降低，并且启动速度非常快。 运行时间从2小时减少到不到1/2小时。 变化非常简单。 我希望我早点记得那个图书馆。

我需要SourceForge存储库中的以下文件（我不想下载整个库）：

• StBase.pas
• StColl.pas
• StConst.pas
• StList.pas
• StDefine.inc

实际上我很惊讶没有更多的相互依赖。 TurboPower的家伙肯定知道他们的交易。 我不知道他们今天在做什么，还在为赌场编程赌博机吗？