HMGforum.com

Hello,

The following link is an attempt to explain how to build Harbour 64 Bits

http://mig2soft.com/?p=206

Gracias Miguel,
como siempre con tus buenos aportes.
Espero que te encuentres bien despues del sacudón...
Saludos cordiales,
Luis Vasquez.

Nice one. Thanks for sharing MigSoft.

Can you feel the speed difference?

Gracias Luis, en realidad fue una experiencia muy fuerte, pero sin problemas.

Rathinagiri,
You notice a subtle increase in the speed of the compiled program, I need to do some comparative tests to see results.
The next step is to compile HMG, someone already did

I don't think so...

Let us know about your experiments.

Hello,

These are the results:

2010.04.04 19:51:26 Windows 7 6.1.7600
Harbour 2.1.0dev (Rev. 14264) MinGW GNU C 4.4.1 (32-bit) x86
THREADS: 0
N_LOOPS: 1000000
[ T000: empty loop overhead ]...................................0.05
====================================================================
[ T001: x := L_C ]..............................................0.05
[ T002: x := L_N ]..............................................0.05
[ T003: x := L_D ]..............................................0.05
[ T004: x := S_C ]..............................................0.05
[ T005: x := S_N ]..............................................0.06
[ T006: x := S_D ]..............................................0.06
[ T007: x := M->M_C ]...........................................0.05
[ T008: x := M->M_N ]...........................................0.06
[ T009: x := M->M_D ]...........................................0.06
[ T010: x := M->P_C ]...........................................0.06
[ T011: x := M->P_N ]...........................................0.05
[ T012: x := M->P_D ]...........................................0.06
[ T013: x := F_C ]..............................................0.14
[ T014: x := F_N ]..............................................0.20
[ T015: x := F_D ]..............................................0.11
[ T016: x := o:Args ]...........................................0.11
[ T017: x := o[2] ].............................................0.11
[ T018: round( i / 1000, 2 ) ]..................................0.25
[ T019: str( i / 1000 ) ].......................................0.87
[ T020: val( s ) ]..............................................0.22
[ T021: val( a [ i % 16 + 1 ] ) ]...............................0.39
[ T022: dtos( d - i % 10000 ) ].................................0.27
[ T023: eval( { || i % 16 } ) ].................................0.28
[ T024: eval( bc := { || i % 16 } ) ]...........................0.14
[ T025: eval( { |x| x % 16 }, i ) ].............................0.19
[ T026: eval( bc := { |x| x % 16 }, i ) ].......................0.20
[ T027: eval( { |x| f1( x ) }, i ) ]............................0.30
[ T028: eval( bc := { |x| f1( x ) }, i ) ]......................0.27
[ T029: eval( bc := &("{ |x| f1( x ) }"), i ) ].................0.27
[ T030: x := &( "f1(" + str(i) + ")" ) ]........................1.93
[ T031: bc := &( "{|x|f1(x)}" ), eval( bc, i ) ]................2.07
[ T032: x := valtype( x ) + valtype( i ) ].....................0.30
[ T033: x := strzero( i % 100, 2 ) $ a[ i % 16 + 1 ] ]..........0.84
[ T034: x := a[ i % 16 + 1 ] == s ].............................0.30
[ T035: x := a[ i % 16 + 1 ] = s ]..............................0.30
[ T036: x := a[ i % 16 + 1 ] >= s ].............................0.30
[ T037: x := a[ i % 16 + 1 ] <= s ].............................0.28
[ T038: x := a[ i % 16 + 1 ] < s ]..............................0.28
[ T039: x := a[ i % 16 + 1 ] > s ]..............................0.31
[ T040: ascan( a, i % 16 ) ]....................................0.22
[ T041: ascan( a, { |x| x == i % 16 } ) ].......................1.97
[ T042: iif( i%1000==0, a:={}, ) , aadd(a,{i,1,.T.,s,s2,a2 ]....0.66
[ T043: x := a ]................................................0.06
[ T044: x := {} ]...............................................0.08
[ T045: f0() ]..................................................0.08
[ T046: f1( i ) ]...............................................0.11
[ T047: f2( c[1...8] ) ]........................................0.09
[ T048: f2( c[1...40000] ) ]....................................0.11
[ T049: f2( @c[1...40000] ) ]...................................0.09
[ T050: f2( @c[1...40000] ), c2 := c ]..........................0.12
[ T051: f3( a, a2, s, i, s2, bc, i, n, x ) ]....................0.41
[ T052: f2( a ) ]...............................................0.11
[ T053: x := f4() ].............................................0.36
[ T054: x := f5() ].............................................0.17
[ T055: x := space(16) ]........................................0.14
[ T056: f_prv( c ) ]............................................0.28
====================================================================
[ total application time: ]....................................19.56
[ total real time: ]...........................................19.99



2010.04.04 19:25:10 Windows 7 6.1.7600
Harbour 2.1.0dev (Rev. 14234) MinGW GNU C 4.4.4 (64-bit) x86-64
THREADS: 0
N_LOOPS: 1000000
[ T000: empty loop overhead ]...................................0.06
====================================================================
[ T001: x := L_C ]..............................................0.00
[ T002: x := L_N ]..............................................0.00
[ T003: x := L_D ]..............................................0.00
[ T004: x := S_C ]..............................................0.00
[ T005: x := S_N ]..............................................0.02
[ T006: x := S_D ]..............................................0.00
[ T007: x := M->M_C ]...........................................0.02
[ T008: x := M->M_N ]...........................................0.00
[ T009: x := M->M_D ]...........................................0.00
[ T010: x := M->P_C ]...........................................0.00
[ T011: x := M->P_N ]...........................................0.02
[ T012: x := M->P_D ]...........................................0.00
[ T013: x := F_C ]..............................................0.11
[ T014: x := F_N ]..............................................0.11
[ T015: x := F_D ]..............................................0.05
[ T016: x := o:Args ]...........................................0.08
[ T017: x := o[2] ].............................................0.06
[ T018: round( i / 1000, 2 ) ]..................................0.11
[ T019: str( i / 1000 ) ].......................................0.27
[ T020: val( s ) ]..............................................0.12
[ T021: val( a [ i % 16 + 1 ] ) ]...............................0.25
[ T022: dtos( d - i % 10000 ) ].................................0.20
[ T023: eval( { || i % 16 } ) ].................................0.20
[ T024: eval( bc := { || i % 16 } ) ]...........................0.14
[ T025: eval( { |x| x % 16 }, i ) ].............................0.19
[ T026: eval( bc := { |x| x % 16 }, i ) ].......................0.12
[ T027: eval( { |x| f1( x ) }, i ) ]............................0.22
[ T028: eval( bc := { |x| f1( x ) }, i ) ]......................0.20
[ T029: eval( bc := &("{ |x| f1( x ) }"), i ) ].................0.20
[ T030: x := &( "f1(" + str(i) + ")" ) ]........................1.64
[ T031: bc := &( "{|x|f1(x)}" ), eval( bc, i ) ]................2.06
[ T032: x := valtype( x ) + valtype( i ) ].....................0.22
[ T033: x := strzero( i % 100, 2 ) $ a[ i % 16 + 1 ] ]..........0.44
[ T034: x := a[ i % 16 + 1 ] == s ].............................0.16
[ T035: x := a[ i % 16 + 1 ] = s ]..............................0.17
[ T036: x := a[ i % 16 + 1 ] >= s ].............................0.16
[ T037: x := a[ i % 16 + 1 ] <= s ].............................0.17
[ T038: x := a[ i % 16 + 1 ] < s ]..............................0.16
[ T039: x := a[ i % 16 + 1 ] > s ]..............................0.14
[ T040: ascan( a, i % 16 ) ]....................................0.16
[ T041: ascan( a, { |x| x == i % 16 } ) ].......................1.53
[ T042: iif( i%1000==0, a:={}, ) , aadd(a,{i,1,.T.,s,s2,a2 ]....0.48
[ T043: x := a ]................................................0.00
[ T044: x := {} ]...............................................0.06
[ T045: f0() ]..................................................0.03
[ T046: f1( i ) ]...............................................0.08
[ T047: f2( c[1...8] ) ]........................................0.08
[ T048: f2( c[1...40000] ) ]....................................0.06
[ T049: f2( @c[1...40000] ) ]...................................0.08
[ T050: f2( @c[1...40000] ), c2 := c ]..........................0.09
[ T051: f3( a, a2, s, i, s2, bc, i, n, x ) ]....................0.25
[ T052: f2( a ) ]...............................................0.06
[ T053: x := f4() ].............................................0.28
[ T054: x := f5() ].............................................0.14
[ T055: x := space(16) ]........................................0.09
[ T056: f_prv( c ) ]............................................0.20
====================================================================
[ total application time: ]....................................15.18
[ total real time: ]............................................15.53

"Exe files" for your tests

Nice. Thanks for sharing MigSoft.

MigSoft wrote:These are the results:
...
(32-bit [ total real time: ]...........................................19.99
(64-bit)[ total real time: ]............................................15.53

Had expected someone to double the speed? Real-life application will benefits even less, they depends mainly on the HDD throughput.