World: r3wp

I said a looong time ago that we would, when R3 reaches beta, require 
a much larger number of developers to move forward. When extensions 
and host are properly released, this will still be the case.

Henrik, you've used R3 more than I have, I think. Do you remember 
my work on FITS files in the spring from my visit to the telescopes 
at Tenerife? I made images from the 16MB FITS files using R2. It 
took 1-2 minutes to compute one file, where it takes less than a 
second if using C. How do you think, R3 perform compared to R2, when 
it comes to brute force calculations?

If it's math heavy it will probably be around the same. If you use 
graphics, the better scalability of having many GOBs will help speed 
up certain operations. DRAW is currently around the same speed. If 
you use it as a C extension, then you will of course get C speeds. 
There are a few tricks in R3 to reduce the need for copying as well 
as some functions that have gone from mezzanine to native.

I made a quick test to compare calc performance between R2 and R3. 
A 10'000'000 loop of some simple + * and /. It took around 17 seconds 
using R2, and 27 seconds using R3. If this is not changing, then 
I will probably continue to use R2 more than R3.

The key is that if we want real speed, we can do it in C now.

Please post an example.

a: 1. b: 2. dt [loop 10000000 [a + b * a / b]]

I tested on an iBook. It might be different results under Windows!?

I didn't know there was a PPC version of R3.

You maybe forgot? :-)
http://www.rebol.com/r3/downloads.html

Seems like there's a newer version, than what I have installed. I'll 
try the newer one...

It takes 55 seconds in R2 and 64 seconds in R3 here.

There might be some math changes that BrianH knows way more about 
than me.

But don't forget that extensions are precisely for such cases and 
R3 is way ahead of R2 here.

I got same result with latest PPC version of R3, 27 seconds.

So we can expect R3 to be slower than R2, when it comes to calculations? 
hm

Yes, the say to go with heavy calculations is probably to get some 
C code written somehow, and then just use REBOL as the control program.

we can expect

 - no, I think we can expect a reasonable explanation to the slowdown 
 and possibly a fix, when we get to that point.

the *way* to go

yes

I don't think Carl wants to complicate R3 with fast maths that could 
be done smaller and faster as a C extension anyway.

My results
R3
>> a: 1. b: 2. dt [loop 10000000 [a + b * a / b]]

== 0:00:05.575825

R2
>> a: 1. b: 2. dt [loop 10000000 [a + b * a / b]]
== 0:00:03.590101

What computer?

Geomol: "So we can expect R3 to be slower than R2, when it comes 
to calculations?"


No, I wouldn't expect R3 to have slower calculations. From what Carl 
has said, the R3 Alphas are not optimised for speed when compiled.

That might be the reason.

An older MacBook Pro - 2.4Ghz Intel Core 2 Duo

It's interesting, that the difference is large when running under 
OS X, and just a few percent when running Windows.

I tested mine under VMWare, so that's a third environment.

The money! datatype calculations are much slower, I guess that is 
the price of accuracy:


>> a: $1.00  b: $2.00 dt [loop 10000000 [a + b * a / b]]
== 0:00:15.957041

I not surprised that the Windows R3 Alphas run better than the Mac 
ones. Carl seems to develop for Windows and then ports to Mac and 
Linux in between "development phases". I think the more we report 
Mac bugs and issues in CureCode the more likely we are not to end 
up with a crippled R3 on Mac.

The documentation state, money! datatype uses standard IEEE floating 
point numbers. That can't be right.
http://rebol.com/r3/docs/datatypes/money.html

The docs appear to be missing the warning that they still  show the 
R2 docs.

Geomol, sometime I felt frustrated by the long time REBOL3 took to 
be developed but now I see the light out from the tunnel and it is 
not the train running against us !

REBOL3 has been rewritten from ground upp with high skills and few 
resources. This mean it needs time to be completed but it will be 
like a good wine.

I ran the calculation test under Windows/XP using VirtualBox. It 
took 5.009 seconds compared to 5.575825 seconds run natively under 
Mac OS X.

Actually we are in the state where all developers should wait for 
the core to be completed. In beta stage they will be able to operate 
and cooperate to extend it.

Keep the faith !

I also ran the calculation test with R2 under Windows/XP using Virtual 
Box it took 4.368 seconds.


As native R2 on Mac OS X is faster than Windows R2 running under 
emulation, it looks as though the issue is the that the code is yet 
to be optimised.

Giuseppe: I think it would be better if more developers could test 
the R3 alphas and report bugs and issues rather than just wait.

PeterWood, I think that only a little step further is needed to have 
this. Developers want R3 to be used in REAL world scenario and do 
testing for passion; this is called "motivation". Even Carl admits 
the situation.  When CGI support, VID, and extension will be finalized 
expect an huge boost into test and debugging.

Geomol, the manual was converted from the Core 2.3 manual, and most 
of the pages still reflect that. For types where the semantics have 
changed, the manual pages usually aren't updated until the semantic 
changes are finalized. This is not the case with money! yet, so the 
page hasn't been updated.

In other words: You are right, the docs are wrong.

Geomol: the http://www.rebol.net/wiki/Moneypage is accurate (AFAIK), 
so the doc needs to be
updated in accordance with that.

Thanks, Ladislav.

The money! datatype calculations are much slower, I guess that is 
the price of accuracy

 - the money! datatype is implemented in software, while the decimal! 
 datatype is implemented in hardware (FPU).

Geomol, all the work on R3 was not about improving the runtime (host 
code)... as much as the language (the core dll).


improving the runtime is easier/faster cause decisions are either 
obvious or straightworward.  work on the core is both tedious, highly 
philosophical, and complex.  add one assembly instruction to functions 
evaluation and you've slowed functions down 50%, everything design 
Carl changes, basically cause side-effects else where, its a very 
organic process.


I see it like a closed system, where the slightest change causes 
feedback where you have to stop everything and start again, until 
the system is balanced and doesn't feedback.  then you add another 
thing to the system.

the host is a totally different beast.  once a few of us have the 
host code and start hitting it with "applied" code, 2 things will 
happen IMHO:


* The core work will start to shift from "completing" R3 (architeture) 
to "finishing" it. (bugs, optimisations, docs, etc).


* R3's theoric usability (which is what pekr keeps refering too ;-) 
will be replaced by more and more "applied" usability, what you, 
I, and many others have been actively refering as "a working" version 
of R3.

This "closed system" has nothing to do with source availability, 
of course. As an example, value lookup from words associated with 
function! contexts is 28% slower that of object! contexts, just because 
of the addition of one instruction for stack indirection.

it seems the word "closed" is too closely coupled to souce in CS.... 
by "closed system" I do put the emphasis on "system"  as in a chaotic 
system, like a complex frequency modulation patchbay or a closed-circuit 
video system where a monitor is in the view of the camera.

souce=source

Just trying to head off another useless, off-topic source licensing 
flamewar :(