我注意到数组的执行速度比Haxe的链表(至少在cpp上)快得多。我得到的结果如下。
Main.hx:40: With 1 items, Array is 14% faster than List.
Main.hx:40: With 5 items, Array is 58% faster than List.
Main.hx:40: With 10 items, Array is 59% faster than List.
Main.hx:40: With 100 items, Array is 54% faster than List.
Main.hx:40: With 1000 items, Array is 56% faster than List.
Main.hx:40: With 10000 items, Array is 55% faster than List.
Main.hx:40: With 100000 items, Array is 52% faster than List.
这让我震惊。即使必须连续在项目周围进行复制,Array怎么能这么快?那为什么还要使用列表呢?
package tests;
import haxe.Timer;
class Main
{
static function main()
{
var arr:Array<Int> = new Array();
var list:List<Int> = new List();
var result = new List();
for (items in [1, 5, 10, 100, 1000, 10000, 100000]) {
var listtime = timeit(10000, function() {
for (i in 0...items)
list.add(i);
for (x in list)
result.add(x);
result.clear();
list = new List();
});
var arrtime = timeit(10000, function() {
for (i in 0...items)
arr.push(i);
for (x in arr)
result.add(x);
result.clear();
arr = new Array();
});
if (arrtime < listtime)
trace('With $items items, Array is ${Std.int((1-arrtime/listtime)*100)}% faster than List.');
else
trace('With $items items, List is ${Std.int((1-listtime/arrtime)*100)}% faster than Array.');
}
}
static public function timeit<T>(times:Int, f:Void -> T):Float {
var start = Timer.stamp();
for (i in 0...times) {
f();
}
var time = Timer.stamp() - start;
return time;
}
}
即使必须连续在项目周围进行复制,Array怎么能这么快?
数组用于线性处理的速度更快,因为数组内容连续存储在内存中。线性访问内存时,多个对象会同时提取到处理器缓存中。另一方面,链接列表节点分散在整个内存中,因此,对其进行线性处理会导致主内存中出现更多访问权限。读取缓存比读取主内存快得多。
那为什么还要使用列表呢?
使用链表的一个主要原因是,插入新元素或删除现有元素不会使对链表中其他元素的引用(包括迭代器和指针)无效。数组不能有这种保证。
本文收集自互联网,转载请注明来源。
如有侵权,请联系 [email protected] 删除。
我来说两句