Speed Test...casting Ints as objects and such...

Well, I've run into the ugly problem of ints and floats and other basic data types not being objects, yet I need to store them as an object and then retrieve them again and there are a few different ways to handle this.

Can you please compile and run the following in both debug and non-debug mode, and post your results.

(Don't look at the code, it's ugly :P)

Local numiterations:Int = 100000000
Local Obj:Object
Local wrap:intwrapper = New intwrapper
Local time:Double = MilliSecs()
wrap.intval = 55
obj = "test"

Print "~n"

For Local iter1:Int = 0 Until numiterations
test( obj )
Next
Print "Convert from object to int via cast to string then int results."
Print "Elapsed time over: " + numiterations + " iterations: " + (MilliSecs()-time)

Print "~n"

time = MilliSecs()
For Local iter3:Int = 0 Until numiterations
test3( "5" )
Next
Print "Convert from string to int results."
Print "Elapsed time over: " + numiterations + " iterations: " + (MilliSecs()-time)

Print "~n"

time = MilliSecs()
For Local iter4:Int = 0 Until numiterations
test4( wrap )
Next
Print "Get int value from wrapper object results."
Print "Elapsed time over: " + numiterations + " iterations: " + (MilliSecs()-time)

Print "~n"

time = MilliSecs()
For Local iter2:Int = 0 Until numiterations
test2( iter2 )
Next
Print "No conversion whatsoever results."
Print "Elapsed time over: " + numiterations + " iterations: " + (MilliSecs()-time)




Type intwrapper
Field intval:Int
EndType

Function test:Int( obj:Object )
Return Int(String(obj))
EndFunction


Function test2:Int( pInt:Int )
Return pInt
EndFunction

Function test3:Int( obj:String )
Return Int(obj)
EndFunction

Function test4:Int( obj:Object )
Return intwrapper(obj).intval
EndFunction

Thanks much.

Here are my own results from my pathetic computer at work:

debug ON:




debug OFF:

On a Core 2 Duo 6700 @2.66Ghz, 3gb ram

debug on:

debug off:

Thanks Azathoth. I'm assuming most results will look similar, at least regarding the disparity between the efficiency of the different methods.

I'm now curious to see how an AMD processor will perform.

Also, looks like it'll be worth converting the little bit I've coded to an int wrapper system.

AMD Athlon 64 Processor 3700+, 2.21GHz, 2.00 GB Ram

DEBUG ON:
Convert from object to int via cast to string then int results.
Elapsed time over: 100000000 iterations: 10652.000000000000


Convert from string to int results.
Elapsed time over: 100000000 iterations: 11730.000000000000


Get int value from wrapper object results.
Elapsed time over: 100000000 iterations: 10603.000000000000


No conversion whatsoever results.
Elapsed time over: 100000000 iterations: 8744.0000000000000

Process complete


DEBUG OFF:
Convert from object to int via cast to string then int results.
Elapsed time over: 100000000 iterations: 3276.0000000000000


Convert from string to int results.
Elapsed time over: 100000000 iterations: 3321.0000000000000


Get int value from wrapper object results.
Elapsed time over: 100000000 iterations: 1252.0000000000000


No conversion whatsoever results.
Elapsed time over: 100000000 iterations: 389.00000000000000

Process complete

That is strange.

int(string(object)) is faster than
int(string)?

Wow. Heh, very strange indeed.

Intel Core 2 Duo E6600 (2.4GHz), latest MinGW

Debug Off:



Debug On:

Well, for anyone that needs to do a lot of operations dealing with storing ints in lists or in some other area where you've got to cast an int (or any basic data type) to an object it's much MUCH faster to create a wrapper object then to cast it to a string and store it as a string (which is an object, for those unaware.)

I figured there would be a speed difference, I just didn't anticipate the discrepancy being so large.

Core 2 Duo E6600 @ 3Ghz, 2GB RAM

Debug on:


Debug off:

My results at my work computer: (Pentium 4 2.53Ghz with 512 Mbytes of RAM)