PureBasic Forums - English

Funny you get the same purebasic results with print and without :roll:

Yeah, but the first time it's with 250000 drops and PRINT. The second time it's with 10 000 000 drops and without PRINT. So you get an idea how much performance is lost when using PRINT commands.

Absolutely. And afterall, pb beats bmax, so im happy
Nice tests, btw.. Better than those iteration loops

I'll do another PI calc-benchmark. This time I'll use Bailey-Borwein-Plouffe. Don't know when it'll be read though.

Ok, the last one for today: http://www.kudoscry.com/public/bbp.zip

PureBBP - PureBasic4.0beta7 - 7680 Bytes
Iter: 0001000 :: Time: 0000 m/secs
Iter: 0010000 :: Time: 0000 m/secs
Iter: 0050000 :: Time: 0031 m/secs
Iter: 0100000 :: Time: 0062 m/secs (coincidence?)
Iter: 0500000 :: Time: 0313 m/secs
Iter: 1000000 :: Time: 0449 m/secs
Iter: 5000000 :: Time: 1844 m/secs
Iter: 7500000 :: Time: 2562 m/secs
Iter: 9999999 :: Time: 3360 m/secs

BBPmax - Blitzmax1.12demo - 51200 Bytes
Iter: 0001000 :: Time: 0001 m/secs
Iter: 0010000 :: Time: 0011 m/secs
Iter: 0050000 :: Time: 0060 m/secs
Iter: 0100000 :: Time: 0120 m/secs (coincidence?)
Iter: 0500000 :: Time: 0492 m/secs
Iter: 1000000 :: Time: 0744 m/secs
Iter: 5000000 :: Time: 2883 m/secs
Iter: 7500000 :: Time: 4347 m/secs
Iter: 9999999 :: Time: 5720 m/secs

With 16 digits, PI should be: 3.1415926535897932
PB after 9999999 iterations: 3.1415926535897931
BM after 9999999 iterations: 3.1415925277860772
Both use doubles...

Have fun
I wonder what you guys got like

Well, here is mine - with Pentium M 1.70 GHz, 2 GB RAM (heavy loaded with 92 processes).

PureBBP ( PB4B7 ) - 7680 Bytes
Iter: 0001000 :: Time: 0000 m/secs
Iter: 0010000 :: Time: 0010 m/secs
Iter: 0050000 :: Time: 0050 m/secs
Iter: 0100000 :: Time: 0090 m/secs
Iter: 0500000 :: Time: 0441 m/secs
Iter: 1000000 :: Time: 0871 m/secs
Iter: 5000000 :: Time: 4386 m/secs
Iter: 7500000 :: Time: 6580 m/secs
Iter: 9999999 :: Time: 8763 m/secs

BBPmax ( BM1.18 ) - 54272 Bytes
Iter: 0001000 :: Time: 0001 m/secs
Iter: 0010000 :: Time: 0013 m/secs
Iter: 0050000 :: Time: 0057 m/secs
Iter: 0100000 :: Time: 0112 m/secs
Iter: 0500000 :: Time: 0560 m/secs
Iter: 1000000 :: Time: 1126 m/secs
Iter: 5000000 :: Time: 5604 m/secs
Iter: 7500000 :: Time: 8441 m/secs
Iter: 9999999 :: Time:11252 m/secs

Fred, hope you don't mind but it's "nonsense" not "non-sens"

Very heavy loaded machine:

pb: 9999999 iterations: 2985 ms (nope i didnt round it thats the result

bmax: 9999999 iterations: 5151 ms. (but the result is WRONG!!! why ?)

Guys, no more floats, but comparatives with arrays and integers calculations only.
Perhaps PB loss in that! :roll:

Psychophanta wrote: Perhaps PB loss in that! :roll:

Better dont write such nonsense or i will hope, even pray for, that David Hasselhoff will hunt you in your dreams! (without trousers )

Hee! thefool, lets be realists: scientific method, i.e. observation, comparation... and see evidences.
Then, if PB is slower press Fred threating him to send a D. Hasselhoff gift to his dreams. hehehe!

Psychophanta wrote:Hee! thefool, lets be realists: scientific method, i.e. observation, comparation... and see evidences.
Then, if PB is slower press Fred threating him to send a D. Hasselhoff gift to his dreams. hehehe!

hehe
Yeah... FRED:

If you dont make pb faster than blitz max, i will blackmail you with pictures of David Hasselhoff until you dream about him!

PB is Faster already so where is the problem, and BMax even doesn't calculate correct they should shame themselves

No, I'm afraid but PB is NOT faster anymore. I enabled the auto-GarbageCollector and uploaded both tests in one zip file: http://www.kudoscry.com/public/test.zip

Here are the test results:

MonteCarloPI

PureBasic - V4.00 beta7 - filesize: 8KB
Float
Drops: 0001000 :: Time: 0000 m/secs
Drops: 0010000 :: Time: 0016 m/secs
Drops: 0050000 :: Time: 0047 m/secs
Drops: 0100000 :: Time: 0110 m/secs
Drops: 0500000 :: Time: 0390 m/secs
Drops: 1000000 :: Time: 0641 m/secs
Drops: 5000000 :: Time: 2562 m/secs
Drops: 9999999 :: Time: 4984 m/secs

Double
Drops: 0001000 :: Time: 0000 m/secs
Drops: 0010000 :: Time: 0016 m/secs
Drops: 0050000 :: Time: 0047 m/secs
Drops: 0100000 :: Time: 0110 m/secs
Drops: 0500000 :: Time: 0500 m/secs
Drops: 1000000 :: Time: 0765 m/secs
Drops: 5000000 :: Time: 2625 m/secs
Drops: 9999999 :: Time: 4985 m/secs

BlitzMax - V1.12 demo - filesize: 50.5KB
Float
Drops: 0001000 :: Time: 0001 m/secs
Drops: 0010000 :: Time: 0008 m/secs
Drops: 0050000 :: Time: 0040 m/secs
Drops: 0100000 :: Time: 0080 m/secs
Drops: 0500000 :: Time: 0402 m/secs
Drops: 1000000 :: Time: 0638 m/secs
Drops: 5000000 :: Time: 1997 m/secs
Drops: 9999999 :: Time: 3798 m/secs

Double
Drops: 0001000 :: Time: 0002 m/secs
Drops: 0010000 :: Time: 0008 m/secs
Drops: 0050000 :: Time: 0040 m/secs
Drops: 0100000 :: Time: 0081 m/secs
Drops: 0500000 :: Time: 0393 m/secs
Drops: 1000000 :: Time: 0536 m/secs
Drops: 5000000 :: Time: 2056 m/secs
Drops: 9999999 :: Time: 3779 m/secs


Bailey-Borwein-Plouffe

PureBasic - V4.00 beta7 - filesize: 7.5KB
Double
Iter: 0001000 :: Time: 0000 m/secs
Iter: 0010000 :: Time: 0000 m/secs
Iter: 0050000 :: Time: 0031 m/secs
Iter: 0100000 :: Time: 0061 m/secs
Iter: 0500000 :: Time: 0313 m/secs
Iter: 1000000 :: Time: 0449 m/secs
Iter: 5000000 :: Time: 1813 m/secs
Iter: 9999999 :: Time: 3313 m/secs

BlitzMax - V1.12 demo - filesize: 50KB
Double
Iter: 0001000 :: Time: 0014 m/secs
Iter: 0010000 :: Time: 0014 m/secs
Iter: 0050000 :: Time: 0060 m/secs
Iter: 0100000 :: Time: 0122 m/secs
Iter: 0500000 :: Time: 0492 m/secs
Iter: 1000000 :: Time: 0744 m/secs
Iter: 5000000 :: Time: 2916 m/secs
Iter: 9999999 :: Time: 3720 m/secs


Conclusion: The GarbageCollector boosts BMX forward in the first test. The second test ran with GC already the first time so nothing has changed here.
BMX (auto-GC) seems to be on PB level speedwise. But why is PB losing on the MonteCarloPI test? It seems that BMX has a slightly faster random command (that would explain why PB is ahead the when it's just around 1000 drops - the random command is not so often called). It can't be the calculations because the BBP test computes much more and PB is ahead here. Time to go on to non-float speed testing me thinks I hope Fred will improve the speed of the compiler even more in the future, I hate to lose on Blitzers

Is it possible that PB's fixation with tiny exe's is interferring with speed?

Using around 8 kb of program is awesome (v around 50 kb for the bmax progs) but if having 12kb instead would mean greased lightning I think I would prefer the extra 4kb or so.