by Andrey Kuznetcov
01/25/2004 | 11:05 PM
It is not a very frequently occurring thing that the users need a RAID array in their home system, but in some cases it is simply impossible to do without it. Two most common situations when RAID array in a must are: the desire to squeeze the maximum out of your hard disk drives and the need for maximum data security. The simplest and cheapest way of making ATA HDDs work in this mode is to take a mainboard with the integrated RAID controller onboard or to get a PCI add-on RAID controller, which will help you create an array of the desired configuration.
There are a few choices here, and we decided to take a closer look at some of them. For our test session we took four ATA RAID controllers, which are mostly spread in the today’s market. One of them is an external PCI add-on controller card, and the other three are all onboard integrated controllers. This test session is intended to answer the question: how greatly (if at all) integrated RAID controllers fall behind the add-on ones? And of course, the results of this testing will help you make the right choice, if you really need a RAID controller today.
Anyway, this is still a very acute topic for discussion, however, in the future you may never again ask yourself this tricky question, as the RAID function tends to get soon integrated into the mainboard chipsets. But, let’s not rush ahead of time: we still need RAID controllers, so let’s find out which one is the best!
The chip from the Taiwanese VIA Company – VT6410 is a controller supporting two ATA/133 channels. It allows creating RAID 0, 1, 0+1 arrays. This solution is integrated onto mainboards on many manufacturers. In our case we will test this controller as implemented on ASUS P4P800 mainboard.
Trying to significantly enrich the features of their products, Gigabyte integrates GigaRAID ITE IT8212F controller onto some of its mainboards. This controller supports two ATA/133 channels. It allows creating RAID 0, 1, 0+1 and JBOD arrays. In our case we used Gigabyte 8SQ800 Ultra mainboard.
This is an external controller card from Promise supporting two ATA/133 channels. We have already taken a closer look at it in our Promise FastTrak TX2000 Controller Review. It supports the following disk array configurations: RAID 0, 1, 0+1 and JBOD.
This controller from Promise is implemented in their PDC20276 chip. It supports two ATA/133 channels and can work with RAID 0 and RAID 1 arrays. In our case this controller was integrated onto Albatron PX865Pro II mainboard.
Just in case you do not remember the theory behind RAID arrays of different configurations, I would like to quickly remind you a few basic things. RAID 0 (striping) implies an arrays of a few hard drives, where the data blocks alternate. By distributing the workload among the drives of the array you can increase its reading and writing speed. RAID 1 (mirroring) configuration implies that the HDDs work in pairs, where one HDD duplicates the info stored on the second one in the pair, thus ensuring its higher security. RAID 0+1 array, which is a combination of RAID 0 and RAID 1, ensures both: higher performance and higher data security. When the RAID controller works in JBOD mode (just a bunch of drives), which is also known as spanning, it means that there are one or more HDDs connected to it, which can be accessed as a single array (the data is saved to each HDD until it is full). However, JBOD doesn’t boast any advantages over a single HDD in terms of performance or data security.
We can evaluate the performance of ATA RAID controllers only according to the performance of the disk array. For this purpose we created RAID 0 and RAID 1 arrays of two Hitachi 180GXP 120GB hard disk drives (IC35L120AVV207-1 model) and then ran all the tests for these two arrays.
Here is a list of programs we used for our test session:
The testbed was configured as follows:
With the help of DataBase pattern we will test the performance of our HDDs when they process requests with different queue depth and varying share of writes.
As usual, to offer you a more illustrative picture we made three graphs for the queue depth equal to 1, 16 and 256 requests.
Let’s start our investigation with RAID 0 configuration:
On the graph with linear workload you see that the controllers got split in two pairs regarding the influence they exert over the RAID array performance. ITE IT8212F and VIA VT6410 got defeated by both Promise controllers in situations with low share of writes among the processed requests. However, as the share of writes starts growing, and reaches 70%, the former losers outperform the rivals from Promise. In fact, the similar results both controllers demonstrate here caught my eye immediately. The two Promise controllers also run very close to one another, although TX2000 gets a little ahead of the counterpart as the share of write requests starts growing. I could conclude that this RAID array runs the fastest of all when we have only write requests to be processed.
The next graph shows how our RAID array behaves when the queue depth increases to 16 requests. The situation is a little bit similar to what we have just seen in the previous case. Again we see that the controllers perform similarly: we have two pairs again.
The results demonstrated by this RAID array with all the testing participants are considerably higher than those we saw under linear workload. I would also like to stress that the performance of our RAID array grows up as the share of writes increases. The array starts running faster when working with ITE IT8212F and VIA VT6410 controllers, rather than Promise controllers, when the share of writes reaches 80%. Among the Promise solutions, TX2000 starts outpacing the 133Lite counterpart with the growth of the writes.
The maximum queue depth reflects all the changes in the performance of our RAID array. Although the “paired influence” of the controllers on the disk subsystem performance is still evident, the situation we observe here differs greatly from what we saw on the previous graph. The RAID array simply dashes forward with Promise controllers. In case of low writes share they prove much faster than the other two controllers.
After that as the writes share keeps growing, the array performance first drops and then rises again as soon as we reach 90% writes. In case of ITE IT8212F and VIA VT6410 controllers, the RAID arrays speeds up gradually together with the writes share increase and when it reaches 90% writes, it shows better performance than with Promise controllers.
Now let’s take a look at the performance of our RAID 1 disk drive array:
The graph showing the performance of the disk drive array with queue=1, we see almost the same picture as in case of RAID 0. The performance is very close to what we have already seen, and the influence of two controller pairs is also similar. The duet from Promise looks more efficient when the share of writes is not that big yet and starts yielding to ITE IT8212F and VIA VT6410 controllers when the writes share reaches 70%.
The increase in the queue depth to 16 requests leads to array performance increase with all controllers. The most noticeable improvement takes place by Promise controllers: RAID array runs fastest of all in case of 100% reads, and then its performance starts going down as the share of writes increases. As soon as disk drive array starts processing only write requests, ITE IT8212F and VIA VT6410 controllers take the lead in terms of efficiency.
The most extraordinary situation with RAID array participating in our test session happen when it was working with 256 request queue: the performance grew up in all four cases compared to the previous graph. Again we see the controller run in pairs. The two solutions from Promise let the array show its best when we had no writes involved at all, then the performance starts going down, however it turns back towards improvement when the writes share reaches 90%. ITE IT8212F and VIA VT6410 controllers appeared highly efficient almost only with write requests.
In the tables below, you can find the results obtained in Sequential Read and Write patterns where we tested the ability of our disk array to work with ordered requests with linearly growing address. For a simpler analysis the best results are highlighted in blue and the worst – in red color. Moreover, we also summed the results up in four graphs below.
Let’s start with Sequential Reading:
In RAID 0 configuration the array performed slower with ITE IT8212F controller, which you can clearly see for all data blocks. VIA VT6410 controller allows disk drive array show its real best when processing small data blocks. Both Promise controllers prove highly efficient for data blocks bigger than 8KB, and let our RAID array reach its performance maximum easily.
RAID 1 array shows that VIA VT6410 controller is in a more advantageous situation than its rivals. Despite the fact that the maximum read speed is almost the same by all controllers, the array performs the fastest of all when processing small data blocks exactly with VIA VT6410 controller. The slowest one here is ITE IT8212F.
Now let’s check the situation with the write speed of our RAID array:
In case of RAID 0, the array shows its best performance with VIA VT6410 controller, which appears the most efficient this time. It yields a little bit to Promise 133Lite only during small data blocks processing. The latter, however, appears the slowest in case of large data blocks. The slowest write speed when processing small data blocks belongs to a disk array working with ITE IT8212F controller.
Maximum write speed of RAID 1 array is achieved with ITE IT8212F controller, however, at the same time this controller slows down a lot when processing small data blocks. VIA VT6410 controller helps our array show its maximum write speed with small data blocks, and the second best write speed with larger data blocks. Like in the previous case, Promise 133Lite controller loses to TX2000 as it comes to large data blocks writing.
With the help of WorkStation pattern we imitated the work of our HDDs under the workload typical of a workstation limited at 32 requests max.
Let’s check how the controllers affect the RAID 0 array performance in this pattern:
Again we can single out two pairs of almost identical lines, which reflect the influence of Promise controllers and a pair of ITE IT8212F and VIA VT6410. 133Lite and TX2000 models turn out more efficient: RAID array performs really fast in case of any queue depth except queue=1, where the results of all controllers are almost equal.
The diagram with the total performance index, you can notice that the maximum performance of the RAID array is achieved with Promise TX2000 controller, which appeared a little bit more efficient than 133Lite.
The RAID 1 array doesn’t show anything new compared to what we have just seen with RAID 0. The lines on the graph look very similar. The only difference is the overall lower results. Again Promise controllers win the race.
The overall performance graph shows that two pairs of controller run neck and neck.
When we start using 32GB logical partitions on our RAID array drives, the results grow up a bit, but the shape of the RAID 0 graphs doesn’t change. As usual, the array shows better results when working with any of the Promise controllers.
The diagram with the overall performance index you can see that the controllers within the two pairs are almost equally fast.
RAID 1 array performs a little bit slower than RAID 0, although that seems to be the only difference in the graph. Promise controllers look much better than their rivals.
The overall performance indexes again demonstrate that the controllers within the pairs perform very close to one another.
FileServer and WebServer patterns were used to test the performance of our RAID array under the workload typical of file- and web-server disk subsystems.
First of all, let’s take a look at the results our RAID array achieved in FileServer pattern:
RAID 0 array is faster when working with Promise controllers. With these particular solutions the performance growth of the array is evident even at queue=4. With ITE IT8212F and VIA VT6410 controllers the performance starts growing noticeably only when queue=16.
The overall performance indexes show that Promise controller are almost 1.5 times faster than ITE IT8212F and VIA VT6410.
The situation remains practically the same even when we shift to RAID 1.
The overall performance diagram for all four controllers working with our array, shows that the performance gets slightly better in case of Promise controllers compared with what we saw by RAID 0. ITE IT8212F and VIA VT6410 lose to their rivals even more than by 1.5 times.
Now it’s high time we passed over to WebServer pattern:
The performance of RAID 0 array is another proof of Promise controllers efficiency. They speed up the disk subsystem quite tangibly, I should say.
Integral performance coefficients show that our disk array is more than 1.5 times faster when working with Promise controllers than in case of ITE IT8212F and VIA VT6410.
When we shift to RAID 1 array nothing actually changes compared with what we have already seen in case of RAID 0. The only improvement, is that the controllers work somewhat faster compared with their performance in RAID 0.
The overall performance indexes of our RAID array indicate that the disk subsystem is 1.5 times faster when working with Promise controller solutions than with ITE IT8212F and VIA VT6410.
Well, after those synthetic benchmarks it’s high time we got back down to earth. One of the major programs illustrating the HDD performance in real applications is WinBench 99. As usual, the best results in the tables below are highlighted in blue, and the worst – in red.
Let’s consider the performance of our array arranged as RAID 0.
On the diagram for FAT32 we see that the maximum result (and we are going to select the maximum according to High-End Disk WinMark) is achieved with VIA VT6410 controller. The second and the third result belong to Promise TX2000 and 133Lite controllers. The lowest performance of our array is achieved with ITE IT8212F controller.
The use of NTFS file system in the disk drive array results into a natural overall performance reduction and hence change in the rankings. The array runs the fastest of all when it works with Promise TX2000 controller. Then follow VIA VT6410 and Promise 133Lite, in order of preference. The least efficient this time is again ITE IT8212F.
What will happen if we use only one 32GB logical partition?
The use of FAT32 file system makes our RAID array perform best of all with Promise TX2000 controller. Then we could name VIA VT6410 and Promise 133Lite controller, and the worst performance of the array is achieved with ITE IT8212F again.
Even when we shift to NTFS file system, the situation remains the same. Again the fastest performance of the RAID array is observed with Promise TX2000 controller and the slowest performance – with ITE IT8212F.
Now let’s check how the use of different controllers affects the performance of a RAID 1 array:
The FAT32 array immediately brings us a surprise. The leader here appears ITE IT8212F controller. Then the second best performance is achieved with VIA VT6410. The third and fourth positions are occupied by Promise controllers: TX2000 and 133Lite.
The tests of a RAID array built under NTFS file system doesn’t bring any changes compared with the pervious case.
Now let’s consider a more particular situation when we have a 32GB logical partition.
When we work with a FAT32 disk array the highest performance is achieved with ITE IT8212F controller. The second prize is won by Promise TX2000 and the third – by VIA VT6410. The last one in this race appears Promise 133Lite.
As soon as we shift to NTFS file system the leadership got split between ITE IT8212F and Promise TX2000. VIA VT6410 turns out less efficient here, while Promise 133Lite is the slowest.
Now we have finally come to the most realistic benchmark – FC-Test. The results obtained in this test allow us to conclude how the use of this or that controller affects the actual working characteristics of a RAID array. Testing with FC-Test has been carried out according to a standard algorithm, when we involve 5 patterns differing from one another by the number of files and their size. We performed four operations with these files. First we created files in the first 32GB partition (Create). Then the entire set of files was read from the drive (Read). Then we copied this set of files within a single partition (Copy near). And in the end we copied the entire set of files from the first 32GB logical partition to another partition of the same size (Copy far).
Let’s start with RAID 0 configuration:
The Create graph shows very well that the array runs the fastest of all when it works with VIA VT6410 controller: indisputable victory in all five patterns. The second prize can be given to Promise TX2000, which proved a little bit more efficient than ITE IT8212F. Promise 133Lite appears the slowest.
The Read mode shows that it is really hard to name the winner here. The maximum performance of the drive array is observed with the three controller models. We can only state one thing with all certainty: ITE IT8212F is the least efficient of all.
Copying files within a single partition showed that VIA VT6410 is preferable for this type of tasks. The array running with this controller appeared the fastest in all patterns. The second position is occupied by Promise TX2000, and the third – by Promise 133Lite. The very last one appears ITE IT8212F.
File copy from one partition to another shows that the situation remained just the same as in the previous case. Again VIA VT6410 is the best choice here, and the slowest of all again appeared ITE IT8212F.
Let’s see what happens with NTFS file system.
File create test shows that when we use VIA VT6410 controller the RAID array is very fast in all patterns. Then comes the second best – Promise TX2000. The third position is occupied by ITE IT8212F, and the very last one – by Promise 133Lite.
File read speed revealed only the least efficient controller of the four tested. It is ITE IT8212F, because the array worked very slowly with it. Other three models provided about the same performance.
File copy within a single partition names VIA VT6410 as a winner here. The second prize is given to Promise TX2000. The third one – to Promise 133Lite. The least efficient appeared ITE IT8212F.
Copying files from one partition to another doesn’t make any difference compared with the previous case.
Now let’s consider the results obtained for RAID 1 array:
The best at creating files appeared VIA VT6410 and ITE IT8212F. The first one turned out more efficient for large files, while the second one worked best of all with smaller files. The third position can be given to Promise TX2000, and the very last one – to Promise 133Lite.
File reading appeared equally fast on all four controllers, which doesn’t allow us naming any of them the winner. The performance gap between all four controllers is minimal in all five patterns.
File copying within a single partition is carried out faster with VIA VT6410 and ITE IT8212F controllers. Moreover, the latter is more efficient here. The performance of our array appears considerably lower when we use Promise controllers. Note that Promise 133Lite looks a little bit more attractive than its counterpart.
File copying from one partition to another doesn’t reveal any significant changes. Like in the previous case, the array performs much faster when it works with VIA VT6410 or ITE IT8212F controllers. The latter is again a bit faster, like in the previous case. And again 133Lite controller from Promise looks more attractive to us.
Now let’s consider the same RAID 1 array performing in NTFS file system:
The files are created faster when the array works with VIA VT6410 controller. The drives work a bit slower when we have ITE IT8212F. Among two Promise controllers, the TX2000 model is a bit more efficient than 133Lite.
The results of file reading are very close for all four controller solutions. Although VIA VT6410 and ITE IT8212F look a little better, as RAID array performs somewhat faster with them.
You can clearly see from the diagram that the file copy within one partition is performed faster when we have VIA VT6410 and ITE IT8212F controllers involved. Note that the latter is somewhat more efficient. Both Promise controllers are equally fast having demonstrated almost the same copying speed.
We have finally come to the very last diagram for today. The situation during file copy from one partition to another didn’t change the situation that much compared with the previous case. The array is again in the most advantageous situation with ITE IT8212F or VIA VT6410 controller, with ITE IT8212F being a little bit better still. Both Promise controllers do not make such a great impression this time: the copy speed is much lower, and we hardly see any performance difference between two of them.
Well, it’s high time we summed up all results and evaluated the highs and lows of each of the tested RAID controllers.
GigaRAID ITE IT8212F. It didn’t impress us when working in DataBase IOMeter pattern. It also worked not that convincing in FileServer, WebServer and WorkStation patterns. The results obtained in SequentialRead ranked it as the slowest of all. It managed to improve the situation a little bit in SequentialWrite, where it outperformed the rivals with the RAID 1 array. I assume that ITE IT8212F controller doesn’t suit well for RAID arrays used as a disk subsystem for servers and workstations. However, when the RAID array worked as a disk subsystem of an ordinary home PC, ITE IT8212F controller showed its real best. Although it was still behind Promise solutions when working with RAID 0 array in FC-Test and WinBench99, with RAID 1 it turned into an indisputable leader. Therefore, with all certainty I would recommend this controller for RAID 1 arrays intended to perform routine tasks.
VIA VT6410. If we were discussing the controllers in alphabetical order, this one would be mentioned in the very end. However, since it got “virtually” tied up with the previous model during our test session, and demonstrated similar characteristics, we will continue with it now.
VT6410 behaves as an outsider in DataBase, FileServer, WebServer and WorkStation Intel IOMeter patterns, just like ITE IT8212F. It performed a little better in SequentialRead and SequentialWrite patterns. In the first one it outperformed other RAID controller when working with RAID 1 array, and in the second one it also won in case of RAID 0. I have to admit that this controller is also not the best choice for workstation and server disk subsystem. However, it looks highly positive in WinBench99 and FC-Test, being the leader with RAID 0 array, and a highly efficient solution with RAID 1. That is why, I would call it a great choice for a home user.
Promise FastTrak TX2000. This controller appeared a great product in almost all Intel IOMeter patterns leaving the other controller from promise slightly behind. This way I would recommend it for work with RAID arrays in low-end servers and workstations. TX2000 loses a little bit of its advantage in WinBench99 and FC-Test, which is mostly true for RAID 1 configuration.
Promise FastTrak 133Lite. In fact, its features are very similar to those of the just mentioned TX2000 model that is why everything we have just said about TX2000 is true for 133Lite, too. I only have to stress that in almost all the benchmarks 133Lite yields a little bit to its counterpart. And of course, its functionality is somewhat limited by its “lite” nature.