Hi Przemek,
Przemyslaw Czerpak ha scritto:
On Sat, 04 Oct 2008, Francesco Saverio Giudice wrote:
Hi Francesco,
Many thanks for your results.
Looks that there in no important difference between DL-MM and BCC-MM in
real MT programs in your system. DL has a little bit better performance.
In my test in Linux DL-MM in MT mode was killing the performance
in MT+ test in comparison to default SUSE malloc when in ST mode
it gives nearly the same results. The difference is such huge that
Harbour overhead is unimportant at all and it's even hard to measure.
So I would like to also test the performance without memory allocation
in Windows. I've just added --exclude option to which allows to disable
all tests which allocates memory in test loop.
If possible please also make this tests again using current SVN speedtst
with option --exclude=mem, f.e.:
speetst.exe --exclude=mem
It doesn't matter which memory manager you will use. You can use the
default one.
Once again many thanks for your help.
I was already compiling after your changelog ;-)
Here results:
J:\cvs\harbourSVN_trunk\tests>speedtst.exe //info
Harbour Terminal: Windows native console
Harbour 1.1.0dev (Rev. 9545)
Windows Vista 6.0.6001 Service Pack 1
DS avail=1352780KB OS avail=2064552KB EMM avail=0KB MemStat:Off MT:Off
10/04/08 21:37:25 Windows Vista 6.0.6001 Service Pack 1
Harbour 1.1.0dev (Rev. 9545) Borland C++ 5.5.1 (32 bit)
N_LOOPS = 1000000
ST MT MT+
[ empty loop overhead ]..............................0.09..0.09..0.09
=====================================================================
[ x := L_C ].........................................0.09..0.12..4.10
[ x := L_N ].........................................0.06..0.09..9.20
[ x := L_D ].........................................0.09..0.14..3.04
[ x := S_C ].........................................0.11..0.16.11.93
[ x := S_N ].........................................0.12..0.11..2.92
[ x := S_D ].........................................0.09..0.09.11.89
[ x := M_C ].........................................0.09..0.14..5.87
[ x := M_N ].........................................0.08..0.11.11.72
[ x := M_D ].........................................0.08..0.09..4.98
[ x := P_C ].........................................0.11..0.12.12.90
[ x := P_N ].........................................0.11..0.08..7.85
[ x := P_D ].........................................0.09..0.09.11.70
[ x := F_C ].........................................0.16..0.30.25.33
[ x := F_N ].........................................0.19..0.25.15.97
[ x := F_D ].........................................0.09..0.11..9.31
[ x := o:GenCode ]...................................0.27..0.30.18.50
[ x := o[8] ]........................................0.22..0.23.12.68
[ round( i / 1000, 2 ) ].............................0.23..0.31.20.40
[ str( i / 1000 ) ]..................................0.84..1.00.35.46
[ val( s ) ].........................................0.30..0.33.19.28
[ val( a [ i % 16 + 1 ] ) ]..........................0.62..0.75.23.31
[ dtos( d - i % 10000 ) ]............................0.44..0.73.37.49
[ eval( { || i % 16 } ) ]............................0.39..0.97.41.51
[ eval( bc := { || i % 16 } ) ]......................0.30..0.42.21.23
[ eval( { |x| x % 16 }, i ) ]........................0.41..0.70.34.48
[ eval( bc := { |x| x % 16 }, i ) ]..................0.33..0.44.21.68
[ eval( { |x| f1( x ) }, i ) ].......................0.50..0.92.34.41
[ eval( bc := { |x| f1( x ) }, i ) ].................0.55..0.67.24.41
[ x := &( "f1(" + str(i) + ")" ) ]...................3.01..4.40.56.18
[ bc := &( "{|x|f1(x)}" ); eval( bc, i ) ]...........3.56..5.38.60.04
[ x := valtype( x ) + valtype( i ) ]................0.51..0.81.34.01
[ x := strzero( i % 100, 2 ) $ a[ i % 16 + 1 ] ].....1.09..1.37.34.98
[ x := a[ i % 16 + 1 ] == s ]........................0.48..0.50.21.42
[ x := a[ i % 16 + 1 ] = s ].........................0.51..0.59.23.93
[ x := a[ i % 16 + 1 ] >= s ]........................0.51..0.64.21.84
[ x := a[ i % 16 + 1 ] <= s ]........................0.50..0.66.23.93
[ x := a[ i % 16 + 1 ] < s ].........................0.53..0.62.21.78
[ x := a[ i % 16 + 1 ] > s ].........................0.48..0.66.24.15
[ ascan( a, i % 16 ) ]...............................0.31..0.48.18.39
[ ascan( a, { |x| x == i % 16 } ) ]..................3.87..5.37.50.59
[ if i%1000==0;a:={};end; aadd(a,{i,1,.T.,s,s2,a2,b..1.73..2.14.38.74
[ x := a ]...........................................0.09..0.12.13.65
[ x := {} ]..........................................0.12..0.39.27.77
[ f0() ].............................................0.11..0.12.13.82
[ f1( i ) ]..........................................0.22..0.27.14.09
[ f2( c[1...8] ) ]...................................0.19..0.28.18.89
[ f2( c[1...40000] ) ]...............................0.22..0.30.14.60
[ f2( @c[1...40000] ) ]..............................0.22..0.23.18.24
[ f2( @c[1...40000] ), c2 := c ].....................0.23..0.27.15.48
[ f3( a, a2, s, i, s2, bc, i, n, x ) ]...............0.72..0.90.24.40
[ f2( a ) ]..........................................0.20..0.30.14.38
[ x := f4() ]........................................0.69..0.92.33.79
[ x := f5() ]........................................0.34..0.55.31.11
=====================================================================
[ total application time: ].........................32.40.43.04.61.12
[ total real time: ]................................33.68.44.35.33.60
J:\cvs\harbourSVN_trunk\tests>speedtst.exe --exclude=mem //info
Harbour Terminal: Windows native console
Harbour 1.1.0dev (Rev. 9545)
Windows Vista 6.0.6001 Service Pack 1
DS avail=1349184KB OS avail=2064552KB EMM avail=0KB MemStat:Off MT:Off
10/04/08 21:41:51 Windows Vista 6.0.6001 Service Pack 1
Harbour 1.1.0dev (Rev. 9545) Borland C++ 5.5.1 (32 bit)
N_LOOPS = 1000000
ST MT MT+
[ empty loop overhead ]..............................0.08..0.09..0.08
=====================================================================
[ x := L_C ].........................................0.11..0.14..2.04
[ x := L_N ].........................................0.09..0.11..8.74
[ x := L_D ].........................................0.09..0.11..0.87
[ x := S_C ].........................................0.09..0.17.10.87
[ x := S_N ].........................................0.09..0.08..8.97
[ x := S_D ].........................................0.09..0.09..9.70
[ x := M_C ].........................................0.11..0.16.10.81
[ x := M_N ].........................................0.12..0.11.10.56
[ x := M_D ].........................................0.12..0.11.10.02
[ x := P_C ].........................................0.09..0.16.11.53
[ x := P_N ].........................................0.12..0.09..9.98
[ x := P_D ].........................................0.12..0.11.10.62
[ x := F_C ].........................................0.20..0.31.14.52
[ x := F_N ].........................................0.25..0.27.14.63
[ x := F_D ].........................................0.14..0.14.10.19
[ x := o:GenCode ]...................................0.25..0.33.16.02
[ x := o[8] ]........................................0.25..0.23.13.42
[ round( i / 1000, 2 ) ].............................0.30..0.36.17.11
[ val( s ) ].........................................0.27..0.36.16.19
[ val( a [ i % 16 + 1 ] ) ]..........................0.56..0.70.20.23
[ eval( bc := { || i % 16 } ) ]......................0.28..0.39.16.91
[ eval( bc := { |x| x % 16 }, i ) ]..................0.37..0.45.18.77
[ eval( bc := { |x| f1( x ) }, i ) ].................0.51..0.61.19.08
[ x := a[ i % 16 + 1 ] == s ]........................0.53..0.61.20.06
[ x := a[ i % 16 + 1 ] = s ].........................0.53..0.67.18.83
[ x := a[ i % 16 + 1 ] >= s ]........................0.50..0.62.20.20
[ x := a[ i % 16 + 1 ] <= s ]........................0.50..0.62.18.74
[ x := a[ i % 16 + 1 ] < s ].........................0.50..0.66.20.28
[ x := a[ i % 16 + 1 ] > s ].........................0.51..0.69.18.75
[ ascan( a, i % 16 ) ]...............................0.37..0.48.19.42
[ x := a ]...........................................0.14..0.14.10.31
[ f0() ].............................................0.14..0.12.11.56
[ f1( i ) ]..........................................0.23..0.27.14.77
[ f2( c[1...8] ) ]...................................0.17..0.25.16.05
[ f2( c[1...40000] ) ]...............................0.19..0.28.15.21
[ f2( @c[1...40000] ) ]..............................0.19..0.25.16.01
[ f2( @c[1...40000] ), c2 := c ].....................0.23..0.34.15.68
[ f3( a, a2, s, i, s2, bc, i, n, x ) ]...............0.80..0.90.20.14
[ f2( a ) ]..........................................0.22..0.22.14.98
=====================================================================
[ total application time: ].........................13.49.16.36.21.26
[ total real time: ]................................13.62.16.56.10.95
Now, without memory allocations, it seems very good !
Best Regards
Francesco
_______________________________________________
Harbour mailing list
Harbour@harbour-project.org
http://lists.harbour-project.org/mailman/listinfo/harbour
