Understanding endurance and performance characteristics of HP solid state drives
9
Using SSDs with Array Controllers
SSDs perform much better than HDDs in applications requiring large, random IOPS performance. This
advantage extends to the use of SSDs RAIDed behind Array Controllers. But there are some subtleties to
keep in mind, including how various RAID levels affect SSD performance differently than HDDs.
Array performance scaling with SSDs
Just as IOPS performance scales when using multiple HDDs behind an HP Smart Array controller, the
same is true for multiple SSDs. An individual SSD, of course, is capable of delivering thousands of
random IOPS compared to hundreds for the highest performing HDD. But IOPS will still scale linearly
when you add SSDs behind a Smart Array RAID controller. With typical workloads, random IOPS
performance for an array controller such as the HP Smart Array P410 scales linearly up to six SSDs.
Past this number, the performance starts to become constrained by the throughput capability of the
array controller. It can process a maximum of 50,000 to 60,000 I/O operations per second. Because
of this, we recommend a maximum of eight SSDs behind an array controller when you are using the
current generation of SmartArray controllers. This number increases significantly with the Gen8
SmartArray controllers. They are capable of processing up to 200,000 I/O operations per second.
SSDs and RAID levels
You can use SSDs with Smart Array controllers in redundant RAID configurations. In RAID 5 and RAID 6
configurations, SSDs have several unique advantages. Both RAID 5 and RAID 6 require the Smart Array
controller to perform two read-modify-write operations to the back-end array drives for every host-level
random write it executes. With HDDs, the performance penalty for using RAID 5 and RAID 6 is severe.
Each read-modify-write operation requires an extra revolution of the disk media, causing the system to
incur the worst possible latency. This is why you often use RAID 1 or RAID 10 with HDD arrays. They
achieve redundancy without suffering as great a performance penalty. With SSDs, however, there is no
rotational latency. As a result, you can create RAID 5 or RAID 6 arrays using SSDs that have about the
same performance as RAID 1 or RAID 10 arrays.
With any redundant RAID level, a host-level write operation results in multiple low-level writes to the
drives. SSD write operations typically have a higher overhead and generate more background NAND
management activity than SSD read operations. In redundant RAID configurations using SSDs, this
performance difference is magnified. A redundant array using SSDs may deliver better performance
than an HDD-based array. But the relative fall off in performance as the write load increases is greater
for the SSD-based configuration.
SSD and SmartArray array accelerator cache
For HP SmartArray controllers, the Array Accelerator cache module typically delivers significant
performance improvements for logical volumes consisting of traditional disk drives. The dramatic
decreases in latency for both writes and read hits far exceed the processing overhead for determining
cache hits and misses on reads and for aggregating cached writes. When the logical volume consists
of SSDs, this may not be the case.
For logical volumes consisting of SSDs, we generally recommend disabling the array accelerator cache.
The overhead of the cache lookup typically outweighs the more marginal latency gains that the
accelerator cache provides over the SSDs’ natively low latencies. This guideline is not absolute. Some
applications may actually benefit from using the array accelerator, and in those cases, the most
advantageous cache ratio is usually 0% read/100% write. But nearly all synthetic benchmarks will
show better performance with the array accelerator disabled.
With SSDs and SmartArray controllers, you should still install a cache memory module even if you don’t
activate the array accelerator function. Without the memory module installed, the array controller
operates in Zero Memory RAID mode (ZMR). In ZMR, the controller code runs from non-volatile memory










