What are you looking for?
< All Topics
Print

How Industrial SSDs May Use 3D TLC NAND Flash to Create SLC-Like Endurance

Introduction

This article will discusses these frequently asked questions of Virtium industrial SSD customers:

“With the higher cost of SLC NAND, is there another solution using more prevalent and available lower cost TLC NAND? The big question is, can a high-endurance SSD be created using cheaper and much lower endurance NAND? Is it possible to make a TLC drive last as long as a SLC one? What trade-offs can be made to make this true?”

Here we will be reviewing pertinent data and engineering considerations to respond to these important SLC vs TLC questions.

Test Data: TLC vs. SLC

Below are design parameters for SLC vs TLC:

Looking at the design parameters above, there are two key programming and provisioning techniques under consideration:

  1. Using TLC in pSLC mode – Programming a TLC cell with a single bit improves endurance of the cell to 20,000 P/E cycles. The trade-off is that approximately 67% of the total available density is forfeited in this mode.
  2. Over Provisioning (OP) – By deploying more TLC flash memory than is required for a given SSD memory density, the Write operations to the flash are also reduced, leading to a higher endurance.

Let’s consider how this would work in a 8GB industrial SSD example using TLC flash memory:

  1. Use 64GB of TLC flash memory in pSLC mode, which results in 64GB divided by 3, or 21.3 GB of programmable-accessible flash.
  2. OP this 21.3GB of flash down to the 8GB of defined flash that is presented to the user.

In this example, there are nearly 3-times (3X) the amount of raw flash memory needed to make an 8GB SSD. With respect to flash memory programming, definitions of Pages and Blocks are offered:

  • Blocks – Smallest unit that can be erased – 4-8MB size
  • Pages – Smallest unit that can be programmed/written – 8-16KB size

Based on these definitions, a Block will contain a range from 256-Pages up to 1,024-Pages. Note that a Block cannot be erased until all its Pages have “Invalid Data” within them.

Figure 1 graphically depicts an example of 3-Blocks of flash using these data provisioning principals.

Figure 2 describes rewriting Data 1-3. With flash, you cannot perform an erase until the Block has no valid data in it, so you must Write to a new location and invalidate the former ones:

When we rewrite Data 4-9 as shown in Figure 3, note that there are not enough empty Blocks to accomplish this, so we must move some data to enable this. One approach is to move the data from the first Block to the remaining Blocks, then we can fully erase the first Block:

Figure 4 shows the rewrite of Data 4-6. Yet if we write Data 7-9, we run out of space once again, so we move NewData1 and NewData3 from Block 2 to Block 1 and produce another Invalid Block:

Now we can rewrite Data 7-9, but we will run out of space once again. Therefore, we will move data from Block 3 and move it to Block 2 to make another Invalid Block as shown in Figure 5:

From this exercise, we see the importance of having OP. This becomes the “spare area” used to reduce the amount of internal data copies to create new Blocks, which can be written to. The greater the spare area available, the less often one would need to move this data to free-up Blocks. This action improves performance as well as reducing Write operations to the flash, directly increasing SSD endurance. Write Amplification (WA) is the number of writes to the flash memory over the amount of writes by the actual user to the SSD.

The previous flash programming example provided a basis for a large amount of OP, which is key to increasing the reliability of a TLC-based industrial SSD. This, in turn, decreases the WA to the flash substantially. With a Random Workload, a standard SLC-based industrial SSD, which uses 8GB of flash to produce an 8GB drive will have to perform 10-20 internal Writes for every user Write to the flash. As previously described, when there is insufficient page space, the flash controller must rewrite data many times to create empty Blocks to write new data. By having 100,000 P/E cycles but doing 10 writes for each user write, it effectively decreases the user’s endurance to 10,000 P/E cycles.

In our example, with nearly 3X over provisioning, the TLC-based industrial SSD under random workload conditions will occasionally need to rewrite data, but it is more likely to occur after we have written to all the Blocks that entire Blocks will be completely invalidated without having to internally move data. The reduction in extra Writes to the drive is essential to developing a TLC-based industrial SSD with comparable reliability as its legacy SLC-based alternative. The 20,000 P/E cycles may all be assigned to actual user Writes with minimal loss due to internal flash management operations.

A Sequential Workload,