We carry on our series of quickbench, this time the 8-core T1 processor contained Sun T2000 will clash to Intel's brand new favourite, Solaris and Linux will sweat on them.
What we are going to practise in the 2nd sequal of first year is the elementary school math. Although, not to worry, not on a paper with pencil, but with a calculator, I mean computer. The task appears simple: we have to make sure whether 4*2=8*1 is correct or not.
Yes, for the first look, but let's look behind the numbers.
On the left side of equation is a brand new killing machine, which has neiter weapon nor military training. It fights with teeth and nails to be joined the elite troops, which is hallmarked by such a names AMD Opteron, or the newly debuted Sun T1, also Intel's Xeon family.
As far as is concerned the guy may have a good tailwind for called Xeon in contempt of its origin: he is codenamed 'Sossaman', the low consumption (31W) dual-core Xeon processor.
This processor is the first member of Pentium M series server processors, that dual-cored as Core Duo is, but neither has feature for AMD 64 extention (EM64T), nor Hyperthreading.
There were two Sossaman processors in that machine was here, worked on 2 GHz clock signal, also 2 GB memory, two Ethernet interface, two place of harddrives, and 2x2 core of processor were inside.
Before anybody would be suspicious of a twofold vision, I disclose, there was one harddrive used, as an addition only one 80 GB, 7k2 RPM SATA one.
The other side of equation is represented by the well known Sun T2000, powered by eight 1Ghz processors, that is equivalent with one 8Ghz processor according to its manufacturer (obviously in the same architecture).
We put our notebook-educated server on the out-and-out T2000 (see its configuration in the previous article), but for our greatest surprise, the little cheeky scoundrel was fighting to its last drop of blood, instead of abasing itself.
There is another sysbench measuring on our first diagram, trying to measure memory throughput at 1 MB blocksize. The operation systems are just the same on both of the machines, Linux (the 2.6.17rc one in both cases) and Solaris 10. The only divergence was the kernel could run in 32-bit on Sossaman one, while it may run in 64-bit mode on T1, nevertheless some of the applications (e.g. sysbench) was 32-bit in both cases.
Well appears on the characteristic curves, the application must do memory operations on 32 threads for reaching the maximum memory bandwidth on Sun T2000, during this, there could be measured a very fine scaleing (linear for a while), but a lot lower throughput. There is not a lot difference between Solaris and Linux on T2000, but Solaris was a bit better over 32 threads.
Although our dual-cored 2-way processor system (Sossaman) was a lot more interesting. The curve shows exactly the reversed shape than T2000's one, we could reach maximum throughput on one thread, but keep getting reduced above this. Also, an odd man just came up on this graph, FreeBSD 7th (developement) version, will have a more interesting role in the next round.
In comparation of T2000 and Sossaman, describable, the bus-like architecture of Intel is a big disadvange for memory troughput, where the cores are in constant competition of right of traffic ruining the total output.
Let's see the same on 1kB after large blocksizes:
The diagram is a little entangled, thanks to FreeBSD 6's get on (still containing the phkmalloc thingy, was also implemented in 7 version against jemalloc).
Now the graph is really interesting, because it shows Solaris as an absolute vicorious on Sossaman (if there could be a winner at all in this artifical test), then it looks like FreeBSD 7's brand new malloc glitters afterwards, if the performance wouldn't be dropped to the level of Linux, which was the worst otherwise (according to Jason Evans, developer of jemalloc, this could be fixed by increasing the number of arenas, but I could not verify this on the test machine, because I had to give it back).
FreeBSD 6 has chosen the golden mean in this test.
That is interesting, the almost staight characteristic curve (line) of Linux shows a nice increasing nature, which is far from T2000, but it is much better than x86 version.
As we established last time, for memory benchmark's running, Solaris and T2000 is the most prefered solution. :)
Let's step to the MySQL test: I tried three different combinations, where MySQL 4.1 was a fundamental in every case.
Our first test is the usual 1-million-row HEAP table:
Well appears, Solaris and Linux perform neck and neck on both platforms (attribute that nasty break of T2000 to initial problem of pasting 64 threads).
The greatest surprise was caused by Intel's Sossaman, in spite of the fact that was designed for notebooks to put in priority the long battery time, but it obviously beats T1 through 16 thread despite the thinner bandwidth of memory, and not to lose sight of energy involved (Sun T1: about 72W, Sossaman: 31W, obviously a factor of two).
This is what happens, if we try on InnoDB tables:
This is the situation, when appears easily T1's slower processors perform worse on low utilisation: Sossaman could be faster a factor of three at identical number of clients in some cases, but the four times more client driven T2000 was even capable to provide that performance, that Sossaman with two clients. In this test, T2000 could only approach Sossaman in one case, - at 32 threads - but the gap is still significant between them.
The next one, either the last figure has also taken by InnoDB RDBMS, however, there were write operations involved as well. That test shows a huge different between them, therefore it is not really relevant (Sossaman: one desktop SATA harddrive, T2000: two 10kRPM SAS server disk).
In spite of all these facts, Sossaman performed very well with the single SATA harddrive, thanks to the small tables either.
Discernable on the previous figure, the Solaris superiority has turned back on Sossaman, for the reason that was not the right operation system, also the MySQL tunning (buffers, sync methods, etc). Dispite that Solaris, Linux and MySQL were run at the same settings (except the increasement of parallelity control parameters on T2000) either on PC and T2000. Describable, Solaris seems a bit better in case of MySQL than Linux, also Sossaman entry level than T2000.
Also describable, expects of Intel are very well advantageous with Sossaman as successor of the always 'spinning' Xeon with netburst. However, there are some features made Xeon tolerable against Opteron (64-bit, HTT), but they will supplement these defectivenesses soon to catch or defeat Opterons, then the only to do is the increasing of clock signals.
Better if AMD gets in on the act before it gets lose.