Suzanne Render Benchmark

Hey, since its turned out that the other benchmark thread is not terrifically accurate in depicting the performance difference between single and multi-core processors, I thought I’d create a new simple benchmark that should test this more accurately. This is a rather quick render - similar in times to the grass tutorial one.

So here’s the file:

And the format for posting the results. For those who’re new, 4x4 or 8x8 etc stands for Xparts and Yparts in the render settings. the time format is in mins:secs.1/100secs

OS: Fedora 64bit
Blender Version: Blender 64bit
CPU: core 2 quad q6600 @ stock 2.4ghz
RAM: 4gb ddr800

Render times:
1 thread 4x4: 02:17.35
2 threads 4x4: 01:15.96
4 threads 4x4: 00:39.45
4 threads 8x8: 00:34.25
8 threads 4x4: 00:46.31 (this is interesting - the last several seconds, there is only one thread running)
8 threads 8x8: 00:34.65
8 threads 16x16: 00:36.44

It’s a fairly steady increase in terms of performance, as 1, 2 and then 4 cores are used. Also it seems there’s not a terrific difference between using 8 threads and 4 threads in this particular case, as they both utilise all 4 cores.

Also it looks like it’s a good idea to set X and Y parts to 8 or so.

Looking forward to seeing some other results. Mainly it will be the difference between operating systems and 64bit or 32bit builds on similar setups that i’d like to see.

Sure why not, I’ll give it a go:

32bit Windows XP
SSE1/2 Optimized Blender 2.44
Core 2 Duo e4300 at 3.2Ghz (460x7)
2x1GB Memory DDR2-1066 4-3-3-8 (fatboy kit :D)

2 thread: 4x4: 51.99sec
2 thread: 2x2: 52.27sec

I wish I have a C2Q…

Nice overclock and memory timings you have there man.

Did you get any improvement in render times using 8x8 over 4x4?

4x4 02:39:86
2x2 02:37:46
os: windows vista
blender version 2.44
cpu intel core duo [email protected]
ram 2047mb
32 bit operating system

no. render time actually increased by a bit.

Those times are pretty high for that setup, are you sure you turned the number of threads up?

OS : Ubuntu Studio 7.04
CPU: AMD Athlon XP-M 2800 @ 2,37GHZ
Ram: 1024MB
Windows XP 32bit

Blender 2.44 (self compiled)

1Thread 4x4: 03:15:51
1Thread 8x8: 03:22:93

OS: Windows Vista Ultimate 64bit
Blender Version: Standard Blender 2.45
CPU: Core 2 Duo e6400; Stock 2.13GHz
RAM: 4GB DDR2 667

Render times:
1 thread 4x4: 3:30.88
1 thread 8x8: 3:38.18
2 threads 4x4: 1:50.45
2 threads 8x8: 1:55.09
4 threads 4x4: 2:00.24
4 threads 8x8: 1:53.81
4 threads 16x16: 1:56.16
8 thread 4x4: 2:03.66
8 threads 8x8: 1:54.76

Some interesting results…

OS: Debian Sid
CPU Athlon XP 2300
RAM: 2x1GB DDR2 400

Blender: Latest svn build
Render times:
1 thread 4x4: 17:14.90
1 thread 8x8: 19:20.76

Blender: Generic 2.44
Render times:
1 thread 4x4: 6:46.98
1 thread 8x8: 7:04.19

I think I might have to check my building options :slight_smile:

Glen: possibly, however i’m getting considerably higher render times with svn build too, and i know i have mine rather well optimized…they must’ve changed something.
My svn build takes about 2:20 while the 64bit 2.44 build only needs less than 1:10
System is a Core2Duo E6600 (2.4GHz) with 2GB DDR2-667 and 64bit Ubuntu 7.04, 2 threads with 4x4 parts.

Maybe broken’s new raytracing stuff has todo with that…whatever it is, there’s a whooping 100%+ performance regression.

Not my own PC but it is interesting to compare :slight_smile:
OS: Windows 2000
P4 3 Ghz Hyperthreading

1 thread 4x4 : 8:30
2 threads 4x4: 7:29


OS: Vista 32-Bit
Blender: 32-Bit 2.45
C2D Merom 2.2ghz
2GB DDR2 667 5-5-5-15

1 Thread - 4x4 - 3:11:50
2 Thread - 4x4 - 1:42:13
4 Thread - 4x4 - 1:49:35
8 Thread - 4x4 - 1:43:75

1 Thread - 8x8 - 3:13:68
2 Thread - 8x8 - 1:45:82
4 Thread - 8x8 - 1:45:08
8 Thread - 8x8 - 1:47:15

After seeing my results, as well as someone else who has a C2D, it appears 2 thread on a 4x4 and 4 threads on a 8x8 were the fastest.

Dan: A few questions for ya. What settings are on those objects in the blend file? I’ve never seen blender render like that (the pink first, then suzanne?)

Also, do you think that pagefile size could affect the results? I recently set mine to 4gbs.

core 2 quad
gig ram
ubuntu feisty fawn

1 thred, 4*4 parts: 3.04.42
2 threds, " "_____: 1.34.07
3 threds, " " ____ : 1.03.56
4 threds, " " ____ : 0.54.66

Windows XP Home SP2
AMD Athlon 64 X2 5600+ @ 2800 MHz (Liquid cooled)
2GB DDR2 PC2-5300 (2 x 1024 @ 333 MHz)
NVIDIA GeForce 8800 GTX
Asus M2N32-SLI Deluxe( nVidia nForce 590 SLI)

2 threads 2x2 01:36.06
2 threads 4x4 01:37.21
2 threads 6x6 01:38.03
2 threads 8x8 01:39.10

Specs are in my sig. I’m running on WinXP Pro SP2.

1 Thread 4x4 - 02.55.37
1 Thread 8x8 - 03.00.18
2 Thread 4x4 - 01.30.12
2 Thread 8x8 - 01.32.12
4 Thread 4x4 - 01.34.96
4 Thread 8x8 - 01.31.54
8 Thread 4x4 - 01.38.49
8 Thread 8x8 - 01.31.62

My system isn’t made for rendering, but rather gaming.


just a Q: on a dual/quads - can you test also n+1 threads? n being No. of cores.
another Q: I’m interested in AMD x2 results on 64bit linux, if possible with -O3 …sse with latest gcc and if posters also post their compiler flags thanks

I can try to load Ubuntu up on my Virtual Machine, and make my best attempt at making it equal to my current system. I don’t know about all those other things, but at least it’ll give the general idea.


i don’t have any more solid numbers, but from my extensive testing, MSVC standard builds are usually faster than GCC -O3 builds on windows. And Optimized MSVC builds are about 20% faster than GCC -O3 -march=xxx .

thanks for that VM suggestion, but I don’t think it would be a representation of actual performance. I agree though, that it would be an interesting comparison for sure!

regarding gcc-msvc stuff: hmmm, true, it isn’t relevant anymore (it was pentium III era …), but I managed to build a faster blender with gcc 3.3.4 (on 32bit linux) than AN][ARES’s ICC buid for windows (those who remember elysiun days). My results are (still?) on (look for intellistation dual p3 733), and my flags are in the antaress thread somewhere (if it is still on the server …)

Anyhow, it took me quite some time and research (not to mention testing) and I had to specify cache sizes etc. for the fastest build that didn’t render artifacts …

edit: I’m really curious to see what autovectorization does on gcc for renderspeed.

Don’t know what is the situation now, though - in fact I’ve no clue. Esp. re. how to compile and optimize for 64bit, AMD K8 (64+64+512Kb per core iirc). I hope these will be cheap and abound once the upgrade fever hits the current owners … hehe

2 threads 4x4: 2:24.48
2 threads 8x8: 2:28.29
4 threads 4x4: 2:36.86
4 threads 8x8: 2:29.85

blender 2.45
os x 10.4
g5 dual 2.7
4.5gb pc3200 ddr sdram

conclusion: my once badass machine is showing its age :frowning: