SBC CPU Throughput

Loop unrolling is what I meant to say. Loop invariant code hoisting removes code that should not be in the loop to begin with because the results

obtained from executing the code does not change (invariant) with each iteration of the loop so you are just wasting CPU cycles each time it

executes inside the loop. I personally try to keep such code out of loops in the first place because as far as I know it is generally considered to

be bad programming (wastingCPU cycles and all that) and don't understand why you think it is a good idea to keep it in the loop so you can

benchmark it.

Run the program and count the digits yourself. It is a well know exercise to compute pi to way more digits that are available on any processor architecture

that I am aware of. I think the record is quite a few more than 2000 now (10^13 according to wikipedia).

> and don't understand why you think it is a good idea to keep it in the loop so you can benchmark it.

Come on.  It's not that complicated.

Johnny wanted to know how fast his new computer was.  He decided to measure how long it takes

to multiply two numbers together.  He wrote a program that did that, but it ran so fast that his

stopwatch was useless.  He got a brilliant idea.  Put the multiplication inside a loop that iterates

1,000,000 times, and time that, and divide the time by 1,000,000.  But his compiler recognized

the multiplication as loop invariant, and hoisted it out of the loop, so his program only ended up

doing one multiplication, and his stopwatch was still useless.  Finally he recognized that an

important feature of a benchmark program is that it avoids doing a calculation repeatedly in a loop.

>I think the record is quite a few more than 2000 now (10^13 according to wikipedia).

floating point doesn't get you 10^13 digits either.

I think we need to be more logical about this:

1.  Nothing is better than an accurate benchmark.

2.  But an inaccurate benchmark is better than nothing.

3.  Therefore, an inaccurate benchmark is better than an accurate benchmark.

[Adapted from a favorite sillygism ]

Come on.  It's not that complicated.

Read it again, carefully. Yes you can waste as many CPU cycles as you want to executing code over and over again

inside a loop that produces a result that never changes (that's why it's called invariant) no matter how many times

the code is run in the loop.

Why do you want to ? It serves no purpose, at all other than wasting CPU cycles.

Yep I agree that is a sillygism.

Johnny put his multiplication statement inside a loop so that his program would

run long enough for his stopwatch to be useful.  Turned out his stopwatch still

wasn't useful because the compiler hoisted the multiplication outside of the loop.

So Johnny learned his lesson and from now on insists on benchmarks that

don't involve a loop containing an invariant calculation.  

For example, Johnny would much rather benchmark a calculation of pi to 2000 digits

than he would a loop that calculates 200 digits 10 times over.

So how do they do it ?

Perhaps you have heard of arbitrary precision arithmetic ? It is available in integer and floating point libraries for

several languages and allows higher precisions than are directly supported by the native hardware and use the

native hardware to do it.

I don't believe that's how they calculate pi to so many digits (very clever algorithms I suspect, not my area of expertise)

but I'm pretty sure they do use floating point since it is normally done on a supercomputer.

> Perhaps you have heard of arbitrary precision arithmetic ? It is available in integer and floating point libraries

no, I've never heard of an arbitrary precision arithmetic library that uses floating point.

Perhaps you can show an example.