END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

I suspect that encryption algorithms are a fairly good indicator for deep-zoom fractal performance, but I don't know that for a fact. I do suspect that normal benchmarks are a poor indicator. The main requirement for fast deep-zoom fractal calculations is a fast 64x64 multiply, and fast adc instructions. I don't know how well Intel and AMD compare.

I agree that having other programs installed and running shouldn't matter, as long as they are well behaved. Task Manager can help you find those that are not.

Anyway, I wrote a benchmark program to help answer this question. It uses the same mov/mul/add/adc/adc block that FX uses so it should accurately predict deep-zoom performance in FX, and probably in other similarly optimized fractal programs.

http://ftp://ftp.cygnus-software.com/pub/InfprecPerf.exe

Aside: apparently the throughput of FX is not helped much by hyperthreads. I didn't know that.

Here are the results from my four-core eight-thread Sandybridge laptop. It nominally runs at 2.2 GHz but it can Turboboost up to between 2.8 and 3.2 GHz, according to CPU-Z. I think that means that performance is ultimately limited by the four-cycles-per-mul throughput, and that the hyperthreads merely help hit this maximum.

CPU information:
VendorID = 'GenuineIntel'
Stepping = 0x7, model = 0xA, family = 0x6, type = 0
Signature is 0x6A7 (06_0AH)
CPU's rdtsc speed is 2.195 GHz (peak speed may be higher).

Running tests on 8 thread system.
Performance with 1 threads is 0.981 GBlocks/sec
Performance with 2 threads is 1.988 GBlocks/sec
Performance with 3 threads is 2.355 GBlocks/sec
Performance with 4 threads is 2.994 GBlocks/sec
Performance with 5 threads is 3.547 GBlocks/sec
Performance with 6 threads is 3.681 GBlocks/sec
Performance with 7 threads is 3.672 GBlocks/sec
Performance with 8 threads is 3.816 GBlocks/sec

CPU information:
VendorID = 'GenuineIntel'
Stepping = 0x6, model = 0xD, family = 0x6, type = 0
Signature is 0x6D6 (06_0DH)
CPU's rdtsc speed is 3.202 GHz (peak speed may be higher).

On my six-core twelve-thread Sandybridge work machine the results are:

Running tests on 12 thread system.
Performance with 1 threads is 1.149 GBlocks/sec
Performance with 2 threads is 2.268 GBlocks/sec
Performance with 3 threads is 3.263 GBlocks/sec
Performance with 4 threads is 3.961 GBlocks/sec
Performance with 5 threads is 4.803 GBlocks/sec
Performance with 6 threads is 5.447 GBlocks/sec
Performance with 7 threads is 6.123 GBlocks/sec
Performance with 8 threads is 6.365 GBlocks/sec
Performance with 9 threads is 6.452 GBlocks/sec
Performance with 10 threads is 6.506 GBlocks/sec
Performance with 11 threads is 6.591 GBlocks/sec
Performance with 12 threads is 6.667 GBlocks/sec

The system process was consuming about 6% of CPU time, otherwise I would have hit about 7.0 GBlocks/sec.

If you have other results from different CPUs please send them to me. Note that this program is 64-bit only. As somebody observed, 32-bit performance is not really comparable. It will typically be 4-5x worse, so not very interesting.

What is it that makes the performance of multiple threads worse in proportion to one thread? Is it the turbo mode, other processes not affecting the render, or does multiple threads just inherently mean less efficiency?

Apparently rendering multiple things at once increases performance, I didn't know that.

Here's some benchmark results on my intel q6700, 4×2,66 GHz, 4 threads:

It seems this compares with the benchmark results we did using fractal extreme itself. The i7 2600 was 1,7 times faster than my q6700, and the fx-8150 was 35% faster than the i7 2600. The predictable result for the fx-8150 would be:
2,615 * 1,7 * 1,35 = 6,001425
Which corresponds exactly to the test by stardust4ever.

Bruce Dawson, which 12-thread CPU do you have, which model?

The memory subsystem should make no difference. The inner loop of FX's calculations fits entirely in the cache, so the memory subsystem and disks basically sit idle during calculations.

4.228 GHz / 0.857 GBlocks/sec on Bulldozer works out to one block processed every five cycles. That's pretty good, although Sandybridge seems to manage slightly better than that, since my work machine manages 1.15 GBlocks/sec at less than 4 GHz. Assuming that my laptop is TurboBoosting up to 3.2 GHz its 0.871 GBlocks/sec works out to one block processed every 3.26 cycles. That's 50% faster on a clock-by-clock basis.

Adding more threads beyond num-hardware-threads shouldn't help. I could try it, but I would doubt it would help.

I'm not entirely sure what makes the per-thread performance drop as #threads increases. There are three likely causes, which can interace:
1) On Sandybridge the second half of the 'cores' are just hyperthreads. They share the same execution resources with the first set of cores. Therefore they are bottlenecked by the raw execution resources. I think using both hyperthreads on a core might hide more instruction latency, which is why performance goes up a bit. Bulldozer threads are more independent, but not totally. The equivalent on Bulldozer is that the front-end is shared between two cores on the same module, so instruction decode can be a bottleneck.
2) On Sandybridge the clock speed should be reduced as load increases. On my laptop I would guess that the frequency drops as I go from one thread to four.
3) Even an 'idle' system has some housekeeping going on. When only one calculation thread is running this doesn't affect the results, but when FX tries to use all threads it starts to interfere a bit. If you don't have lots of extraneous programs running then this should normally be a modest effect.

It sounds like #3 is responsible for most of the slowdown on the Bulldozer, but it's curious that on the idle system the speed increase going from one thread to eight threads is about 7.1. I would have expected closer to 8. Maybe #1 is also a factor?

It's interesting that the six core (twelve thread) Sandybridge is slightly faster than the 8 core (four module) Bulldozer. The lower latency per block is apparently enough to make up for the higher core count and the higher clock rate.

My laptop is an Intel(R) Core(TM) i7-2720QM @ 2.20 GHz, peak is 3.2 GHz?
My work machine is an Intel(R) Core(TM) i7-3930K @ 3.20 GHz, peak is 3.5 GHz?

I haven't compared the costs, but I would guess that a reasonably fast Sandybridge with as many cores as possible is the way to go.

Just found that the processor I linked to in the previous post can't be used with 2 at the same time. I could have known that because I had read that before. I was kind of amazed to see an intel CPU like that for that price at first, but it turns out AMD is really the only option at the moment to keep the price for a computer somewhat reasonable.

This is the true alternative:
http://www.newegg.com/Product/Product.aspx?Item=N82E16819117228

$540 against $1640

Can you post these again, with the CPU ID information? I'm collecting the results and it's good to have that information, in additional the model information.

I summarized the information into a blog post which you can find here:

http://randomascii.wordpress.com/2012/03/28/fractal-and-crypto-performance/

TL;DR. Higher clock rate is better, more cores are better (Bulldozer cores count, Sandybridge hyperthreads don't), microarchitectural efficiencies make a big difference.

Let me know if you get any more results that I should add.

AVX instructions sound like a very good idea. I've read a lot of good things about that. I think it could really make rendering a lot faster in the near of far future.