Forums | MacLife

I think this would be a better test with writing an actual C program. That way you have complete control over the algorithm used on all the systems, as well as the compilation. (as in having the same code on all systems, instead of different implementations)

ivanjs wrote:

PowerMac (2002 Quicksilver model) Dual 1 Ghz CPUs (Jaguar)
Approx. 9 minutes 1 second

PowerMac (2002 Quicksilver model) Dual 1 Ghz CPUs, (Tiger)
Approx. 2 minutes

That tells me just about all I need to know about that "benchmark" right there.

,xtG
.tsooJ

SpacemanSpiff wrote:

FYI: 58 seconds in OS X on 2.16

Hey, SS-thanks for the time post. Good time by the way!

Here's the shell script if anyone wants to try it:

time bc -q -l << EOF
scale=5000
4*a(1)
quit
EOF
exit 0

There's probably a shorter way to write it, but it worked for my purposes.

0wnd !! keep up the good work akb

akb825 wrote:

ivanjs wrote:

akb825 wrote:

I think this would be a better test with writing an actual C program. That way you have complete control over the algorithm used on all the systems, as well as the compilation. (as in having the same code on all systems, instead of different implementations)

Well, um, actually it was the same code across all machines...

No it is not. It is a shell script, which calls a utility. That utility does not necessarily use the same code across all systems. In fact, the fact that other operating systems vary that much across systems tells you that it doesn't use the same code for the utility. This means that this test is 100% BS and highly dependent on the implementation of bc.

For a true test. you would need to make a C program and compile it using GCC, with the same flags across systems. You could use sin/cos/tan type functions. You could either try to imitate what they're using, or you can do something that's simpler to code. (something like calculating sine with a taylor expansion out to a ridiculous number of spaces, etc.)

Feel free to write your own-it works for what I was trying to show and all the people who have posted their times so far. It's not an indication of computer speed so no need to get upset.

Last edited by ivanjs (2006-04-27 2:51 pm)

akb825 wrote:

For a true test. you would need to make a C program and compile it using GCC, with the same flags across systems. You could use sin/cos/tan type functions. You could either try to imitate what they're using, or you can do something that's simpler to code. (something like calculating sine with a taylor expansion out to a ridiculous number of spaces, etc.)

But then, on different processors, the code would also be totally different (intel binary vs powerpc binary for example). And since ALL compiled programs compile to different binaries on different platforms, aren't we back to the code being different across platforms?

This is just a simple test showing how the bc calculates at different speeds, not an indication of computer speed.

Different (binary) code vs. different algorithm. Big difference.

,xtG
.tsooJ

To clarify, when I was talking about code, I was talking about the algorithm, or more generally, the code that is then translated into machine instructions in the most optimal way possible. (probably written in C, or possibly C++, for bc) That won't change between processors, as the algorithm stays the same. Of course the binary code would be different, as it must be. However, will be comparable. The problem with the script is that you're calling a pre-made algorithm, which would have different C code across OSs. Over the weekend when I have time, I might write some sort of benchmark that can be run completely in the cache. With that, memory speeds would be pretty much moot, as it will benchmark 3 things:
1. the ability of the compiler across the OSs and platforms
2. the speed of the processor itself
3. how quickly the OS switches processes, since unless something is done nearly instantaneously, it isn't going to stay on the processor and cache for the entire runtime of the process.

Sometimes running only 1 thread is useful for benchmarking: it tests the speed of the processor itself. The fact that it doesn't use 200% is because of the fact that it only has 1 thread, which means that it can only use 1 CPU. (or core, which is almost the same thing)

They come out with new versions of things all the time. They likely use the same version as FreeBSD, or they might have written their own as in Darwin. Regardless, they likely found a better algorithm than what they were using (which was obviously not very good) for, I'm assuming, representing and doing operations on very high precision numbers. If they made their own version for Darwin, though, I wouldn't be surprised that it's not as good as other platforms and is being updated, since it's a rather new OS.

In this case, the test is speed, not correctness.