Well, it is pretty interesting that unlike Promise Company (which launched their FastTRAK100 TX4 a bit earlier), HighPoint engineers didn't deprive their 4-channel monster of the ability to work with two HDDs connected to a single cable. As a result, the four-channel RocketRAID 404 controller turned our capable of working with 8 hard disk drives at a time. But, please, do not hurry to celebrate this event. Remembering the problems with "single-cable" configurations, HighPoint engineers allowed their offspring to work with 8 HDDs only in RAID0 array, with no RAID01 support for 6- and 8-drive systems.

The controller supports Hot Spare of the failed drive in an array and Hot Swap of the drives "on the fly". However, these options work only in case the proper HS mobile racks are used. Very soon we will offer you a detailed coverage of these devices explaining what the "proper" mobile racks are.

But, let's not veer too far away from our today's hero. The controller itself looks as follows:

On the picture above you can clearly see HPT374 chip, which is the heart of the controller, the BIOS chip, "emergency" beeper and the pinout for the hard disk drives work status indicators. The four IDE cable connectors are also very pretty, as you may notice. :)

The controller is shipped in a rather big blue box:

Besides the controller card the box also contains:

• User's manual;
• Floppies with drivers and utilities;
• 4 IDE cables for two devices each.

The table below will give you an idea of the basic HighPoint RocketRAID 404 specifications:

Testbed and Methods

We ran all the tests for this four-channel controller on the same system as the one we used for dual-channel controller tests. The methodology was also the same (read about it in our Three ATA/133 IDE RAID Controllers Comparison). This approach will allow us to compare the performance of the dual-channel and four-channel controllers with one another later on.

HighPoint RocketRAID 404 controller was tested with BIOS 1.21 and drivers ver. 1.21.

Performance

WinBench99 1.2

The first test was WinBench99 1.2 as usual. You should remember from our HighPoint RocketRAID133 Controller Review that the results of HighPoint solutions in WinBench99 tests were pretty high, so do not be surprised at what you will see next :)

If you take a look at the performance of different arrays in applications, you will notice that RAID0 arrays are much slower when working with smaller files than a single drive, and in case of larger files RAID0 arrays speed up s lot leaving the single HDD behind.

The diagram above shows that the use of RAID arrays affects the performance in Business test quite negatively.

And in High-End benchmark the arrays' performance is, on the contrary, very much dependent on the array type and on the number of HDDs used in an array in case of RAID0.

In NTFS the absolute results are smaller than in FAT32, though the tendency, which we observed in FAT32 works here as well. In other words, the array type and the number of HDDs involved tells much more on the performance in High-End test rather than in Business test.

Now take a look at the linear read graphs:

JBOD (Graph)
RAID1 (Graph)
RAID0 2HDD (Graph)
RAID0 3HDD (Graph)
RAID0 4HDD (Graph)
RAID01 (Graph)

Intel IOMeter: DataBase

In this semi-synthetic pattern we will see how the controller drivers will react to the change in the writes-to-reads ratio under varying workload. The data block was taken equal to 8KB.

This is a really cool table, isn't it? :)

Do you want to know how long it took us to run all the tests for this table? The algorithm for this calculation is very simple: every cell of the table took 10 minutes to test…

Well, I love the tables, honestly, but the diagrams are traditionally more illustrative. Have a look here:

For queue=1, the arrays performance differs only when the share of writes increases.

RAID1 array speed is similar to single drive speed (JBOD), and RAID-1 is as fast as RAID0 of 2 HDDs.

The increase in the queue depth up to 16 changed the whole picture drastically. I even didn't have enough space for the legend, as the graphs were so close to one another…

Please, note that the graphs for RAID0 arrays built of different number of HDDs are terracing, so that with the increase in the number of hard drives involved, the array performance is not longer limited by the controller. On the contrary, the array of 4 hard disk drives was about to jump beyond the diagram when the writes reached 80%, but in RandomWrites mode it got too frightened of its own courage and fell down again.

The behavior of RAID1 array is also pretty curious to take a look at. In RandomRead mode (when there are 0 writes) the RAID1 array is twice as fast as a single HDD (it means that the read requests are addressed to both HDDs of the array in turns). However, as the share of write requests starts growing, the performance of these two arrays gets closer. It is absolutely logical: the share of writes grows up, and the share of reads reduces. This way the fewer requests can be split between the two drives of the array. So that the performance of RAID1 array gets closer to that of a single hard disk drive. In RandomWrite mode there is no way the reads could be split at all (there are simple no reads), and the performance of RAID1 and JBOD get equally fast.

The interesting thing about it is that HighPoint engineers didn't' apply the same approach to RAID01 array. To tell the truth, it is quite strange as RAID01 is also a mirror but with the elements being stripe groups of two HDDs and not separate HDDs. So, the performance of RAID01 array appeared equal to that of a single stripe-group (RAID0 of two drives).

With the queue depth like that you can be sure that all requests have already been sorted and that the controller demonstrates the fastest speed possible for each array (although I saw a mention of 512 queue depth in the specs for some SCSI controllers…)

This diagram shows that RAID1 is always faster than a single HDD in all modes except RandomWrites, and RAID01 is as fast as RAID0 of 2 HDDs.

Intel IOMeter: SequentialRead

This is the second synthetic pattern: RandomRead. Here the controller receives read requests (queue=4) of the varying size (from 512Byte up to 1MB).

Let's split the results in this pattern in two groups. In the first group we will compare the read speed from JBOD and RAID0 arrays:

What do we see here? Only RAID0 of two HDDs managed to double the results of the single hard drive (according to the number of HDDs used in the array), and RAID) of 3 and 4 drives failed to overcome the sacred 100MB/sec… I wish this controller could work with PCI64 or at least PCI32/66MHz…

The second group will include the results for JBOD, RAID0 of 2 drives, RAID1 and RAID01.

Well, the performance of 2-HDD RAID0 and RAID01 appeared nearly absolutely equal, just like that of RAID1 and JBOD.

Intel IOMeter: SequenctialWrite

Our next pattern is SequentialWrite. The algorithm here is the same as in the previous case with that only difference that we write into the arrays instead of reading from it.

Look how "proper" the graphs are! And I always thought that it was much easier to read reviews rather than to write them… :)

But, just as in case of SequentialRead, only RAID0 of two drives managed to increase the write speed proportionally to that of a single drive. RAID0 of 3 and 4 hard drives, were equally fast with the data block of any size, which is rather interesting.

As we see, RAID0 of two HDDs is twice as fast as a single hard disk drive, and RAID1 is fast as the latter (I am talking about the achieved maximum here). The performance of RAID01 array is quite far from being impressive: it is just a little bit faster than a single hard disk drive. It must be the necessity to perform the mirroring twice (as we mirror the stripe groups).

Intel IOMeter: WorkStation

This pattern emulates the user's work with different applications under NTFS5:

Let's pass over to the diagram right away:

The terraces, which we have already seen above catch our eye immediately: I am talking about the RAID0 graphs. The equal distance between RAID0 graphs indicates perfect scalability of the controller (i.e. the absence of "weak spots").

It is very interesting that RAID01 array proved faster than RAID0, and RAID1 array appeared even slower than a single HDD at first (at smaller queue depth). However, as the queue got bigger, it left JBOD far behind, so that its performance was just a little slower than that of RAID0 of 2 HDDs.

Intel IOMeter: StorageReview Patterns 2002

Well, let's see how the controller managed to cope with the patterns emulating the work of file- and web-servers:

Again, the diagrams will show us more:

In both: FileServer and WebServer patterns the controller proved highly scalable in RAID0, very fast in RAID1 (note that RAID1 is faster than 2HDD RAID0). It is especially noticeable in WebServer pattern! :)

As we remember, this pattern has no write requests, and the reads can be split between the two drives of a mirrored pair. Unfortunately, HighPoint software developers applied this technique only to RAID1 array, and RAID01 kept working as usual… Therefore, its performance turned out as fast as that of RAID0 of 2 drives. By the way, you cannot see the graph for 2HDD RAID0 array on the WebServer diagram because it is right under that of RAID01. On the one hand it illustrates that HighPoint engineers have something to work on, and on the other it proves how exact out measurements are :)

Conclusion

Four-channel HighPoint controller proved very fast in all our tests. Its performance in RAID0 array was highly scalable depending on the number of drives the array was built of. The implementation of RAID1 also proved nearly brilliant: in some modes RAID1 built with HighPoint RocketRAID 404 managed to outpace RAID0 of two drives. Unfortunately, I have to admit that RAID01 is not as successfully implemented by RocketRAID 404 as other arrays, so HighPoint software guys still have something to work on :)

Of course, we didn't manage to cover everything in this review. For instance, we didn't test RocketRAID 404 with 8 HDDs. In fact, it would be incorrect to say that we didn't test this. We do have the results for 1-8 HDDs working with HighPoint RocketRAID 404, but these were taken with different hard disk drives (DTLA 307015) and with the older BIOS version. As soon as I noticed how big the difference is depending on the driver version, I stopped testing… Hopefully I will be brave enough to do everything anew…