Speed test between _ArrayAdd, Scripting Dictionary, Array command (inbuilt)

[Shafayat]

Recently I've been working with Scripting Dictionary Object a lot. So, I did a basic test and got just the result I had expected.

expandcollapse popup

#cs
Speed test between -
1) _ARRAYADD
2) Scripting Dictionary Add
3) Array command (inbuilt)
#ce

#include <Timers.au3>
#include <Array.au3>

Global $count = 100000
;~ Global $count = 1000000 ; Use if you can let your computer have fun for a few minutes
Global $rnd = Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1)

; ==================== TEST ARRAYADD ==================== ;
$starttime = _Timer_Init()
Global $testarray
For $i = 1 To $count
    _ArrayAdd($testarray, $rnd)
Next
$TEST_ARRAYADD = _Timer_Diff($starttime)
; ======================================================= ;

; =================== TEST DICTIONARY =================== ;
$starttime = _Timer_Init()
Global $testdict = ObjCreate("Scripting.Dictionary")
For $i = 1 To $count
    $testdict($rnd) = $rnd
Next
$TEST_DIC = _Timer_Diff($starttime)
; ======================================================= ;

; ================== TEST ARRAY GENERAL ================== ;
$starttime = _Timer_Init()
Global $testarray2[$count + 1]
For $i = 1 To $count
    ;_ArrayAdd($testarray, $rnd)
    $testarray2[$i] = $rnd
Next
$TEST_ARRAY = _Timer_Diff($starttime)
; ======================================================= ;

MsgBox(0, "Speed Test Results:", "With _ArrayAdd = " & $TEST_ARRAYADD & @CRLF & "With ScriptingDictionary = " & $TEST_DIC & @CRLF & "With Simple Array = " & $TEST_ARRAY)

Edited March 17, 2010 by Shafayat

[UEZ]

I added the struct to your example:

; ================== TEST STRUCT ======================== ;
Global $tStruct = DllStructCreate("uint[" & $count & "]")
$starttime = _Timer_Init()
For $i = 1 To $count
    DllStructSetData($tStruct, $i, $rnd)
Next
$TEST_STRUCT = _Timer_Diff($starttime)
$tStruct = ""
; ======================================================= ;


MsgBox(0, "Speed Test Results:", "With _ArrayAdd = " & $TEST_ARRAYADD & @CRLF & _
                                 "With ScriptingDictionary = " & $TEST_DIC & @CRLF & _
                                 "With Simple Array = " & $TEST_ARRAY & @CRLF & _
                                 "With Struct = " & $TEST_STRUCT)

UEZ

[MvGulik]

whatever Edited February 7, 2011 by MvGulik

[MrCreatoR]

_ArrayAdd is slow because it's redims the array every call, your comparision is wrong here.

We can change the function a little bit and add an Element parameter:

expandcollapse popup

;#include <Array.au3>

Global $count = 10000
Global $testarray[$count + 1]

; ==================== TEST ARRAYADD ==================== ;
$starttime = TimerInit()
For $i = 1 To $count
    _ArrayAdd($testarray, $i, $i)
Next
$TEST_ARRAYADD = TimerDiff($starttime)
; ======================================================= ;

; ================== TEST ARRAY GENERAL ================== ;
$starttime = TimerInit()
For $i = 1 To $count
    $testarray[$i] = $i
Next
$TEST_ARRAY = TimerDiff($starttime)
; ======================================================= ;

MsgBox(0, "Speed Test Results:", "With _ArrayAdd = " & $TEST_ARRAYADD & @CRLF & "With Simple Array = " & $TEST_ARRAY)

Func _ArrayAdd(ByRef $avArray, $vValue, $iElement=-1)
    If Not IsArray($avArray) Then Return SetError(1, 0, -1)
    If UBound($avArray, 0) <> 1 Then Return SetError(2, 0, -1)
    
    Local $iUBound = UBound($avArray)
    
    If $iElement > 0 And $iElement < $iUBound Then
        $iUBound = $iElement
    Else
        ReDim $avArray[$iUBound + 1]
    EndIf
    
    $avArray[$iUBound] = $vValue
    Return $iUBound
EndFunc

but that is still slower than custom assignment.

[Kealper]

So...what is the benifit of using _ArrayAdd() again (or any "more complex" method, for that matter)? from this, it looks like the most simple and straight-forward method beats the others by a long shot. The Scripting Dictionary object is an interesting take on filling an array, though.

[Shafayat]

I knew why _arrayadd is slower. But I don't see any way to fix it either. It will always be slower, yet still easy to use.

Actually I did the test to find out if I use Scripting Dictionary object instead of array functions, what kind of loss I receive in speed. The answer I get is "not much" or "acceptable". I see that this object provides many of the flexibilities of _array functions with less compromising on the speed. So, I'm most likely going to use it in my later scripts.

[MrCreatoR]

I don't see any way to fix it either

I personaly use global declaration of the array with specific size, and i redim it only when there is need to.

[wraithdu]

Try this one. Also, fixed your use of the dictionary. Best speed so far for a dynamically filled array.

expandcollapse popup

#NoTrayIcon

#cs
Speed test between -
1) _ARRAYADD
2) Scripting Dictionary Add
3) Array command (inbuilt)
#ce

#include <Timers.au3>
#include <Array.au3>

Global $count = 100000
;~ Global $count = 1000000 ; Use if you can let your computer have fun for a few minutes
Global $rnd = Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1)

; ==================== TEST ARRAYADD ==================== ;
$starttime = _Timer_Init()
Global $testarray
For $i = 1 To $count
    _ArrayAdd($testarray, $rnd)
Next
$TEST_ARRAYADD = _Timer_Diff($starttime)
; ======================================================= ;

; =================== TEST DICTIONARY =================== ;
$starttime = _Timer_Init()
Global $testdict = ObjCreate("Scripting.Dictionary")
For $i = 1 To $count
    $testdict.Item($i) = $rnd
    ;$testdict.Add($i, $rnd)
Next
$TEST_DIC = _Timer_Diff($starttime)
; ======================================================= ;

; ================== TEST ARRAY GENERAL ================== ;
$starttime = _Timer_Init()
Global $testarray[1] = [0]
For $i = 1 To $count
    $testarray[0] += 1
    If UBound($testarray) <= $testarray[0] Then ReDim $testarray[UBound($testarray) * 2]
    $testarray[$testarray[0]] = $rnd
Next
ReDim $testarray[$testarray[0] + 1]
$TEST_ARRAY = _Timer_Diff($starttime)
; ======================================================= ;

MsgBox(0, "Speed Test Results:", "With _ArrayAdd = " & $TEST_ARRAYADD & @CRLF & "With ScriptingDictionary = " & $TEST_DIC & @CRLF & "With Dynamic Array = " & $TEST_ARRAY)

Edited March 21, 2010 by wraithdu

[MHz]

_ArrayAdd() does return @error with using a non-array variable. Perhaps checking @error may help to validate the test.

[MilesAhead]

I've been using Scripting.Dictionary since it's accessible from many programming languages. I'm curious if anyone has done any capacity benchmarks? The maximum size may vary with physical ram but I'm wondering if there's some limitations in the implementation such as maximum number of entries or some other.

As an example I'm using it to store text comments associated with files. The comment shows in a ToolTip when you arrow key in Explorer. The file path is the key. But since entry is HotKey to an InputBox, enter text, repeat, I'm not really up for entering 4000 comments to see what it can handle.

Seems to be fine for casual use. I'm just curious if anyone has run into some number where it bogs badly or just craps out altogether.

Edited August 25, 2011 by MilesAhead

[Zedna]

Try this one. Also, fixed your use of the dictionary. Best speed so far for a dynamically filled array.

Added static array test - of course speed winner:

; ================== TEST ARRAY STATIC ================== ;
$starttime = _Timer_Init()
Global $testarray[$count]
For $i = 0 To $count - 1
    $testarray[$i] = $rnd
Next
$TEST_ARRAY_static = _Timer_Diff($starttime)
; ======================================================= ;

[Zip]

Try this one. Also, fixed your use of the dictionary. Best speed so far for a dynamically filled array.

#NoTrayIcon
 
#cs
Speed test between -
1) _ARRAYADD
2) Scripting Dictionary Add
3) Array command (inbuilt)
#ce
 
#include <Timers.au3>
#include <Array.au3>
 
Global $count = 100000
;~ Global $count = 1000000 ; Use if you can let your computer have fun for a few minutes
Global $rnd = Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1)
 
; ==================== TEST ARRAYADD ==================== ;
$starttime = _Timer_Init()
Global $testarray
For $i = 1 To $count
    _ArrayAdd($testarray, $rnd)
Next
$TEST_ARRAYADD = _Timer_Diff($starttime)
; ======================================================= ;

Not sure If I am missing something, please excuse me if I am,

but _ArrayAdd is a million times slower than this code suggests,

as if you declare it like you did, this array is neither created nor redimmed by _ArrayAdd,

so effectively, all youre timing there, is Autoit's Error response speed from the func.

[monoscout999]

@Zip Read the posts form above. the speed problem is because _ArrayAdd() ReDim the Array every time you called, that takes most time.. that is what i undertand reading this topic. Edited September 4, 2011 by monoscout999

[Zip]

Yes, but that will not happen, with the code I quoted ... all it times, is the calls to & error returns from _ArrayAdd.

[Zip]

This, I think, should show the real speed difference, using the examples above combined,

(I left the Dynamic array over estimation of redimming to *2, if used with +1, it will be ~ as slow as _arrayadd)

I changed it to use a 1000 values, as 100,000 values is too slow if _ArrayAdd truly does its thing.

expandcollapse popup

#NoTrayIcon
#include <Timers.au3>
#include <Array.au3>
#cs
Speed test between -
1) _ARRAYADD
2) Scripting Dictionary Add
3) Array command (inbuilt)
#ce
Global $count = 1000
Global $rnd = Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1) & Random(0, 9, 1)
ConsoleWrite('-('&@ScriptLineNumber&') :['&@error&'|'&@Extended&'] $rnd = '&$rnd&@lf) ;### Debug Console
; ==================== TEST ARRAYADD ==================== ;
ConsoleWrite(@lf & '>  ==================== TEST ARRAYADD ==================== ' & @LF)
$starttime = _Timer_Init()
Dim $testarray[1]=[$count]
For $i = 1 To $count
    $ArrayAdd=_ArrayAdd($testarray, $rnd)
Next
$TEST_ARRAYADD = _Timer_Diff($starttime)
ConsoleWrite(':'&@ScriptLineNumber&': $TEST_ARRAYADD = '&$TEST_ARRAYADD&@lf) ;### Debug Console
; ======================================================= ;
; =================== TEST DICTIONARY =================== ;
ConsoleWrite(@lf & '>  =================== TEST DICTIONARY =================== ' & @LF)
$starttime = _Timer_Init()
Global $testdict = ObjCreate("Scripting.Dictionary")
For $i = 1 To $count
    $testdict.Item($i) = $rnd
Next
$TEST_DIC = _Timer_Diff($starttime)
ConsoleWrite(':'&@ScriptLineNumber&': $TEST_DIC =  '&$TEST_DIC&@lf) ;### Debug Console
; ======================================================= ;
; ================== TEST ARRAY DYNAMIC ================== ;
ConsoleWrite(@lf & '>  ================== TEST ARRAY DYNAMIC ================== ' & @LF)
$starttime = _Timer_Init()
Global $testarray[1] = [0]
For $i = 1 To $count
    $testarray[0] += 1
    If UBound($testarray) <= $testarray[0] Then ReDim $testarray[UBound($testarray) * 2]
    $testarray[$testarray[0]] = $rnd
Next
ReDim $testarray[$testarray[0] + 1]
$TEST_ARRAY = _Timer_Diff($starttime)
ConsoleWrite(':'&@ScriptLineNumber&': $TEST_ARRAY  = '&$TEST_ARRAY &@lf) ;### Debug Console
; ======================================================= ;
; ================== TEST ARRAY STATIC ================== ;
ConsoleWrite(@lf & '>  ================== TEST ARRAY STATIC ================== ' & @LF)
$starttime = _Timer_Init()
Global $testarray[$count]
For $i = 0 To $count - 1
    $testarray[$i] = $rnd
Next
$TEST_ARRAY_static = _Timer_Diff($starttime)
ConsoleWrite(':'&@ScriptLineNumber&': $TEST_ARRAY_static = '&$TEST_ARRAY_static&@lf) ;### Debug Console
; ======================================================= ;
MsgBox(0, "Speed Test Results:", "With _ArrayAdd = " & $TEST_ARRAYADD & @CRLF & "With ScriptingDictionary = " & $TEST_DIC & @CRLF & "With Dynamic Array = " & $TEST_ARRAY & @CRLF & "With Static Array = " & $TEST_ARRAY_static)

Edited September 5, 2011 by Zip

[monoscout999]

I don´t get your "Dynamic Array" method...why * 2 it should be + 1 to be fair...

[Zip]

well, because its useless without it ..

using *2 makes it a valid way to do it speed wise, change it to +1, & your'e back to _ArrayAdd speed.

[monoscout999]

I see now! good method i don`t know where to apply, because if you know how many data you will add you use the "Static array" method

[wraithdu]

Yes, but that will not happen, with the code I quoted ... all it times, is the calls to & error returns from _ArrayAdd.

Yeah, there's an error in the test code. For the _ArrayAdd test, the $testarray var must be declared an array, Global $testarray[1].