Savage Benchmark on hp50g ??
Mike
would report the results of a 2500-iteration Savage Benchmark on it.
The program I use on my hp48gx and hp49g+ should run on the hp50g:
<< RAD TICKS 1 1 2499 START sqrt SQ LN EXP ATAN TAN 1 + NEXT
TICKS 3 ROLL - b->r 8192 / 400 2 BEEP DEG >>
where sqrt = squart root
b->r = binary to real conversion.
No arguements are required, and the program results are a numerical
value close to 2500 (would be 2500 exactly if calcs were ideal), and a
performance time in seconds.
On my hp48gx (rev. R) performs this in 117 seconds.
My hp49g+ version 2.06 performs this in 107 seconds (surprinsingly
slow).
My hp49g+ when it had the original ROM version 1.20 performed this in
97 seconds.
Thanks,
Mike
Heiko Arnemann
thank you for your benchmark
news:1153590931....@m79g2000cwm.googlegroups.com...
> << RAD TICKS 1 1 2499 START sqrt SQ LN EXP ATAN TAN 1 + NEXT
> TICKS 3 ROLL - b->r 8192 / 400 2 BEEP DEG >>
First, the program for the 49g should be with reals instead of
zints, after ASCII transfer it shoul look like this:
%%HP: T(3)A(D)F(.);
\<< RAD TICKS 1. 1. 2499.
START \v/ SQ LN EXP ATAN TAN 1. +
NEXT TICKS 3. ROLL - B\->R 8192. / 400. 2. BEEP DEG
\>>
> On my hp48gx (rev. R) performs this in 117 seconds.
>
> My hp49g+ version 2.06 performs this in 107 seconds (surprinsingly
> slow).
>
> My hp49g+ when it had the original ROM version 1.20 performed this in
> 97 seconds.
The result on hp 49g+ depens on flag settings, too, I assume.
my flags:
%%HP: T(3)A(D)F(.);
{ # 4071257920090719220d # 0d # 9230128673280131992d # 0d }
my result ROM 2.05-4:
within 64 s.
By the way, your prog modifies the flag settings (RAD.. DEG) :-)
Best regards
Heiko
Mike
> First, the program for the 49g should be with reals instead
> of zints,
> ...
> my result ROM 2.05-4:
> within 64 s.
Hi Heiko,
Thanks very much for the reminder about zints on the hp49g+. I'd
forgotten all about that!
After adding the decimal points to the appropriate values to change
from zints to reals (which will be done automatically if the hp49g+ is
in "approximate" mode before writing and saving the program), my Savage
Benchmark now reads:
<< RAD TICKS 1.
1. 2499. START sqrt SQ LN EXP ATAN TAN 1. + NEXT
TICKS 3. ROLL - b->r 8192. /
400. 2. BEEP DEG >>
where sqrt = square root, b->r = convert binary to real.
Now my hp49g+, ROM version 2.06, performs the benchmark in just a
little more than 64 seconds, just as you reported. That's much better,
but it's still only about 1.8 times faster than an old hp48gx.
Typical results: 2499.99948647, 64.28 seconds.
It makes no difference in results if the hp49g+ is in exact or
approximate mode, if the program has been written to use real values
and not zints.
It will be interesting to read how the hp50g compares to the hp49g+, if
someone will post that info.
Best regards!
Mike
tta...@elp.rr.com
64.4040527344
in approx mode
VER
4.20060106
VERSION
"Version HP50-C
Revision 2.08"
Mike
> 2499.99948647
> 64.4040527344
> ...
> "Version HP50-C
> Revision 2.08"
Thanks! It appears that the hp50g and the hp49g+ operate at exactly
the same speed. I was hoping that more of the internal programming of
the hp50g would have been converted to run "native" on the ARM
processor for a better speed advantage.
Best regards!
Mike
Gene
Gene: if you want it to run faster, get the clock speed adjustment
program off www.hpcalc.org.
Clock up the processor speed from 75Mhz to 100, 150, or even 203Mhz and
it will run faster.
The utlity allows you to programmatically adjust the speed up at the
start of a program and then back down at the end of a program.
Heiko Arnemann
...
> Now my hp49g+, ROM version 2.06, performs the benchmark in just a
> little more than 64 seconds, just as you reported. That's much
> better,
> but it's still only about 1.8 times faster than an old hp48gx.
Yes, Corvallis made a good job with 2 MHz.
I like the improved response of the newer calcs; your
benchmark does not show it, but my feeling tells me
it is a big improvment in speed.
> It makes no difference in results if the hp49g+ is in exact or
> approximate mode, if the program has been written to use real values
> and not zints.
Oh, yes, thanks for cleaning my brain ;-)
> It will be interesting to read how the hp50g compares to the hp49g+,
> if
> someone will post that info.
Best regards
Heiko
Jean-Yves Avenard
> Hello Mike,
> thank you for your benchmark
> news:1153590931....@m79g2000cwm.googlegroups.com...
>
>> << RAD TICKS 1 1 2499 START sqrt SQ LN EXP ATAN TAN 1 + NEXT
>> TICKS 3 ROLL - b->r 8192 / 400 2 BEEP DEG >>
>
> First, the program for the 49g should be with reals instead of
> zints, after ASCII transfer it shoul look like this:
>
> %%HP: T(3)A(D)F(.);
> \<< RAD TICKS 1. 1. 2499.
> START \v/ SQ LN EXP ATAN TAN 1. +
> NEXT TICKS 3. ROLL - B\->R 8192. / 400. 2. BEEP DEG
> \>>
You can also use binary integers for loops in the 49g+:
#1d #2499d FOR I
Khanh-Dang
> I like the improved response of the newer calcs; your
> benchmark does not show it, but my feeling tells me
> it is a big improvment in speed.
This is because the "savage benchmark" is particularly focused on
real numbers complex operations. Another benchmark based on stack
manipulation, or integer manipulations may show that the ARM calcs are
much faster. Anyway, I'm not sure and I cannot test, as I don't own any
ARM calc, but it's just a guess...
ME
You've got to understand that the hp50 was in response to the poor design of
the hp49g+. This was their foremost concern and not adding new features. IF
they have solved the belt breaking , the keybounce problems ,the keys
breaking and the paint rubbing off (the main ones) then they would have made
a great stride forward ( for hp these days). If you just keep in mind the
following:
*The hp50g really is what hp made you think that you were paying for when
you purchased your 49g+. Now you get to pay them twice!* What a business
model Turn blunders into profit!
"Mike" <kk...@earthlink.net> wrote in message
news:1153612737.1...@s13g2000cwa.googlegroups.com...
Claudio Lapilli
Mike wrote:
> Now my hp49g+, ROM version 2.06, performs the benchmark in just a
> little more than 64 seconds, just as you reported. That's much better,
> but it's still only about 1.8 times faster than an old hp48gx.
My own benchmarks done a while ago (when the 49G+ was just released in
2003) seem to show that the emulated saturn speed is between 1.6 and
2.1 times the original, depending on the type of application you are
running.
Memory intensive applications emulate 2.1 times faster and
calculation-intensive aplications at 1.6 times faster, probably due to
the very slow memory access times in the original Saturn compared with
the ARM, and also due to the overhead of doing BCD calculations in the
ARM architecture.
But this is in *PURE* saturn assembler. SysRPL programs run much faster
due to improvements in ROM routines, but also depending on the type of
application you are running. The more memory-intensive should run
faster (lots of routines were converted to ARM), while the more
calculation-intensive should approach the 1.6 to 2.1 figures I got,
which seems to hold true for your benchmark.
Claudio
Claudio Lapilli
int main()
{
double f;
f=1.0;
while(f<=2499.0)
{
f=sqrt(f);
f=f*f;
f=log(f);
f=exp(f);
f=atan(f);
f=tan(f);
f+=1.0;
}
sat_push_real(f);
return 0;
}
This little program, compiled and stored as a variable 'SAVAGE' and ran
with the following wrapper:
<< TICKS 'SAVAGE' PrRUN TICKS ROT - B->R 8192 / >>
reports about 2.7 seconds (it varies between 2.3 and 2.9), and the
result is:
2499.
Notice that there's no apparent rounding error (probably the error was
< 10^-12 and was truncated when converted to 12-digit real), and also
that the loop was executed only 2499 times, because apparently the
number was slightly *above* 2499.0 in the last iteration, contrary to
what happened in the userRPL version.
BTW, the above results correspond to the calculator running in SLOW
mode (12 MHz). Adding a sys_slowOff(); at the beginning of the program
(with the corresponding sys_slowOn(); at the end), executes the
benchmark in only 0.5 seconds, but varies between 0.3 and 0.8.
0.5 compared to 64.0 = 120 times faster than userRPL, and in slow mode
it's only 23.7 times faster.
Claudio
bokubob
> Thanks! It appears that the hp50g and the hp49g+ operate at exactly
> the same speed. I was hoping that more of the internal programming of
> the hp50g would have been converted to run "native" on the ARM
> processor for a better speed advantage.
How much faster would it be? Would it be faster than just bumping up
the clock speed on the ARM chip? How many less cpu operations would be
involved?
-Jonathan
aplnub
2499.99948647
1.09875488281
aplnub
I ran your program: << RAD TICKS 1 1 2499 START sqrt SQ LN EXP ATAN TAN 1 + NEXT
I used the Don't Panic HD skin.
1.1 seconds seems to be the average time to run the program. If you have an iOS device I highly recommend m48+.