Let’s take a look at the performance difference between various arrays when the workload equals 1 outgoing request (the situation closest to reality):

To make the diagrams easier to read we decided to mark all RAID0 arrays with the same color.
Despite this fact you can easily distinguish between the RAID 0 arrays with different number of HDDs:
the arrays made of more drives are closer to the top of the diagram (come first).

Of course, with only 1 request workload we didn’t see any scalability of the read speed depending on the number of hard drives in the array in a single thread (application). A single HDD and RAID 1 array performed equally fast, and RAID 10 array outperformed even RAID 0 of 4 HDDs… And it happened not because RAID 10 read successfully from all disks of the array at a time, but because RAID 0 array failed to perform better. Looks like neither the controller, nor the hard drives support aggressive read ahead feature.

However, when we moved to two simultaneous threads, there was a surprise waiting for us: RAID 1 sky-rocketed!

Two threads got split ideally between the two drives of the array and the read speed almost doubled. Of course, in case of two threads the HDD heads have to keep moving all the time between the two working zones, so you’d better forget about high linear read speed from the array in this case. But what about the read ahead function, which serves for these particular situations? Unfortunately, the hard disk drives we used in our test session are optimized for server needs, i.e. the main objective is to ensure short access time. So, the bigger chunks of data the HDD is going to “swallow” upon each read request, the more time it will require to process random requests.

If we turn to the results tables above we will see that if the workload exceeds 1 outgoing request, the arrays start performing much faster: it is either the TCQ of the hard drives or the requests optimization of the controller. The requests sent to the drives start looking more like linear reading.

In case of three and four simultaneous threads we see very clear scalability of the RAID 0 array speed from the number of HDDs in the array.

Let’s see what we’ve got during sequential writing:

And when we write data, the worst results were demonstrated by the mirrored arrays: almost in all test modes these arrays appeared slower than a single HDD as well as a RAID 0 array of 2 drives.

However, RAID 0 arrays coped with the single and two threads processing very well. No wonder, since the hard disk drives we used feature very big cache buffer, which is used up almost entirely for lazy writing. In case of three and four simultaneous threads RAID 0 array performance again proves scalable depending on the number of hard drives in the array.

So, the first multi-threaded testing experiments with RAID controllers gave us a lot of food for thought. We hope you also found a lot of useful information here.